├── .gitignore
├── .dir-locals.el
├── v8-sys
    ├── src
    │   ├── v8-trampoline.h
    │   ├── lib.rs
    │   ├── v8-glue.h
    │   └── v8-glue.cc
    ├── Cargo.toml
    └── build.rs
├── .editorconfig
├── examples
    └── hello-world.rs
├── v8-api
    ├── src
    │   ├── bin
    │   │   └── v8-api-rs-parse.rs
    │   └── lib.rs
    └── Cargo.toml
├── Cargo.toml
├── src
    ├── allocator.rs
    ├── context.rs
    ├── script.rs
    ├── platform.rs
    ├── template.rs
    ├── util.rs
    ├── error.rs
    ├── isolate.rs
    └── lib.rs
├── .travis.yml
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | target
2 | Cargo.lock
3 | *.bk
4 | 


--------------------------------------------------------------------------------
/.dir-locals.el:
--------------------------------------------------------------------------------
1 | ((rust-mode . ((fill-column . 100))))
2 | 


--------------------------------------------------------------------------------
/v8-sys/src/v8-trampoline.h:
--------------------------------------------------------------------------------
1 | // v8-trampoline.h: includes the files containing the V8 APIs we want
2 | // to wrap.
3 | #include <v8.h>
4 | #include <v8-platform.h>
5 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | end_of_line = lf
 5 | indent_style = space
 6 | insert_final_newline = true
 7 | trim_trailing_whitespace = true
 8 | 
 9 | [*.rs]
10 | indent_size = 4
11 | 
12 | [*.js]
13 | indent_size = 2
14 | 


--------------------------------------------------------------------------------
/v8-sys/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![allow(non_camel_case_types)]
 2 | #![allow(non_snake_case)]
 3 | #![allow(non_upper_case_globals)]
 4 | 
 5 | #[cfg(test)]
 6 | #[macro_use]
 7 | extern crate lazy_static;
 8 | 
 9 | include!(concat!(env!("OUT_DIR"), "/ffi.rs"));
10 | 
11 | pub use ffi::*;
12 | 


--------------------------------------------------------------------------------
/examples/hello-world.rs:
--------------------------------------------------------------------------------
 1 | extern crate v8;
 2 | 
 3 | use v8::value;
 4 | 
 5 | fn main() {
 6 |     let isolate = v8::Isolate::new();
 7 |     let context = v8::Context::new(&isolate);
 8 | 
 9 |     let source = value::String::from_str(&isolate, "'Hello, ' + 'World!'");
10 |     let script = v8::Script::compile(&isolate, &context, &source).unwrap();
11 | 
12 |     let result = script.run(&context).unwrap();
13 |     let result_str = result.to_string(&context);
14 | 
15 |     println!("{}", result_str.value());
16 | }
17 | 


--------------------------------------------------------------------------------
/v8-api/src/bin/v8-api-rs-parse.rs:
--------------------------------------------------------------------------------
 1 | extern crate env_logger;
 2 | extern crate v8_api;
 3 | 
 4 | use std::env;
 5 | use std::path;
 6 | 
 7 | fn main() {
 8 |     env_logger::init().unwrap();
 9 | 
10 |     let header_file_path = if let Some(path) = env::args_os().nth(1) {
11 |         path::PathBuf::from(path)
12 |     } else if let Some(path) = env::var_os("V8_SOURCE") {
13 |         path::PathBuf::from(path).join("include").join("v8.h")
14 |     } else {
15 |         path::Path::new("/usr/include/v8.h").to_path_buf()
16 |     };
17 | 
18 |     print!("{}", v8_api::read(&header_file_path, &[] as &[&path::Path]));
19 | }
20 | 


--------------------------------------------------------------------------------
/v8-api/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | authors = ["David Flemström <david.flemstrom@gmail.com>"]
 3 | description = "A parser for v8.h files to extract a description of the V8 API heuristically.  Used in build scripts, for example in v8-sys."
 4 | homepage = "https://dflemstr.github.io/v8-rs"
 5 | keywords = ["v8", "javascript", "api"]
 6 | license = "Apache-2.0"
 7 | name = "v8-api"
 8 | repository = "https://github.com/dflemstr/v8-rs/tree/master/v8-api"
 9 | version = "0.7.3"
10 | 
11 | [dependencies]
12 | env_logger = "0.4.0"
13 | log = "0.3.6"
14 | 
15 | [dependencies.clang]
16 | features = ["clang_3_5", "runtime"]
17 | version = "0.15.0"
18 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | authors = ["David Flemström <david.flemstrom@gmail.com>"]
 3 | description = "High-level bindings to V8, the Javascript engine"
 4 | documentation = "https://dflemstr.github.io/v8-rs/v8/index.html"
 5 | homepage = "https://dflemstr.github.io/v8-rs"
 6 | keywords = ["v8", "javascript", "js", "ecmascript", "google"]
 7 | license = "Apache-2.0"
 8 | name = "v8"
 9 | repository = "https://github.com/dflemstr/v8-rs"
10 | version = "0.9.6"
11 | 
12 | [dependencies]
13 | error-chain = "0.9.0"
14 | lazy_static = "0.2.1"
15 | num_cpus = "1.1.0"
16 | 
17 | [dependencies.v8-sys]
18 | path = "v8-sys"
19 | version = "0.14.0"
20 | 
21 | [features]
22 | shared = ["v8-sys/shared"]
23 | unstable = []
24 | 


--------------------------------------------------------------------------------
/v8-sys/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | authors = ["David Flemström <david.flemstrom@gmail.com>"]
 3 | build = "build.rs"
 4 | description = "Low-level bindings to V8, the Javascript engine"
 5 | documentation = "https://dflemstr.github.io/v8-rs/v8_sys/index.html"
 6 | homepage = "https://dflemstr.github.io/v8-rs"
 7 | include = ["build.rs", "src/**/*", "Cargo.toml"]
 8 | keywords = ["v8", "javascript", "js", "ecmascript", "google"]
 9 | license = "Apache-2.0"
10 | name = "v8-sys"
11 | repository = "https://github.com/dflemstr/v8-rs/tree/master/v8-sys"
12 | version = "0.14.7"
13 | 
14 | [build-dependencies]
15 | bindgen = "0.22.0"
16 | gcc = "0.3.38"
17 | pkg-config = "0.3.8"
18 | 
19 | [build-dependencies.clang]
20 | features = ["runtime"]
21 | version = "0.15.0"
22 | 
23 | [build-dependencies.clang-sys]
24 | features = ["runtime"]
25 | version = "0.14.0"
26 | 
27 | [build-dependencies.v8-api]
28 | path = "../v8-api"
29 | version = "0.7.0"
30 | 
31 | [dev-dependencies]
32 | lazy_static = "0.2.1"
33 | 
34 | [features]
35 | shared = []
36 | 


--------------------------------------------------------------------------------
/src/allocator.rs:
--------------------------------------------------------------------------------
 1 | //! Allocators for array buffers.
 2 | use v8_sys as v8;
 3 | 
 4 | use std::os;
 5 | use std::mem;
 6 | 
 7 | /// A simple array buffer allocator that guarantees that all allocated
 8 | /// blocks are coercible to `Vec`s.
 9 | #[derive(Debug)]
10 | pub struct Allocator(v8::ArrayBuffer_AllocatorPtr);
11 | 
12 | impl Allocator {
13 |     /// Creates a new allocator.
14 |     pub fn new() -> Allocator {
15 |         let raw = unsafe { v8::v8_ArrayBuffer_Allocator_Create(ALLOCATOR_FUNCTIONS) };
16 |         if raw.is_null() {
17 |             panic!("Could not create ArrayBuffer::Allocator");
18 |         }
19 | 
20 |         Allocator(raw)
21 |     }
22 | 
23 |     /// Returns the underlying raw pointer behind this allocator.
24 |     pub fn as_raw(&self) -> v8::ArrayBuffer_AllocatorPtr {
25 |         self.0
26 |     }
27 | }
28 | 
29 | impl Drop for Allocator {
30 |     fn drop(&mut self) {
31 |         unsafe {
32 |             v8::v8_ArrayBuffer_Allocator_Destroy(self.0);
33 |         }
34 |     }
35 | }
36 | 
37 | const ALLOCATOR_FUNCTIONS: v8::v8_AllocatorFunctions = v8::v8_AllocatorFunctions {
38 |     Allocate: Some(allocate),
39 |     AllocateUninitialized: Some(allocate_uninitialized),
40 |     Free: Some(free),
41 | };
42 | 
43 | extern "C" fn allocate(length: usize) -> *mut os::raw::c_void {
44 |     let mut data = Vec::with_capacity(length);
45 |     data.resize(length, 0u8);
46 |     let ptr = data.as_mut_ptr();
47 |     mem::forget(data);
48 | 
49 |     ptr as *mut os::raw::c_void
50 | }
51 | 
52 | extern "C" fn allocate_uninitialized(length: usize) -> *mut os::raw::c_void {
53 |     let mut data = Vec::with_capacity(length);
54 | 
55 |     unsafe {
56 |         data.set_len(length);
57 |     }
58 | 
59 |     let ptr = data.as_mut_ptr();
60 |     mem::forget(data);
61 | 
62 |     ptr as *mut os::raw::c_void
63 | }
64 | 
65 | unsafe extern "C" fn free(data: *mut os::raw::c_void, length: usize) {
66 |     // TODO: restore `cap` here?  Can this possibly leak memory?
67 |     drop(Vec::from_raw_parts(data, length, length));
68 | }
69 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: true
 2 | dist: trusty
 3 | language: rust
 4 | 
 5 | addons:
 6 |   apt:
 7 |     sources:
 8 |       - sourceline: 'ppa:pinepain/libv8-5.4'
 9 |       - ubuntu-toolchain-r-test
10 |     packages:
11 |       # Modern compilers
12 |       - gcc-6
13 |       - g++-6
14 |       # The V8 version that we want to bind
15 |       - libv8-5.4-dev
16 |       - libicu-dev
17 |       # Dependencies for travis-cargo and for coverage
18 |       - libcurl4-openssl-dev
19 |       - libelf-dev
20 |       - libdw-dev
21 |       - binutils-dev
22 | 
23 | matrix:
24 |   include:
25 |     - env: FEATURES="" CC=gcc-6 CXX=g++-6
26 |       rust: stable
27 |       os: linux
28 |     - env: FEATURES="--features=shared" CC=gcc-6 CXX=g++-6
29 |       rust: stable
30 |       os: linux
31 |     - env: FEATURES="--features=shared"
32 |       rust: stable
33 |       os: osx
34 |       osx_image: xcode8
35 |     - env: FEATURES="" CC=gcc-6 CXX=g++-6
36 |       rust: nightly
37 |       os: linux
38 |     - env: FEATURES="--features=shared" CC=gcc-6 CXX=g++-6
39 |       rust: nightly
40 |       os: linux
41 |   allow_failures:
42 |     - rust: nightly
43 | 
44 | before_install:
45 |   - |
46 |       if [ "$TRAVIS_OS_NAME" = osx ]
47 |       then
48 |         brew tap dflemstr/tools
49 |         brew update
50 |         brew install -v dflemstr/tools/v8
51 |       fi
52 | 
53 | before_script:
54 |   - |
55 |       pip install 'travis-cargo<0.2' --user &&
56 |       export PATH=$HOME/.local/bin:$HOME/Library/Python/2.7/bin:$PATH
57 | 
58 | script:
59 |   - |
60 |       travis-cargo build -- $FEATURES &&
61 |       travis-cargo test -- $FEATURES &&
62 |       travis-cargo bench -- $FEATURES
63 | 
64 | after_success:
65 |   - |
66 |     if [ -z "$FEATURES" ]; then travis-cargo --only stable doc; travis-cargo --only stable doc-upload; fi
67 |     wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz &&
68 |     tar xzf master.tar.gz &&
69 |     cd kcov-master &&
70 |     mkdir build &&
71 |     cd build &&
72 |     cmake .. &&
73 |     make &&
74 |     sudo make install &&
75 |     cd ../.. &&
76 |     rm -rf kcov-master &&
77 |     RUSTFLAGS='-C link-dead-code' cargo test $FEATURES --no-run &&
78 |     for file in target/debug/v8-*
79 |     do
80 |         kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov" "$file"
81 |     done &&
82 |     bash <(curl -s https://codecov.io/bash) &&
83 |     echo "Uploaded code coverage"
84 | 


--------------------------------------------------------------------------------
/src/context.rs:
--------------------------------------------------------------------------------
 1 | //! Execution contexts and sandboxing.
 2 | use v8_sys as v8;
 3 | use isolate;
 4 | use util;
 5 | use value;
 6 | 
 7 | /// A sandboxed execution context with its own set of built-in objects and functions.
 8 | #[derive(Debug)]
 9 | pub struct Context(isolate::Isolate, v8::ContextRef);
10 | 
11 | /// A guard that keeps a context bound while it is in scope.
12 | #[must_use]
13 | pub struct ContextGuard<'a>(&'a Context);
14 | 
15 | impl Context {
16 |     /// Creates a new context and returns a handle to the newly allocated context.
17 |     pub fn new(isolate: &isolate::Isolate) -> Context {
18 |         unsafe {
19 |             Context(isolate.clone(),
20 |                     util::invoke(isolate, |c| v8::v8_Context_New(c)).unwrap())
21 |         }
22 |     }
23 | 
24 |     /// Binds the context to the current scope.
25 |     ///
26 |     /// Within this scope, functionality that relies on implicit contexts will work.
27 |     pub fn make_current(&self) -> ContextGuard {
28 |         self.enter();
29 |         ContextGuard(self)
30 |     }
31 | 
32 |     fn enter(&self) {
33 |         unsafe { util::invoke(&self.0, |c| v8::v8_Context_Enter(c, self.1)).unwrap() }
34 |     }
35 | 
36 |     fn exit(&self) {
37 |         unsafe { util::invoke(&self.0, |c| v8::v8_Context_Exit(c, self.1)).unwrap() }
38 |     }
39 | 
40 |     /// Returns the global proxy object.
41 |     ///
42 |     /// Global proxy object is a thin wrapper whose prototype points to actual context's global
43 |     /// object with the properties like Object, etc. This is done that way for security reasons (for
44 |     /// more details see https://wiki.mozilla.org/Gecko:SplitWindow).
45 |     ///
46 |     /// Please note that changes to global proxy object prototype most probably would break VM---v8
47 |     /// expects only global object as a prototype of global proxy object.
48 |     ///
49 |     pub fn global(&self) -> value::Object {
50 |         unsafe {
51 |             value::Object::from_raw(&self.0,
52 |                                     util::invoke(&self.0, |c| v8::v8_Context_Global(c, self.1))
53 |                                         .unwrap())
54 |         }
55 |     }
56 | 
57 |     /// Creates a context from a set of raw pointers.
58 |     pub unsafe fn from_raw(isolate: &isolate::Isolate, raw: v8::ContextRef) -> Context {
59 |         Context(isolate.clone(), raw)
60 |     }
61 | 
62 |     /// Returns the underlying raw pointer behind this context.
63 |     pub fn as_raw(&self) -> v8::ContextRef {
64 |         self.1
65 |     }
66 | }
67 | 
68 | reference!(Context, v8::v8_Context_CloneRef, v8::v8_Context_DestroyRef);
69 | 
70 | impl<'a> Drop for ContextGuard<'a> {
71 |     fn drop(&mut self) {
72 |         self.0.exit()
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/script.rs:
--------------------------------------------------------------------------------
 1 | //! Script and source code compilation, execution, origins and management.
 2 | use v8_sys as v8;
 3 | 
 4 | use context;
 5 | use error;
 6 | use isolate;
 7 | use value;
 8 | use util;
 9 | 
10 | /// A compiled JavaScript script, tied to a Context which was active when the script was compiled.
11 | #[derive(Debug)]
12 | pub struct Script(isolate::Isolate, v8::ScriptRef);
13 | 
14 | impl Script {
15 |     /// Compiles the specified source code into a compiled script.
16 |     pub fn compile(isolate: &isolate::Isolate,
17 |                    context: &context::Context,
18 |                    source: &value::String)
19 |                    -> error::Result<Script> {
20 |         let raw = unsafe {
21 |             try!(util::invoke_ctx(isolate,
22 |                                   context,
23 |                                   |c| v8::v8_Script_Compile(c, context.as_raw(), source.as_raw())))
24 |         };
25 |         Ok(Script(isolate.clone(), raw))
26 |     }
27 | 
28 |     /// Compiles the specified source code into a compiled script.
29 |     ///
30 |     /// The specified name will be reported as the script's origin and will show up in stack traces,
31 |     /// for example.
32 |     pub fn compile_with_name(isolate: &isolate::Isolate,
33 |                              context: &context::Context,
34 |                              name: &value::Value,
35 |                              source: &value::String)
36 |                              -> error::Result<Script> {
37 |         use std::ptr::null_mut as n;
38 |         let raw = unsafe {
39 |             try!(util::invoke_ctx(isolate, context, |c| {
40 |                 v8::v8_Script_Compile_Origin(c,
41 |                                           context.as_raw(),
42 |                                           source.as_raw(),
43 |                                           name.as_raw(),
44 |                                           n(),
45 |                                           n(),
46 |                                           n(),
47 |                                           n(),
48 |                                           n(),
49 |                                           n(),
50 |                                           n())
51 |             }))
52 |         };
53 |         Ok(Script(isolate.clone(), raw))
54 |     }
55 | 
56 |     /// Runs this script in the specified context.
57 |     ///
58 |     /// If the script returns a value, meaning that the last line of the script evaluates to an
59 |     /// expression or there is an explicit return, that value will be returned from this method.  If
60 |     /// the script throws an exception, that will reslt in this method also throwing an exception.
61 |     pub fn run(&self, context: &context::Context) -> error::Result<value::Value> {
62 |         unsafe {
63 |             let raw = try!(util::invoke_ctx(&self.0,
64 |                                             context,
65 |                                             |c| v8::v8_Script_Run(c, self.1, context.as_raw())));
66 |             Ok(value::Value::from_raw(&self.0, raw))
67 |         }
68 |     }
69 | }
70 | 
71 | reference!(Script, v8::v8_Script_CloneRef, v8::v8_Script_DestroyRef);
72 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # `v8-rs` [![Build Status](https://travis-ci.org/dflemstr/v8-rs.svg?branch=master)](https://travis-ci.org/dflemstr/v8-rs) [![Crates.io](https://img.shields.io/crates/v/v8.svg?maxAge=3600)](https://crates.io/crates/v8) [![codecov](https://codecov.io/gh/dflemstr/v8-rs/branch/master/graph/badge.svg)](https://codecov.io/gh/dflemstr/v8-rs) [![Language (Rust)](https://img.shields.io/badge/powered_by-Rust-blue.svg)](http://www.rust-lang.org/)
 2 | 
 3 | **Note:** This library is not actively maintained.  I (dflemstr) have
 4 | attempted keeping it up to date with the latest mainline V8 versions,
 5 | but the maintenance burden is too high.  The path forward would be to
 6 | more directly map the C++ API of V8 via `bindgen` and go forward from
 7 | there to try to automate more of the API surface mapping, but several
 8 | attempts at doing so by me have failed.  Pull requests welcome!
 9 | 
10 | This is a wrapper around the [V8](https://developers.google.com/v8/)
11 | Javascript engine, used for example in
12 | the [Google Chrome browser](https://www.google.com/chrome/browser)
13 | or [Node.js](https://nodejs.org/en/).
14 | 
15 | [Documentation](https://dflemstr.github.io/v8-rs)
16 | 
17 | ## Building
18 | 
19 | It is quite complicated to build V8.  This library has been tested
20 | against V8 5.4.x with GCC 6.x, but later versions might work.
21 | 
22 | ### Static / Shared
23 | 
24 | By default, this library links V8 statically.  There is a feature
25 | called `shared` that builds it by linking to `libv8.so` (and related
26 | libraries like `libicu-i10n.so`) instead.  There's usually little
27 | reason to link dynamically since the V8 ABI changes fairly frequently.
28 | 
29 | ### Ubuntu / Travis CI
30 | 
31 | The easiest way to build this library on Ubuntu or Travis CI is to use
32 | a pre-packaged version of V8.  You need both `sudo` and Ubuntu Trusty
33 | or later to install a compatible one:
34 | 
35 | ``` yaml
36 | sudo: true
37 | dist: trusty
38 | language: rust
39 | 
40 | addons:
41 |   apt:
42 |     sources:
43 |       - sourceline: 'ppa:pinepain/libv8-5.4'
44 |       - ubuntu-toolchain-r-test
45 |     packages:
46 |       # Modern compilers
47 |       - gcc-6
48 |       - g++-6
49 |       # The V8 version that we want to bind
50 |       - libv8-5.4-dev
51 |       - libicu-dev
52 | 
53 | env:
54 |   global:
55 |     - CC=gcc-6
56 |     - CXX=g++-6
57 | ```
58 | 
59 | ### Build tree
60 | 
61 | You can build a build tree using any supported build method that uses
62 | any combination of `depot_tools`, `make`, `gyp`, `ninja` and/or `gn`,
63 | but `gn` hasn't been tested that extensively.
64 | 
65 | You should set `v8_use_snapshot=false`, loading snapshots is currently
66 | not supported.
67 | 
68 | You should also not disable `i10n` support; this library assumes
69 | `libicu` was built at the same time as V8 or is compatible with V8.
70 | 
71 | You should build using `shared_library` if you want to build with the
72 | `shared` feature.
73 | 
74 | Simply set the environment variable `V8_SOURCE` to the root of the
75 | `v8` checkout, and `V8_BUILD` to the build output in the tree (for
76 | example `$V8_SOURCE/out/Release`) and the build Should Work®.  If not,
77 | please figure out how to fix it and send a PR, it'll be impossible for
78 | me to test all of the V8 build configurations :)
79 | 


--------------------------------------------------------------------------------
/src/platform.rs:
--------------------------------------------------------------------------------
  1 | use v8_sys as v8;
  2 | use std::thread;
  3 | use std::time;
  4 | use num_cpus;
  5 | use isolate;
  6 | 
  7 | lazy_static! {
  8 |     static ref START_TIME: time::Instant = {
  9 |         time::Instant::now()
 10 |     };
 11 | }
 12 | 
 13 | /// A simple platform implementation that uses global OS threads for
 14 | /// scheduling.
 15 | // TODO: make this use some kind of main loop/work stealing queue
 16 | // instead.
 17 | #[derive(Debug)]
 18 | pub struct Platform(v8::PlatformPtr);
 19 | 
 20 | #[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
 21 | pub struct Task(v8::TaskPtr);
 22 | 
 23 | unsafe impl Send for Task {}
 24 | 
 25 | #[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
 26 | pub struct IdleTask(v8::IdleTaskPtr);
 27 | 
 28 | impl Platform {
 29 |     pub fn new() -> Platform {
 30 |         let raw = unsafe { v8::v8_Platform_Create(PLATFORM_FUNCTIONS) };
 31 | 
 32 |         if raw.is_null() {
 33 |             panic!("Could not create Platform")
 34 |         }
 35 | 
 36 |         Platform(raw)
 37 |     }
 38 | 
 39 |     pub fn as_raw(&self) -> v8::PlatformPtr {
 40 |         self.0
 41 |     }
 42 | }
 43 | 
 44 | impl Drop for Platform {
 45 |     fn drop(&mut self) {
 46 |         unsafe {
 47 |             v8::v8_Platform_Destroy(self.0);
 48 |         }
 49 |     }
 50 | }
 51 | 
 52 | impl Task {
 53 |     pub fn run(&self) {
 54 |         unsafe {
 55 |             v8::v8_Task_Run(self.0);
 56 |         }
 57 |     }
 58 | }
 59 | 
 60 | impl Drop for Task {
 61 |     fn drop(&mut self) {
 62 |         unsafe {
 63 |             v8::v8_Task_Destroy(self.0);
 64 |         }
 65 |     }
 66 | }
 67 | 
 68 | impl IdleTask {
 69 |     pub fn run(&self, deadline: time::Duration) {
 70 |         unsafe {
 71 |             v8::v8_IdleTask_Run(self.0, duration_to_seconds(deadline));
 72 |         }
 73 |     }
 74 | }
 75 | 
 76 | impl Drop for IdleTask {
 77 |     fn drop(&mut self) {
 78 |         unsafe {
 79 |             v8::v8_IdleTask_Destroy(self.0);
 80 |         }
 81 |     }
 82 | }
 83 | 
 84 | const PLATFORM_FUNCTIONS: v8::v8_PlatformFunctions = v8::v8_PlatformFunctions {
 85 |     Destroy: Some(destroy_platform),
 86 |     NumberOfAvailableBackgroundThreads: Some(number_of_available_background_threads),
 87 |     CallOnBackgroundThread: Some(call_on_background_thread),
 88 |     CallOnForegroundThread: Some(call_on_foreground_thread),
 89 |     CallDelayedOnForegroundThread: Some(call_delayed_on_foreground_thread),
 90 |     CallIdleOnForegroundThread: Some(call_idle_on_foreground_thread),
 91 |     IdleTasksEnabled: Some(idle_tasks_enabled),
 92 |     MonotonicallyIncreasingTime: Some(monotonically_increasing_time),
 93 | };
 94 | 
 95 | extern "C" fn destroy_platform() {
 96 |     // No-op
 97 | }
 98 | 
 99 | extern "C" fn number_of_available_background_threads() -> usize {
100 |     num_cpus::get()
101 | }
102 | 
103 | extern "C" fn call_on_background_thread(task: v8::TaskPtr,
104 |                                         _expected_runtime: v8::v8_ExpectedRuntime) {
105 |     let task = Task(task);
106 |     thread::spawn(move || {
107 |         unsafe {
108 |             v8::v8_Task_Run(task.0);
109 |         }
110 |     });
111 | }
112 | 
113 | extern "C" fn call_on_foreground_thread(isolate: v8::IsolatePtr, task: v8::TaskPtr) {
114 |     let task = Task(task);
115 |     let isolate = unsafe { isolate::Isolate::from_raw(isolate) };
116 | 
117 |     isolate.enqueue_task(task);
118 | }
119 | 
120 | extern "C" fn call_delayed_on_foreground_thread(isolate: v8::IsolatePtr,
121 |                                                 task: v8::TaskPtr,
122 |                                                 delay_in_seconds: f64) {
123 |     let task = Task(task);
124 |     let isolate = unsafe { isolate::Isolate::from_raw(isolate) };
125 |     let duration = duration_from_seconds(delay_in_seconds);
126 | 
127 |     isolate.enqueue_delayed_task(duration, task);
128 | }
129 | 
130 | extern "C" fn call_idle_on_foreground_thread(isolate: v8::IsolatePtr, idle_task: v8::IdleTaskPtr) {
131 |     let idle_task = IdleTask(idle_task);
132 |     let isolate = unsafe { isolate::Isolate::from_raw(isolate) };
133 | 
134 |     isolate.enqueue_idle_task(idle_task);
135 | }
136 | 
137 | extern "C" fn idle_tasks_enabled(isolate: v8::IsolatePtr) -> bool {
138 |     let isolate = unsafe { isolate::Isolate::from_raw(isolate) };
139 | 
140 |     isolate.supports_idle_tasks()
141 | }
142 | 
143 | extern "C" fn monotonically_increasing_time() -> f64 {
144 |     let start = *START_TIME;
145 |     let d = time::Instant::now().duration_since(start);
146 |     duration_to_seconds(d)
147 | }
148 | 
149 | fn duration_to_seconds(duration: time::Duration) -> f64 {
150 |     (duration.subsec_nanos() as f64).mul_add(1e-9, duration.as_secs() as f64)
151 | }
152 | 
153 | fn duration_from_seconds(seconds: f64) -> time::Duration {
154 |     time::Duration::new(seconds as u64, (seconds.fract() * 1e9) as u32)
155 | }
156 | 


--------------------------------------------------------------------------------
/src/template.rs:
--------------------------------------------------------------------------------
  1 | //! Templates for constructing functions and objects efficiently.
  2 | use v8_sys as v8;
  3 | use isolate;
  4 | use util;
  5 | use value;
  6 | use value::Data;
  7 | use context;
  8 | use std::os;
  9 | use std::ptr;
 10 | use std::mem;
 11 | use std::ops;
 12 | use std::ffi;
 13 | 
 14 | /// The superclass of object and function templates.
 15 | #[derive(Debug)]
 16 | pub struct Template(isolate::Isolate, v8::TemplateRef);
 17 | 
 18 | /// A FunctionTemplate is used to create functions at runtime.
 19 | ///
 20 | /// There can only be one function created from a FunctionTemplate in a context.  Any modification
 21 | /// of a FunctionTemplate after first instantiation will trigger a crash.  A FunctionTemplate can
 22 | /// have properties, these properties are added to the function object when it is created.
 23 | #[derive(Debug)]
 24 | pub struct FunctionTemplate(isolate::Isolate, v8::FunctionTemplateRef);
 25 | 
 26 | /// An ObjectTemplate is used to create objects at runtime.
 27 | ///
 28 | /// Properties added to an ObjectTemplate are added to each object created from the ObjectTemplate.
 29 | #[derive(Debug)]
 30 | pub struct ObjectTemplate(isolate::Isolate, v8::ObjectTemplateRef);
 31 | 
 32 | /// A Signature specifies which receiver is valid for a function.
 33 | #[derive(Debug)]
 34 | pub struct Signature(isolate::Isolate, v8::SignatureRef);
 35 | 
 36 | impl Signature {
 37 |     /// Creates a new signature.
 38 |     pub fn new(isolate: &isolate::Isolate) -> Signature {
 39 |         let raw = unsafe {
 40 |             util::invoke(isolate,
 41 |                          |c| v8::v8_Signature_New(c, isolate.as_raw(), ptr::null_mut()))
 42 |                 .unwrap()
 43 |         };
 44 |         Signature(isolate.clone(), raw)
 45 |     }
 46 | 
 47 |     /// Creates a new signature with the specified receiver.
 48 |     pub fn new_with_receiver(isolate: &isolate::Isolate, receiver: &FunctionTemplate) -> Signature {
 49 |         let raw = unsafe {
 50 |             util::invoke(isolate,
 51 |                          |c| v8::v8_Signature_New(c, isolate.as_raw(), receiver.1))
 52 |                 .unwrap()
 53 |         };
 54 |         Signature(isolate.clone(), raw)
 55 |     }
 56 | }
 57 | 
 58 | impl FunctionTemplate {
 59 |     /// Creates a function template.
 60 |     pub fn new(isolate: &isolate::Isolate,
 61 |                context: &context::Context,
 62 |                callback: Box<value::FunctionCallback>)
 63 |                -> FunctionTemplate {
 64 |         let raw = unsafe {
 65 |             let callback_ptr = Box::into_raw(Box::new(callback));
 66 |             let callback_ext = value::External::new::<Box<value::FunctionCallback>>(&isolate, callback_ptr);
 67 | 
 68 |             let template = ObjectTemplate::new(isolate);
 69 |             template.set_internal_field_count(1);
 70 | 
 71 |             let closure = template.new_instance(context);
 72 |             closure.set_internal_field(0, &callback_ext);
 73 | 
 74 |             util::invoke_ctx(isolate, context, |c| {
 75 |                     v8::v8_FunctionTemplate_New(c,
 76 |                                              context.as_raw(),
 77 |                                              Some(util::callback),
 78 |                                              (&closure as &value::Value).as_raw(),
 79 |                                              ptr::null_mut(),
 80 |                                              0,
 81 |                                              v8::ConstructorBehavior::ConstructorBehavior_kAllow)
 82 |                 })
 83 |                 .unwrap()
 84 |         };
 85 |         FunctionTemplate(isolate.clone(), raw)
 86 |     }
 87 | 
 88 |     /// Returns the unique function instance in the current execution context.
 89 |     pub fn get_function(self, context: &context::Context) -> value::Function {
 90 |         unsafe {
 91 |             let raw = util::invoke_ctx(&self.0, context, |c| {
 92 |                     v8::v8_FunctionTemplate_GetFunction(c, self.1, context.as_raw())
 93 |                 })
 94 |                 .unwrap();
 95 |             value::Function::from_raw(&self.0, raw)
 96 |         }
 97 |     }
 98 | }
 99 | 
100 | impl ObjectTemplate {
101 |     /// Creates an ObjectTemplate.
102 |     pub fn new(isolate: &isolate::Isolate) -> ObjectTemplate {
103 |         let raw = unsafe {
104 |             util::invoke(isolate,
105 |                          |c| v8::v8_ObjectTemplate_New(c, isolate.as_raw(), ptr::null_mut()))
106 |                 .unwrap()
107 |         };
108 |         ObjectTemplate(isolate.clone(), raw)
109 |     }
110 | 
111 |     /// Sets the number of internal fields for objects generated from this template.
112 |     pub fn set_internal_field_count(&self, value: usize) {
113 |         unsafe {
114 |             util::invoke(&self.0, |c| {
115 |                     v8::v8_ObjectTemplate_SetInternalFieldCount(c, self.1, value as os::raw::c_int)
116 |                 })
117 |                 .unwrap()
118 |         };
119 |     }
120 | 
121 |     pub fn set(&self, name: &str, value: &value::Data) {
122 |         let cname = ffi::CString::new(name).unwrap();
123 |         let template: &Template = self;
124 |         unsafe {
125 |             util::invoke(&self.0, |c| {
126 |                     v8::v8_Template_Set_Raw(c,
127 |                                          template.1,
128 |                                          self.0.as_raw(),
129 |                                          mem::transmute(cname.as_ptr()),
130 |                                          value.as_raw())
131 |                 })
132 |                 .unwrap()
133 |         };
134 |     }
135 | 
136 |     /// Creates a new object instance based off of this template.
137 |     pub fn new_instance(&self, context: &context::Context) -> value::Object {
138 |         unsafe {
139 |             let raw = util::invoke_ctx(&self.0, context, |c| {
140 |                     v8::v8_ObjectTemplate_NewInstance(c, self.1, context.as_raw())
141 |                 })
142 |                 .unwrap();
143 |             value::Object::from_raw(&self.0, raw)
144 |         }
145 |     }
146 | 
147 |     /// Creates an object template from a set of raw pointers.
148 |     pub unsafe fn from_raw(isolate: &isolate::Isolate,
149 |                            raw: v8::ObjectTemplateRef)
150 |                            -> ObjectTemplate {
151 |         ObjectTemplate(isolate.clone(), raw)
152 |     }
153 | 
154 |     /// Returns the underlying raw pointer behind this object template.
155 |     pub fn as_raw(&self) -> v8::ObjectTemplateRef {
156 |         self.1
157 |     }
158 | }
159 | 
160 | inherit!(Template, Data);
161 | inherit!(ObjectTemplate, Template);
162 | inherit!(FunctionTemplate, Template);
163 | inherit!(Signature, Data);
164 | 
165 | reference!(Template, v8::v8_Template_CloneRef, v8::v8_Template_DestroyRef);
166 | reference!(FunctionTemplate,
167 |            v8::v8_FunctionTemplate_CloneRef,
168 |            v8::v8_FunctionTemplate_DestroyRef);
169 | reference!(ObjectTemplate,
170 |            v8::v8_ObjectTemplate_CloneRef,
171 |            v8::v8_ObjectTemplate_DestroyRef);
172 | reference!(Signature, v8::v8_Signature_CloneRef, v8::v8_Signature_DestroyRef);
173 | 


--------------------------------------------------------------------------------
/src/util.rs:
--------------------------------------------------------------------------------
  1 | use v8_sys as v8;
  2 | use context;
  3 | use error;
  4 | use isolate;
  5 | use std::any;
  6 | use std::mem;
  7 | use std::panic;
  8 | use std::ptr;
  9 | use value;
 10 | 
 11 | pub fn invoke<F, B>(isolate: &isolate::Isolate, func: F) -> error::Result<B>
 12 |     where F: FnOnce(v8::RustContext) -> B
 13 | {
 14 |     invoke_inner(isolate, None, func)
 15 | }
 16 | 
 17 | pub fn invoke_ctx<F, B>(isolate: &isolate::Isolate,
 18 |                         context: &context::Context,
 19 |                         func: F)
 20 |                         -> error::Result<B>
 21 |     where F: FnOnce(v8::RustContext) -> B
 22 | {
 23 |     invoke_inner(isolate, Some(context), func)
 24 | }
 25 | 
 26 | fn invoke_inner<F, B>(isolate: &isolate::Isolate,
 27 |                       context: Option<&context::Context>,
 28 |                       func: F)
 29 |                       -> error::Result<B>
 30 |     where F: FnOnce(v8::RustContext) -> B
 31 | {
 32 |     let mut exception = ptr::null_mut();
 33 |     let mut message = ptr::null_mut();
 34 |     let rust_ctx = v8::RustContext {
 35 |         isolate: isolate.as_raw(),
 36 |         exception: &mut exception,
 37 |         message: &mut message,
 38 |     };
 39 | 
 40 |     let result = func(rust_ctx);
 41 | 
 42 |     if exception.is_null() {
 43 |         assert!(message.is_null());
 44 |         Ok(result)
 45 |     } else {
 46 |         assert!(!message.is_null());
 47 |         let exception = unsafe { value::Value::from_raw(isolate, exception) };
 48 |         let message = unsafe { error::Message::from_raw(isolate, message) };
 49 |         let context = context.map(|c| c.clone())
 50 |             .or_else(|| isolate.current_context())
 51 |             .unwrap_or_else(|| context::Context::new(&isolate));
 52 | 
 53 |         if exception.is_object() {
 54 |             let exception = exception.into_object().unwrap();
 55 |             let panic_info_key = value::String::from_str(isolate, "panicInfo");
 56 | 
 57 |             if exception.has(&context, &panic_info_key) {
 58 |                 match exception.get(&context, &panic_info_key).into_external() {
 59 |                     Some(panic_info) => {
 60 |                         let panic_info =
 61 |                             unsafe {
 62 |                                 Box::from_raw(panic_info.value() as *mut Box<any::Any + Send + 'static>)
 63 |                             };
 64 |                         panic::resume_unwind(panic_info);
 65 |                     }
 66 |                     None => {
 67 |                         // Somebody is playing tricks on us, creating random panicInfo properties...
 68 |                     }
 69 |                 }
 70 |             }
 71 |         }
 72 | 
 73 |         let message_str = message.get(&context).value();
 74 |         let stack_trace = message.get_stack_trace().to_captured();
 75 |         Err(error::ErrorKind::Javascript(message_str, stack_trace).into())
 76 |     }
 77 | }
 78 | 
 79 | pub extern "C" fn callback(callback_info: v8::FunctionCallbackInfoPtr_Value) {
 80 |     unsafe {
 81 |         let callback_info = callback_info.as_mut().unwrap();
 82 |         let isolate = isolate::Isolate::from_raw(callback_info.GetIsolate);
 83 |         let data = value::Object::from_raw(&isolate, callback_info.Data as v8::ObjectRef);
 84 | 
 85 |         let length = callback_info.Length as isize;
 86 |         let args = (0..length)
 87 |             .map(|i| value::Value::from_raw(&isolate, *callback_info.Args.offset(i)))
 88 |             .collect();
 89 |         let info = value::FunctionCallbackInfo {
 90 |             isolate: isolate.clone(),
 91 |             length: length,
 92 |             args: args,
 93 |             this: value::Object::from_raw(&isolate, callback_info.This),
 94 |             holder: value::Object::from_raw(&isolate, callback_info.Holder),
 95 |             new_target: value::Value::from_raw(&isolate, callback_info.NewTarget),
 96 |             is_construct_call: callback_info.IsConstructCall,
 97 |         };
 98 | 
 99 |         let result = panic::catch_unwind(|| {
100 |             let callback_ext = data.get_internal_field(0).into_external().unwrap();
101 |             let callback_ptr: *mut Box<value::FunctionCallback> = callback_ext.value();
102 |             let callback = callback_ptr.as_ref().unwrap();
103 |             callback(info)
104 |         });
105 | 
106 |         match result {
107 |             Ok(value) => {
108 |                 let result = value.unwrap_or_else(|exception| throw_exception(&isolate, &exception));
109 |                 callback_info.ReturnValue = result.as_raw();
110 |                 mem::forget(result);
111 |             }
112 |             Err(panic) => {
113 |                 let error = create_panic_error(&isolate, panic);
114 |                 callback_info.ThrownValue = error.as_raw();
115 |                 mem::forget(error);
116 |             }
117 |         }
118 |     }
119 | }
120 | 
121 | fn throw_exception(isolate: &isolate::Isolate, exception: &value::Value) -> value::Value {
122 |     unsafe {
123 |         let raw = v8::v8_Isolate_ThrowException(isolate.as_raw(), exception.as_raw()).as_mut().unwrap();
124 |         ::value::Value::from_raw(isolate, raw)
125 |     }
126 | }
127 | 
128 | fn create_panic_error(isolate: &isolate::Isolate,
129 |                       panic: Box<any::Any + Send + 'static>)
130 |                       -> value::Value {
131 |     let context = isolate.current_context()
132 |         .unwrap_or_else(|| context::Context::new(&isolate));
133 |     let message = if let Some(s) = panic.downcast_ref::<String>() {
134 |         value::String::from_str(&isolate, &format!("Rust panic: {}", s))
135 |     } else {
136 |         value::String::from_str(&isolate, "Rust panic")
137 |     };
138 | 
139 |     let exception = value::Exception::error(&isolate, &message).into_object().unwrap();
140 | 
141 |     let panic_info_key = value::String::from_str(isolate, "panicInfo");
142 |     let panic_info = unsafe { value::External::new(&isolate, Box::into_raw(Box::new(panic))) };
143 |     exception.set(&context, &panic_info_key, &panic_info);
144 | 
145 |     exception.into()
146 | }
147 | 
148 | macro_rules! reference {
149 |     ($typ:ident, $clone:expr, $dtor:expr) => {
150 |         impl Clone for $typ {
151 |             fn clone(&self) -> $typ {
152 |                 let raw = unsafe { $crate::util::invoke(&self.0, |c| $clone(c, self.1)).unwrap() };
153 |                 $typ(self.0.clone(), raw)
154 |             }
155 |         }
156 | 
157 |         impl Drop for $typ {
158 |             fn drop(&mut self) {
159 |                 // SAFETY: This is unsafe because it calls a native method with a void pointer.
160 |                 // It's safe because the macro is only used with a type and its corresponding
161 |                 // destructor.
162 |                 unsafe {
163 |                     $dtor(self.1)
164 |                 }
165 |             }
166 |         }
167 |     }
168 | }
169 | 
170 | macro_rules! subtype {
171 |     ($child:ident, $parent:ident) => {
172 |         impl From<$child> for $parent {
173 |             fn from(child: $child) -> $parent {
174 |                 unsafe { mem::transmute(child) }
175 |             }
176 |         }
177 |     }
178 | }
179 | 
180 | macro_rules! inherit {
181 |     ($child:ident, $parent:ident) => {
182 |         subtype!($child, $parent);
183 | 
184 |         impl ops::Deref for $child {
185 |             type Target = $parent;
186 | 
187 |             fn deref(&self) -> &Self::Target {
188 |                 unsafe { mem::transmute(self) }
189 |             }
190 |         }
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------
/src/error.rs:
--------------------------------------------------------------------------------
  1 | //! Error types and utilities.
  2 | 
  3 | use std::fmt;
  4 | use v8_sys as v8;
  5 | use context;
  6 | use isolate;
  7 | use util;
  8 | use value;
  9 | 
 10 | error_chain! {
 11 |     errors {
 12 |         Javascript(message: String, stack_trace: CapturedStackTrace) {
 13 |             description("Javascript exception")
 14 |             display("Javascript exception: {}\n{}", message, stack_trace)
 15 |         }
 16 |     }
 17 | }
 18 | 
 19 | /// A captured stack trace, that is separated from its underlying isolate.
 20 | #[derive(Clone, Debug)]
 21 | pub struct CapturedStackTrace {
 22 |     pub frames: Vec<CapturedStackFrame>,
 23 | }
 24 | 
 25 | /// A captured stack frame, that is separated from its underlying isolate.
 26 | #[derive(Clone, Debug)]
 27 | pub struct CapturedStackFrame {
 28 |     pub line: u32,
 29 |     pub column: u32,
 30 |     pub script_name: Option<String>,
 31 |     pub function_name: Option<String>,
 32 |     pub is_eval: bool,
 33 |     pub is_constructor: bool,
 34 | }
 35 | 
 36 | /// An error message.
 37 | #[derive(Debug)]
 38 | pub struct Message(isolate::Isolate, v8::MessageRef);
 39 | 
 40 | /// A stack trace, that is bound to an isolate.
 41 | #[derive(Debug)]
 42 | pub struct StackTrace(isolate::Isolate, v8::StackTraceRef);
 43 | 
 44 | /// A stack frame, that is bound to an isolate.
 45 | #[derive(Debug)]
 46 | pub struct StackFrame(isolate::Isolate, v8::StackFrameRef);
 47 | 
 48 | impl Message {
 49 |     // TODO: pub fn get_script_origin(&self)
 50 | 
 51 |     /// The error message string.
 52 |     pub fn get(&self, context: &context::Context) -> value::String {
 53 |         let _g = context.make_current();
 54 |         unsafe {
 55 |             value::String::from_raw(&self.0,
 56 |                                     util::invoke_ctx(&self.0,
 57 |                                                      context,
 58 |                                                      |c| v8::v8_Message_Get(c, self.1))
 59 |                                         .unwrap())
 60 |         }
 61 |     }
 62 | 
 63 |     /// The stack trace to the point where the error was generated.
 64 |     pub fn get_stack_trace(&self) -> StackTrace {
 65 |         let raw =
 66 |             unsafe { util::invoke(&self.0, |c| v8::v8_Message_GetStackTrace(c, self.1)).unwrap() };
 67 | 
 68 |         StackTrace(self.0.clone(), raw)
 69 |     }
 70 | 
 71 |     pub unsafe fn from_raw(isolate: &isolate::Isolate, raw: v8::MessageRef) -> Message {
 72 |         Message(isolate.clone(), raw)
 73 |     }
 74 | }
 75 | 
 76 | impl StackTrace {
 77 |     /// The stack frames that this stack trace consists of.
 78 |     pub fn get_frames(&self) -> Vec<StackFrame> {
 79 |         let count =
 80 |             unsafe { util::invoke(&self.0, |c| v8::v8_StackTrace_GetFrameCount(c, self.1)).unwrap() };
 81 |         let mut result = Vec::with_capacity(count as usize);
 82 | 
 83 |         for i in 0..count {
 84 |             let raw_frame = unsafe {
 85 |                 util::invoke(&self.0, |c| v8::v8_StackTrace_GetFrame(c, self.1, i as u32)).unwrap()
 86 |             };
 87 |             let frame = StackFrame(self.0.clone(), raw_frame);
 88 |             result.push(frame);
 89 |         }
 90 | 
 91 |         result
 92 |     }
 93 | 
 94 |     /// Creates a captured version of this stack trace, that doesn't retain a reference to its
 95 |     /// isolate.
 96 |     pub fn to_captured(&self) -> CapturedStackTrace {
 97 |         CapturedStackTrace {
 98 |             frames: self.get_frames()
 99 |                 .iter()
100 |                 .map(StackFrame::to_captured)
101 |                 .collect(),
102 |         }
103 |     }
104 | }
105 | 
106 | impl StackFrame {
107 |     /// The line number at which this stack frame was pushed.
108 |     pub fn get_line_number(&self) -> u32 {
109 |         unsafe {
110 |             util::invoke(&self.0, |c| v8::v8_StackFrame_GetLineNumber(c, self.1)).unwrap() as u32
111 |         }
112 |     }
113 | 
114 |     /// The column number at which this stack frame was pushed.
115 |     pub fn get_column(&self) -> u32 {
116 |         unsafe { util::invoke(&self.0, |c| v8::v8_StackFrame_GetColumn(c, self.1)).unwrap() as u32 }
117 |     }
118 | 
119 |     /// The script file name in which this stack frame was pushed.
120 |     pub fn get_script_name(&self) -> Option<value::String> {
121 |         unsafe {
122 |             let raw = util::invoke(&self.0, |c| v8::v8_StackFrame_GetScriptName(c, self.1)).unwrap();
123 |             if raw.is_null() {
124 |                 None
125 |             } else {
126 |                 Some(value::String::from_raw(&self.0, raw))
127 |             }
128 |         }
129 |     }
130 | 
131 |     /// The function name in which this stack frame was pushed.
132 |     pub fn get_function_name(&self) -> value::String {
133 |         unsafe {
134 |             let raw = util::invoke(&self.0, |c| v8::v8_StackFrame_GetFunctionName(c, self.1)).unwrap();
135 |             value::String::from_raw(&self.0, raw)
136 |         }
137 |     }
138 | 
139 |     /// Whether this stack frame is part of an eval call.
140 |     pub fn is_eval(&self) -> bool {
141 |         unsafe { util::invoke(&self.0, |c| v8::v8_StackFrame_IsEval(c, self.1)).unwrap() }
142 |     }
143 | 
144 |     /// Whether this stack frame is part of a constructor call.
145 |     pub fn is_constructor(&self) -> bool {
146 |         unsafe { util::invoke(&self.0, |c| v8::v8_StackFrame_IsConstructor(c, self.1)).unwrap() }
147 |     }
148 | 
149 |     /// Creates a captured version of this stack frame, that doesn't retain a reference to its
150 |     /// isolate.
151 |     pub fn to_captured(&self) -> CapturedStackFrame {
152 |         let function_name = self.get_function_name().value();
153 |         CapturedStackFrame {
154 |             line: self.get_line_number(),
155 |             column: self.get_column(),
156 |             script_name: self.get_script_name().map(|ref s| s.value()),
157 |             function_name: if function_name.is_empty() {
158 |                 None
159 |             } else {
160 |                 Some(function_name)
161 |             },
162 |             is_eval: self.is_eval(),
163 |             is_constructor: self.is_constructor(),
164 |         }
165 |     }
166 | }
167 | 
168 | impl fmt::Display for CapturedStackTrace {
169 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
170 |         for frame in self.frames.iter() {
171 |             try!(writeln!(f, "{}", frame));
172 |         }
173 |         Ok(())
174 |     }
175 | }
176 | 
177 | impl fmt::Display for CapturedStackFrame {
178 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
179 |         try!(write!(f, "    at "));
180 | 
181 |         if self.is_constructor {
182 |             try!(write!(f, "new "));
183 |         }
184 | 
185 |         if let Some(ref function_name) = self.function_name {
186 |             try!(write!(f, "{} (", function_name));
187 | 
188 |             if self.is_eval {
189 |                 try!(write!(f, "eval "));
190 |             }
191 | 
192 |             try!(write!(f,
193 |                         "{}:{}:{})",
194 |                         self.script_name.as_ref().map(|n| n.as_str()).unwrap_or("<anon>"),
195 |                         self.line,
196 |                         self.column));
197 |         } else {
198 |             if self.is_eval {
199 |                 try!(write!(f, "eval "));
200 |             }
201 |             try!(write!(f,
202 |                         "{}:{}:{}",
203 |                         self.script_name.as_ref().map(|n| n.as_str()).unwrap_or("<anon>"),
204 |                         self.line,
205 |                         self.column));
206 |         }
207 | 
208 |         Ok(())
209 |     }
210 | }
211 | 
212 | reference!(Message, v8::v8_Message_CloneRef, v8::v8_Message_DestroyRef);
213 | reference!(StackTrace,
214 |            v8::v8_StackTrace_CloneRef,
215 |            v8::v8_StackTrace_DestroyRef);
216 | reference!(StackFrame,
217 |            v8::v8_StackFrame_CloneRef,
218 |            v8::v8_StackFrame_DestroyRef);
219 | 


--------------------------------------------------------------------------------
/src/isolate.rs:
--------------------------------------------------------------------------------
  1 | //! Heap and execution isolation.
  2 | //!
  3 | //! # Usage
  4 | //!
  5 | //! Construct a new isolate with default settings by doing `Isolate::new()`.  You can customize the
  6 | //! isolate settings by using `Isolate::builder()`.
  7 | //!
  8 | //! # Foreground tasks
  9 | //!
 10 | //! Javascript can produce "deferred" or "time-outed" tasks that need to run on the main thread.
 11 | //! Additionally, V8 has a bunch of internal tasks it wants to perform regularly (for example GC).
 12 | //! The user should therefore call `isolate.run_enqueued_tasks()` regularly to allow these tasks to
 13 | //! run.
 14 | //!
 15 | //! # Background tasks
 16 | //!
 17 | //! Javascript and V8 can trigger various background tasks to run.  These will be run as simple
 18 | //! background OS threads, while trying to keep the number of running background tasks less than the
 19 | //! number of available CPUs.
 20 | //!
 21 | //! # Idle tasks
 22 | //!
 23 | //! V8 can perform various maintenance tasks if the application has nothing better to do.  If the
 24 | //! user wants to allow this to happen, an isolate should be constructed with
 25 | //! `Isolate::builder().supports_idle_tasks(true).build()`.  The user should then regularly call
 26 | //! `isolate.run_idle_tasks(deadline)` to run any pending idle tasks.
 27 | 
 28 | use std::cmp;
 29 | use std::collections;
 30 | use std::mem;
 31 | use std::os;
 32 | use std::sync;
 33 | use std::time;
 34 | use v8_sys as v8;
 35 | use allocator;
 36 | use context;
 37 | use platform;
 38 | 
 39 | static INITIALIZE: sync::Once = sync::ONCE_INIT;
 40 | 
 41 | /// Isolate represents an isolated instance of the V8 engine.
 42 | ///
 43 | /// V8 isolates have completely separate states.  Objects from one isolate must not be used in other
 44 | /// isolates.  The embedder can create multiple isolates and use them in parallel in multiple
 45 | /// threads.  An isolate can be entered by at most one thread at any given time.  The
 46 | /// Locker/Unlocker API must be used to synchronize.
 47 | #[derive(Debug)]
 48 | pub struct Isolate(v8::IsolatePtr);
 49 | 
 50 | /// A builder for isolates.  Can be converted into an isolate with the `build` method.
 51 | pub struct Builder {
 52 |     supports_idle_tasks: bool,
 53 | }
 54 | 
 55 | #[derive(Debug)]
 56 | struct Data {
 57 |     count: usize,
 58 |     _allocator: allocator::Allocator,
 59 |     task_queue: collections::BinaryHeap<ScheduledTask>,
 60 |     idle_task_queue: Option<collections::VecDeque<platform::IdleTask>>,
 61 | }
 62 | 
 63 | #[derive(Debug, Eq, PartialEq)]
 64 | struct ScheduledTask(time::Instant, platform::Task);
 65 | 
 66 | const DATA_PTR_SLOT: u32 = 0;
 67 | 
 68 | impl Isolate {
 69 |     /// Creates a new isolate.
 70 |     pub fn new() -> Isolate {
 71 |         Isolate::builder().build()
 72 |     }
 73 | 
 74 |     /// Creates a new isolate builder.
 75 |     pub fn builder() -> Builder {
 76 |         Builder { supports_idle_tasks: false }
 77 |     }
 78 | 
 79 |     /// Creates a data from a set of raw pointers.
 80 |     ///
 81 |     /// This isolate must at some point have been created by `Isolate::new`, since this library
 82 |     /// expects isolates to be configured a certain way and contain embedder information.
 83 |     pub unsafe fn from_raw(raw: v8::IsolatePtr) -> Isolate {
 84 |         let result = Isolate(raw);
 85 |         result.get_data().count += 1;
 86 |         result
 87 |     }
 88 | 
 89 |     /// Returns the underlying raw pointer behind this isolate.
 90 |     pub fn as_raw(&self) -> v8::IsolatePtr {
 91 |         self.0
 92 |     }
 93 | 
 94 |     /// Returns the context bound to the current thread for this isolate.
 95 |     ///
 96 |     /// A context will be bound by for example `Context::make_current`, or while inside of a
 97 |     /// function callback.
 98 |     pub fn current_context(&self) -> Option<context::Context> {
 99 |         unsafe {
100 |             let raw = v8::v8_Isolate_GetCurrentContext(self.as_raw()).as_mut();
101 |             raw.map(|r| context::Context::from_raw(self, r))
102 |         }
103 |     }
104 | 
105 |     /// Runs all enqueued tasks until there are no more tasks available.
106 |     pub fn run_enqueued_tasks(&self) {
107 |         while self.run_enqueued_task() {}
108 |     }
109 | 
110 |     /// Runs a single enqueued task, if there is one.  Returns `true` if a task was executed, and
111 |     /// `false` if there are no pending tasks to run.
112 |     pub fn run_enqueued_task(&self) -> bool {
113 |         let data = unsafe { self.get_data() };
114 |         let now = time::Instant::now();
115 | 
116 |         if data.task_queue.peek().map(|t| t.0 > now).unwrap_or(false) {
117 |             let task = data.task_queue.pop().unwrap().1;
118 |             task.run();
119 |             true
120 |         } else {
121 |             false
122 |         }
123 |     }
124 | 
125 |     /// Runs as many idle tasks as possible within the specified deadline.  It is not guaranteed
126 |     /// that the execution of the tasks will take less time than the specified deadline.
127 |     pub fn run_idle_tasks(&self, deadline: time::Duration) {
128 |         let deadline = time::Instant::now() + deadline;
129 | 
130 |         loop {
131 |             let now = time::Instant::now();
132 | 
133 |             if now > deadline {
134 |                 break;
135 |             }
136 | 
137 |             self.run_idle_task(deadline - now);
138 |         }
139 |     }
140 | 
141 |     /// Runs a single idle task within the specified deadline.  It is not guaranteed that the
142 |     /// execution of the task will take less time than the specified deadline.  Returns `true` if a
143 |     /// task was executed, and `false` if there are no pending tasks to run.
144 |     pub fn run_idle_task(&self, deadline: time::Duration) -> bool {
145 |         let data = unsafe { self.get_data() };
146 | 
147 |         if let Some(idle_task) = data.idle_task_queue
148 |             .as_mut()
149 |             .map(|q| q.pop_front())
150 |             .unwrap_or(None) {
151 |             idle_task.run(deadline);
152 |             true
153 |         } else {
154 |             false
155 |         }
156 |     }
157 | 
158 |     /// Enqueues the specified task to run as soon as possible.
159 |     pub fn enqueue_task(&self, task: platform::Task) {
160 |         let scheduled_task = ScheduledTask(time::Instant::now(), task);
161 |         unsafe { self.get_data() }.task_queue.push(scheduled_task);
162 |     }
163 | 
164 |     /// Enqueues the specified task to run after the specified delay has passed.
165 |     pub fn enqueue_delayed_task(&self, delay: time::Duration, task: platform::Task) {
166 |         let scheduled_task = ScheduledTask(time::Instant::now() + delay, task);
167 |         unsafe { self.get_data() }.task_queue.push(scheduled_task);
168 |     }
169 | 
170 |     /// Enqueues a task to be run when the isolate is considered to be "idle."
171 |     pub fn enqueue_idle_task(&self, idle_task: platform::IdleTask) {
172 |         unsafe { self.get_data() }.idle_task_queue.as_mut().unwrap().push_back(idle_task);
173 |     }
174 | 
175 |     /// Whether this isolate was configured to support idle tasks.
176 |     pub fn supports_idle_tasks(&self) -> bool {
177 |         unsafe { self.get_data() }.idle_task_queue.is_some()
178 |     }
179 | 
180 |     unsafe fn get_data_ptr(&self) -> *mut Data {
181 |         v8::v8_Isolate_GetData(self.0, DATA_PTR_SLOT) as *mut Data
182 |     }
183 | 
184 |     unsafe fn get_data(&self) -> &mut Data {
185 |         self.get_data_ptr().as_mut().unwrap()
186 |     }
187 | }
188 | 
189 | impl Clone for Isolate {
190 |     fn clone(&self) -> Isolate {
191 |         unsafe {
192 |             self.get_data().count += 1;
193 |         }
194 |         Isolate(self.0)
195 |     }
196 | }
197 | 
198 | impl Drop for Isolate {
199 |     fn drop(&mut self) {
200 |         unsafe {
201 |             let ref mut count = self.get_data().count;
202 |             *count -= 1;
203 | 
204 |             if *count == 0 {
205 |                 drop(Box::from_raw(self.get_data_ptr()));
206 |                 v8::v8_Isolate_Dispose(self.0);
207 |             }
208 |         }
209 |     }
210 | }
211 | 
212 | impl Builder {
213 |     /// Whether the isolate should support idle tasks; i.e. whether the user will call
214 |     /// `run_idle_tasks` regularly.
215 |     pub fn supports_idle_tasks(mut self, value: bool) -> Builder {
216 |         self.supports_idle_tasks = value;
217 |         self
218 |     }
219 | 
220 |     /// Constructs a new `Isolate` based on this builder.
221 |     pub fn build(self) -> Isolate {
222 |         ensure_initialized();
223 | 
224 |         let allocator = allocator::Allocator::new();
225 | 
226 |         let raw = unsafe { v8::v8_Isolate_New(allocator.as_raw()) };
227 |         if raw.is_null() {
228 |             panic!("Could not create Isolate");
229 |         }
230 | 
231 |         unsafe {
232 |             assert!(v8::v8_Isolate_GetNumberOfDataSlots(raw) > 0);
233 |         }
234 | 
235 |         let idle_task_queue = if self.supports_idle_tasks {
236 |             Some(collections::VecDeque::new())
237 |         } else {
238 |             None
239 |         };
240 | 
241 |         let data = Data {
242 |             count: 1,
243 |             _allocator: allocator,
244 |             task_queue: collections::BinaryHeap::new(),
245 |             idle_task_queue: idle_task_queue,
246 |         };
247 |         let data_ptr: *mut Data = Box::into_raw(Box::new(data));
248 | 
249 |         unsafe {
250 |             v8::v8_Isolate_SetData(raw, DATA_PTR_SLOT, data_ptr as *mut os::raw::c_void);
251 |             v8::v8_Isolate_SetCaptureStackTraceForUncaughtExceptions_Detailed(raw, true, 1024);
252 |         }
253 | 
254 |         Isolate(raw)
255 |     }
256 | }
257 | 
258 | impl PartialOrd for ScheduledTask {
259 |     fn partial_cmp(&self, other: &ScheduledTask) -> Option<cmp::Ordering> {
260 |         Some(self.cmp(other))
261 |     }
262 | }
263 | 
264 | impl Ord for ScheduledTask {
265 |     fn cmp(&self, other: &ScheduledTask) -> cmp::Ordering {
266 |         self.0.cmp(&other.0).reverse()
267 |     }
268 | }
269 | 
270 | fn ensure_initialized() {
271 |     INITIALIZE.call_once(|| {
272 |         unsafe {
273 |             v8::v8_V8_InitializeICU();
274 | 
275 |             let platform = platform::Platform::new();
276 |             v8::v8_V8_InitializePlatform(platform.as_raw());
277 |             // TODO: implement some form of cleanup
278 |             mem::forget(platform);
279 | 
280 |             v8::v8_V8_Initialize();
281 |         }
282 |     });
283 | }
284 | 


--------------------------------------------------------------------------------
/v8-sys/src/v8-glue.h:
--------------------------------------------------------------------------------
  1 | #if defined __cplusplus
  2 | 
  3 | #include <v8.h>
  4 | #include <v8-platform.h>
  5 | 
  6 | extern "C" {
  7 | #else
  8 | 
  9 | #include <stdbool.h>
 10 | #include <stddef.h>
 11 | #include <stdint.h>
 12 | 
 13 | #endif /* defined __cplusplus */
 14 | 
 15 | /* A context passed in from Rust that handles isolation and exception
 16 |    handling.
 17 |  */
 18 | struct RustContext;
 19 | typedef struct RustContext RustContext;
 20 | 
 21 | /* Structs for "maybes" containing primitives */
 22 | #define STRUCT_MAYBE_PRIM(PRIM, SUFFIX)         \
 23 |     struct Maybe##SUFFIX {                      \
 24 |         bool is_set;                            \
 25 |         PRIM value;                             \
 26 |     };                                          \
 27 |     typedef struct Maybe##SUFFIX Maybe##SUFFIX;
 28 | 
 29 | STRUCT_MAYBE_PRIM(bool, Bool);
 30 | STRUCT_MAYBE_PRIM(unsigned int, UInt);
 31 | STRUCT_MAYBE_PRIM(int, Int);
 32 | STRUCT_MAYBE_PRIM(unsigned long, ULong);
 33 | STRUCT_MAYBE_PRIM(long, Long);
 34 | STRUCT_MAYBE_PRIM(double, F64);
 35 | STRUCT_MAYBE_PRIM(uint32_t, U32);
 36 | STRUCT_MAYBE_PRIM(int32_t, I32);
 37 | STRUCT_MAYBE_PRIM(uint64_t, U64);
 38 | STRUCT_MAYBE_PRIM(int64_t, I64);
 39 | 
 40 | /* Very special classes that we don't want to auto-map. */
 41 | #if defined __cplusplus
 42 | typedef v8::ArrayBuffer::Allocator *ArrayBuffer_AllocatorPtr;
 43 | #else
 44 | typedef struct _ArrayBuffer_Allocator *ArrayBuffer_AllocatorPtr;
 45 | #endif /* defined __cplusplus */
 46 | 
 47 | #if defined __cplusplus
 48 | typedef v8::Isolate *IsolatePtr;
 49 | #else
 50 | typedef struct _Isolate *IsolatePtr;
 51 | #endif /* defined __cplusplus */
 52 | 
 53 | #if defined __cplusplus
 54 | typedef v8::Platform *PlatformPtr;
 55 | #else
 56 | typedef struct _Platform *PlatformPtr;
 57 | #endif /* defined __cplusplus */
 58 | 
 59 | #if defined __cplusplus
 60 | typedef v8::Task *TaskPtr;
 61 | #else
 62 | typedef struct _Task *TaskPtr;
 63 | #endif /* defined __cplusplus */
 64 | 
 65 | #if defined __cplusplus
 66 | typedef v8::IdleTask *IdleTaskPtr;
 67 | #else
 68 | typedef struct _IdleTask *IdleTaskPtr;
 69 | #endif /* defined __cplusplus */
 70 | 
 71 | /* Special structs simulating vtables */
 72 | struct v8_AllocatorFunctions {
 73 |     void *(*Allocate)(size_t length);
 74 |     void *(*AllocateUninitialized)(size_t length);
 75 |     void (*Free)(void *data, size_t length);
 76 | };
 77 | typedef struct v8_AllocatorFunctions v8_AllocatorFunctions;
 78 | 
 79 | enum v8_ExpectedRuntime {
 80 |     SHORT_RUNNING_TASK,
 81 |     LONG_RUNNING_TASK,
 82 | };
 83 | 
 84 | struct v8_PlatformFunctions {
 85 |     void (*Destroy)();
 86 |     size_t (*NumberOfAvailableBackgroundThreads)();
 87 |     void (*CallOnBackgroundThread)(TaskPtr task, enum v8_ExpectedRuntime expected_runtime);
 88 |     void (*CallOnForegroundThread)(IsolatePtr isolate, TaskPtr task);
 89 |     void (*CallDelayedOnForegroundThread)(IsolatePtr isolate, TaskPtr task, double delay_in_seconds);
 90 |     void (*CallIdleOnForegroundThread)(IsolatePtr isolate, IdleTaskPtr task);
 91 |     bool (*IdleTasksEnabled)(IsolatePtr isolate);
 92 |     double (*MonotonicallyIncreasingTime)();
 93 | };
 94 | typedef struct v8_PlatformFunctions v8_PlatformFunctions;
 95 | 
 96 | /* Copy-paste of enums */
 97 | 
 98 | enum AccessControl {
 99 |     AccessControl_DEFAULT               = 0,
100 |     AccessControl_ALL_CAN_READ          = 1,
101 |     AccessControl_ALL_CAN_WRITE         = 1 << 1,
102 |     AccessControl_PROHIBITS_OVERWRITING = 1 << 2
103 | };
104 | typedef enum AccessControl AccessControl;
105 | 
106 | enum PropertyFilter {
107 |     PropertyFilter_ALL_PROPERTIES = 0,
108 |     PropertyFilter_ONLY_WRITABLE = 1,
109 |     PropertyFilter_ONLY_ENUMERABLE = 2,
110 |     PropertyFilter_ONLY_CONFIGURABLE = 4,
111 |     PropertyFilter_SKIP_STRINGS = 8,
112 |     PropertyFilter_SKIP_SYMBOLS = 16
113 | };
114 | typedef enum PropertyFilter PropertyFilter;
115 | 
116 | enum KeyCollectionMode {
117 |     KeyCollectionMode_kOwnOnly,
118 |     KeyCollectionMode_kIncludePrototypes
119 | };
120 | typedef enum KeyCollectionMode KeyCollectionMode;
121 | 
122 | enum IndexFilter {
123 |     IndexFilter_kIncludeIndices,
124 |     IndexFilter_kSkipIndices
125 | };
126 | typedef enum IndexFilter IndexFilter;
127 | 
128 | enum IntegrityLevel {
129 |     IntegrityLevel_kFrozen,
130 |     IntegrityLevel_kSealed
131 | };
132 | typedef enum IntegrityLevel IntegrityLevel;
133 | 
134 | enum PropertyAttribute {
135 |     PropertyAttribute_Absent = -1, /* Instead of Maybe<PropertyAttribute> */
136 |     PropertyAttribute_None = 0,
137 |     PropertyAttribute_ReadOnly = 1 << 0,
138 |     PropertyAttribute_DontEnum = 1 << 1,
139 |     PropertyAttribute_DontDelete = 1 << 2,
140 | };
141 | typedef enum PropertyAttribute PropertyAttribute;
142 | 
143 | enum PropertyHandlerFlags {
144 |     PropertyHandlerFlags_kNone = 0,
145 |     PropertyHandlerFlags_kAllCanRead = 1,
146 |     PropertyHandlerFlags_kNonMasking = 1 << 1,
147 |     PropertyHandlerFlags_kOnlyInterceptStrings = 1 << 2,
148 | };
149 | typedef enum PropertyHandlerFlags PropertyHandlerFlags;
150 | 
151 | enum ConstructorBehavior {
152 |     ConstructorBehavior_kThrow,
153 |     ConstructorBehavior_kAllow
154 | };
155 | typedef enum ConstructorBehavior ConstructorBehavior;
156 | 
157 | enum PromiseRejectEvent {
158 |     PromiseRejectEvent_kPromiseRejectWithNoHandler = 0,
159 |     PromiseRejectEvent_kPromiseHandlerAddedAfterReject = 1
160 | };
161 | typedef enum PromiseRejectEvent PromiseRejectEvent;
162 | 
163 | #define V8_INTRINSICS_LIST(F) F(ArrayProto_values, array_values_iterator)
164 | 
165 | enum Intrinsic {
166 | #define V8_DECL_INTRINSIC(name, iname) Intrinsic_k##name,
167 |     V8_INTRINSICS_LIST(V8_DECL_INTRINSIC)
168 | #undef V8_DECL_INTRINSIC
169 | };
170 | typedef enum Intrinsic Intrinsic;
171 | 
172 | enum ArrayBufferCreationMode {
173 |     ArrayBufferCreationMode_kInternalized,
174 |     ArrayBufferCreationMode_kExternalized
175 | };
176 | typedef enum ArrayBufferCreationMode ArrayBufferCreationMode;
177 | 
178 | /* Auto-generated forward declarations for class pointers */
179 | #include "v8-glue-decl-generated.h"
180 | 
181 | struct PropertyCallbackInfo {
182 |     IsolatePtr GetIsolate;
183 |     ValueRef Data;
184 |     ObjectRef This;
185 |     ObjectRef Holder;
186 |     ValueRef ReturnValue;
187 |     bool ShouldThrowOnError;
188 |     ValueRef ThrownValue;
189 | };
190 | 
191 | struct FunctionCallbackInfo {
192 |     int Length;
193 |     ValueRef *Args;
194 |     ObjectRef This;
195 |     ObjectRef Holder;
196 |     ValueRef NewTarget;
197 |     bool IsConstructCall;
198 |     ValueRef Data;
199 |     IsolatePtr GetIsolate;
200 |     ValueRef ReturnValue;
201 |     ValueRef ThrownValue;
202 | };
203 | 
204 | /* These typedefs are just here to give a nicer hint to the user as to
205 |    which type of return value is expected to be set.  For the `Void`
206 |    variant, the SetReturnValue function should not be called.
207 | */
208 | 
209 | typedef struct PropertyCallbackInfo *PropertyCallbackInfoPtr_Void;
210 | typedef struct PropertyCallbackInfo *PropertyCallbackInfoPtr_Value;
211 | typedef struct PropertyCallbackInfo *PropertyCallbackInfoPtr_Boolean;
212 | typedef struct PropertyCallbackInfo *PropertyCallbackInfoPtr_Integer;
213 | typedef struct PropertyCallbackInfo *PropertyCallbackInfoPtr_Array;
214 | typedef struct FunctionCallbackInfo *FunctionCallbackInfoPtr_Value;
215 | 
216 | typedef void (*AccessorGetterCallback)(
217 |     StringRef property,
218 |     PropertyCallbackInfoPtr_Value info);
219 | 
220 | typedef void (*AccessorNameGetterCallback)(
221 |     NameRef property,
222 |     PropertyCallbackInfoPtr_Value info);
223 | 
224 | typedef void (*AccessorSetterCallback)(
225 |     StringRef property,
226 |     ValueRef value,
227 |     PropertyCallbackInfoPtr_Void info);
228 | 
229 | typedef void (*AccessorNameSetterCallback)(
230 |     NameRef property,
231 |     ValueRef value,
232 |     PropertyCallbackInfoPtr_Void info);
233 | 
234 | typedef void (*FunctionCallback)(
235 |     FunctionCallbackInfoPtr_Value info);
236 | 
237 | typedef void (*NamedPropertyGetterCallback)(
238 |     StringRef property,
239 |     PropertyCallbackInfoPtr_Value info);
240 | 
241 | typedef void (*NamedPropertySetterCallback)(
242 |     StringRef property,
243 |     ValueRef value,
244 |     PropertyCallbackInfoPtr_Value info);
245 | 
246 | typedef void (*NamedPropertyQueryCallback)(
247 |     StringRef property,
248 |     PropertyCallbackInfoPtr_Integer info);
249 | 
250 | typedef void (*NamedPropertyDeleterCallback)(
251 |     StringRef property,
252 |     PropertyCallbackInfoPtr_Boolean info);
253 | 
254 | typedef void (*NamedPropertyEnumeratorCallback)(
255 |     PropertyCallbackInfoPtr_Array info);
256 | 
257 | typedef void (*GenericNamedPropertyGetterCallback)(
258 |     NameRef property,
259 |     PropertyCallbackInfoPtr_Value info);
260 | 
261 | typedef void (*GenericNamedPropertySetterCallback)(
262 |     NameRef property,
263 |     ValueRef value,
264 |     PropertyCallbackInfoPtr_Value info);
265 | 
266 | typedef void (*GenericNamedPropertyQueryCallback)(
267 |     NameRef property,
268 |     PropertyCallbackInfoPtr_Integer info);
269 | 
270 | typedef void (*GenericNamedPropertyDeleterCallback)(
271 |     NameRef property,
272 |     PropertyCallbackInfoPtr_Boolean info);
273 | 
274 | typedef void (*GenericNamedPropertyEnumeratorCallback)(
275 |     PropertyCallbackInfoPtr_Array info);
276 | 
277 | typedef void (*IndexedPropertyGetterCallback)(
278 |     uint32_t index,
279 |     PropertyCallbackInfoPtr_Value info);
280 | 
281 | typedef void (*IndexedPropertySetterCallback)(
282 |     uint32_t index,
283 |     ValueRef value,
284 |     PropertyCallbackInfoPtr_Value info);
285 | 
286 | typedef void (*IndexedPropertyQueryCallback)(
287 |     uint32_t index,
288 |     PropertyCallbackInfoPtr_Integer info);
289 | 
290 | typedef void (*IndexedPropertyDeleterCallback)(
291 |     uint32_t index,
292 |     PropertyCallbackInfoPtr_Boolean info);
293 | 
294 | typedef void (*IndexedPropertyEnumeratorCallback)(
295 |     PropertyCallbackInfoPtr_Array info);
296 | 
297 | typedef bool (*AccessCheckCallback)(
298 |     ContextRef accessing_context,
299 |     ObjectRef accessed_object,
300 |     ValueRef data);
301 | 
302 | typedef void (*FatalErrorCallback)(
303 |     const char *location,
304 |     const char *message);
305 | 
306 | typedef void (*OOMErrorCallback)(
307 |     const char *location,
308 |     bool is_heap_oom);
309 | 
310 | struct NamedPropertyHandlerConfiguration {
311 |     GenericNamedPropertyGetterCallback getter;
312 |     GenericNamedPropertySetterCallback setter;
313 |     GenericNamedPropertyQueryCallback query;
314 |     GenericNamedPropertyDeleterCallback deleter;
315 |     GenericNamedPropertyEnumeratorCallback enumerator;
316 |     ValueRef data;
317 |     PropertyHandlerFlags flags;
318 | };
319 | typedef struct NamedPropertyHandlerConfiguration NamedPropertyHandlerConfiguration;
320 | 
321 | struct IndexedPropertyHandlerConfiguration {
322 |   IndexedPropertyGetterCallback getter;
323 |   IndexedPropertySetterCallback setter;
324 |   IndexedPropertyQueryCallback query;
325 |   IndexedPropertyDeleterCallback deleter;
326 |   IndexedPropertyEnumeratorCallback enumerator;
327 |   ValueRef data;
328 |   PropertyHandlerFlags flags;
329 | };
330 | typedef struct IndexedPropertyHandlerConfiguration IndexedPropertyHandlerConfiguration;
331 | 
332 | 
333 | PlatformPtr v8_Platform_Create(v8_PlatformFunctions platform_functions);
334 | void v8_Platform_Destroy(PlatformPtr platform);
335 | 
336 | void v8_Task_Destroy(TaskPtr task);
337 | void v8_IdleTask_Destroy(IdleTaskPtr task);
338 | 
339 | void v8_V8_InitializeICU();
340 | void v8_V8_InitializePlatform(PlatformPtr platform);
341 | void v8_V8_Initialize();
342 | void v8_V8_Dispose();
343 | void v8_V8_ShutdownPlatform();
344 | 
345 | 
346 | ArrayBuffer_AllocatorPtr v8_ArrayBuffer_Allocator_Create(v8_AllocatorFunctions allocator_functions);
347 | void v8_ArrayBuffer_Allocator_Destroy(ArrayBuffer_AllocatorPtr allocator);
348 | 
349 | IsolatePtr v8_Isolate_New(ArrayBuffer_AllocatorPtr allocator);
350 | ContextRef v8_Isolate_GetCurrentContext(IsolatePtr self);
351 | ValueRef v8_Isolate_ThrowException(IsolatePtr self, ValueRef exception);
352 | uint32_t v8_Isolate_GetNumberOfDataSlots(IsolatePtr self);
353 | void v8_Isolate_SetData(IsolatePtr self, uint32_t slot, void *data);
354 | void *v8_Isolate_GetData(IsolatePtr self, uint32_t slot);
355 | void v8_Isolate_SetCaptureStackTraceForUncaughtExceptions_Overview(IsolatePtr self, bool capture, int frame_limit);
356 | void v8_Isolate_SetCaptureStackTraceForUncaughtExceptions_Detailed(IsolatePtr self, bool capture, int frame_limit);
357 | void v8_Isolate_Dispose(IsolatePtr isolate);
358 | 
359 | void v8_Task_Run(TaskPtr task);
360 | void v8_IdleTask_Run(IdleTaskPtr task, double deadline_in_seconds);
361 | 
362 | #include "v8-glue-generated.h"
363 | 
364 | PrimitiveRef v8_Undefined(RustContext c);
365 | PrimitiveRef v8_Null(RustContext c);
366 | BooleanRef v8_True(RustContext c);
367 | BooleanRef v8_False(RustContext c);
368 | 
369 | ContextRef v8_Context_New(RustContext c);
370 | 
371 | StringRef v8_String_NewFromUtf8_Normal(RustContext c, const char *data, int length);
372 | StringRef v8_String_NewFromUtf8_Internalized(RustContext c, const char *data, int length);
373 | 
374 | int v8_String_WriteUtf8(RustContext c, StringRef string, char *buffer, int length);
375 | 
376 | ScriptRef v8_Script_Compile(RustContext c, ContextRef context, StringRef source);
377 | ScriptRef v8_Script_Compile_Origin(RustContext c, ContextRef context, StringRef source, ValueRef resource_name, IntegerRef resource_line_offset, IntegerRef resource_column_offset, BooleanRef resource_is_shared_cross_origin, IntegerRef script_id, BooleanRef resource_is_embedder_debug_script, ValueRef source_map_url, BooleanRef resource_is_opaque);
378 | 
379 | ValueRef v8_Object_CallAsFunction(RustContext c, ObjectRef self, ContextRef context, ValueRef recv, int argc, ValueRef argv[]);
380 | 
381 | ValueRef v8_Object_CallAsConstructor(RustContext c, ObjectRef self, ContextRef context, int argc, ValueRef argv[]);
382 | 
383 | FunctionRef v8_Function_New(RustContext c, ContextRef context, FunctionCallback callback, ValueRef data, int length, ConstructorBehavior behavior);
384 | ObjectRef v8_Function_NewInstance(RustContext c, FunctionRef self, ContextRef context, int argc, ValueRef argv[]);
385 | ValueRef v8_Function_Call(RustContext c, FunctionRef self, ContextRef context, ValueRef recv, int argc, ValueRef argv[]);
386 | 
387 | void v8_Template_SetNativeDataProperty(RustContext c, TemplateRef self, StringRef name, AccessorGetterCallback getter, AccessorSetterCallback setter, ValueRef data, PropertyAttribute attribute, AccessorSignatureRef signature, AccessControl settings);
388 | 
389 | FunctionTemplateRef v8_FunctionTemplate_New(RustContext c, ContextRef context, FunctionCallback wrapped_callback, ValueRef data, SignatureRef signature, int length, ConstructorBehavior behavior);
390 | 
391 | void v8_ObjectTemplate_SetAccessor(RustContext c, ObjectTemplateRef self, StringRef name, AccessorGetterCallback getter, AccessorSetterCallback setter, ValueRef data, AccessControl settings, PropertyAttribute attribute, AccessorSignatureRef signature);
392 | void v8_ObjectTemplate_SetAccessor_Name(RustContext c, ObjectTemplateRef self, StringRef name, AccessorNameGetterCallback getter, AccessorNameSetterCallback setter, ValueRef data, AccessControl settings, PropertyAttribute attribute, AccessorSignatureRef signature);
393 | void v8_ObjectTemplate_SetCallAsFunctionHandler(RustContext c, ObjectTemplateRef self, FunctionCallback callback, ValueRef data);
394 | void v8_ObjectTemplate_SetAccessCheckCallback(RustContext c, ObjectTemplateRef self, AccessCheckCallback callback, ValueRef data);
395 | 
396 | struct RustContext {
397 |     IsolatePtr isolate;
398 |     ValueRef *exception;
399 |     MessageRef *message;
400 | };
401 | 
402 | #if defined __cplusplus
403 | } /* extern "C" */
404 | #endif /* defined __cplusplus */
405 | 


--------------------------------------------------------------------------------
/v8-sys/build.rs:
--------------------------------------------------------------------------------
  1 | extern crate v8_api;
  2 | extern crate bindgen;
  3 | extern crate clang;
  4 | extern crate clang_sys;
  5 | extern crate gcc;
  6 | extern crate pkg_config;
  7 | 
  8 | use std::env;
  9 | use std::fmt;
 10 | use std::fs;
 11 | use std::io;
 12 | use std::path;
 13 | 
 14 | const LIBS: [&'static str; 4] = ["v8_base", "v8_libbase", "v8_libsampler", "v8_nosnapshot"];
 15 | 
 16 | trait DisplayAsC {
 17 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result;
 18 | }
 19 | 
 20 | struct C<'a, A>(&'a A) where A: 'a;
 21 | 
 22 | impl<'a, A> fmt::Display for C<'a, A>
 23 |     where A: DisplayAsC + 'a
 24 | {
 25 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 26 |         DisplayAsC::fmt(self.0, f)
 27 |     }
 28 | }
 29 | 
 30 | fn main() {
 31 |     let out_dir_str = env::var_os("OUT_DIR").unwrap();
 32 |     let out_dir_path = path::Path::new(&out_dir_str);
 33 | 
 34 |     println!("cargo:rerun-if-changed=src/v8-trampoline.h");
 35 |     println!("cargo:rerun-if-changed=src/v8-glue.h");
 36 |     println!("cargo:rerun-if-changed=src/v8-glue.cc");
 37 | 
 38 |     let api = read_api();
 39 | 
 40 |     link_v8();
 41 | 
 42 |     let decl_header_path = out_dir_path.join("v8-glue-decl-generated.h");
 43 |     write_decl_header(&api, &mut fs::File::create(&decl_header_path).unwrap()).unwrap();
 44 | 
 45 |     let header_path = out_dir_path.join("v8-glue-generated.h");
 46 |     write_header(&api, &mut fs::File::create(&header_path).unwrap()).unwrap();
 47 | 
 48 |     let cc_file_path = out_dir_path.join("v8-glue-generated.cc");
 49 |     write_cc_file(&api, &mut fs::File::create(&cc_file_path).unwrap()).unwrap();
 50 | 
 51 |     build_glue(out_dir_path);
 52 | 
 53 |     let ffi_path = out_dir_path.join("ffi.rs");
 54 |     gen_bindings(out_dir_path, &ffi_path);
 55 | }
 56 | 
 57 | fn read_api() -> v8_api::Api {
 58 |     let mut extra_includes = vec![];
 59 | 
 60 |     if path::Path::new("v8-build").exists() {
 61 |         extra_includes.push(path::Path::new("v8-build/include").to_path_buf());
 62 |     } else if let Some(dir_str) = env::var_os("V8_SOURCE") {
 63 |         extra_includes.push(path::PathBuf::from(dir_str).join("include"));
 64 |     }
 65 | 
 66 |     let clang = clang_sys::support::Clang::find(None).expect("No clang found, is it installed?");
 67 |     extra_includes.extend_from_slice(&clang.c_search_paths);
 68 | 
 69 |     let trampoline_path = path::Path::new("src/v8-trampoline.h");
 70 | 
 71 |     v8_api::read(trampoline_path, &extra_includes)
 72 | }
 73 | 
 74 | fn link_v8() {
 75 |     if path::Path::new("v8-build").exists() {
 76 |         // rq build hack
 77 |         println!("cargo:rustc-link-search=native=v8-build");
 78 |         println!("cargo:rustc-link-lib=static=v8-uber");
 79 |     } else if let Ok(libs_str) = env::var("V8_LIBS") {
 80 |         println!("V8_LIBS={:?}", libs_str);
 81 |         for lib_str in libs_str.split(char::is_whitespace) {
 82 |             let path = path::Path::new(lib_str);
 83 |             if let Some(dir) = path.parent() {
 84 |                 if dir.file_name().is_some() {
 85 |                     println!("cargo:rustc-link-search=native={}", dir.to_str().unwrap());
 86 |                 }
 87 |             }
 88 |             let lib_name = path.file_name().unwrap().to_str().unwrap();
 89 |             if lib_name.starts_with("lib") && lib_name.ends_with(".a") {
 90 |                 println!("cargo:rustc-link-lib=static={}",
 91 |                          &lib_name[3..lib_name.len() - 2]);
 92 |             }
 93 |         }
 94 |     } else if let Some(dir_str) = env::var_os("V8_BUILD") {
 95 |         println!("using V8_BUILD={:?}", dir_str);
 96 |         let dir = path::Path::new(&dir_str);
 97 | 
 98 |         maybe_search(dir);
 99 | 
100 |         // make+gyp-based build tree
101 |         maybe_search(dir.join("lib"));
102 |         maybe_search(dir.join("obj.target/src"));
103 |         maybe_search(dir.join("obj.target/third_party/icu"));
104 | 
105 |         // ninja+gyp-based build tree
106 |         maybe_search(dir.join("lib"));
107 |         maybe_search(dir.join("obj/src"));
108 |         maybe_search(dir.join("obj/third_party/icu"));
109 | 
110 |         // TODO: for GN-based builds it doesn't seem like the build
111 |         // produces static archives; maybe run ar here?
112 | 
113 |         blind_link_libraries();
114 |     } else {
115 |         let statik = !cfg!(feature = "shared");
116 |         println!("preferring static linking: {}", statik);
117 |         let result = pkg_config::Config::new()
118 |             .statik(statik)
119 |             .probe("v8");
120 |         if result.is_ok() {
121 |             println!("using pkg-config for library v8");
122 |         } else {
123 |             println!("cargo:warning=pkg-config failed, falling back to naïve lib search: {:?}",
124 |                      result);
125 | 
126 |             maybe_search("/usr/lib");
127 |             maybe_search("/usr/local/lib");
128 |             // TODO: hack: lazy way to fix the Travis build
129 |             maybe_search("/usr/lib/x86_64-linux-gnu");
130 |             maybe_search("/usr/local/lib/x86_64-linux-gnu");
131 |             maybe_search("/usr/lib/v8");
132 |             maybe_search("/usr/local/lib/v8");
133 |             maybe_search("/usr/local/opt/icu4c/lib"); // homebrew
134 | 
135 |             blind_link_libraries();
136 |         }
137 |     }
138 | }
139 | 
140 | fn blind_link_libraries() {
141 |     if cfg!(feature = "shared") {
142 |         if cfg!(all(windows, target_env = "msvc")) {
143 |             println!("cargo:rustc-link-lib=dylib=v8.dll");
144 |             println!("cargo:rustc-link-lib=static=v8_base");
145 |         } else {
146 |             println!("cargo:rustc-link-lib=dylib=v8");
147 |             println!("cargo:rustc-link-lib=dylib=icui18n");
148 |             println!("cargo:rustc-link-lib=dylib=icuuc");
149 |         }
150 |     } else {
151 |         for lib in LIBS.iter() {
152 |             println!("cargo:rustc-link-lib=static={}", lib);
153 |         }
154 |         println!("cargo:rustc-link-lib=static=icui18n");
155 |         println!("cargo:rustc-link-lib=static=icuuc");
156 |         if fs::metadata("/usr/lib/x86_64-linux-gnu/libicudata.a")
157 |             .map(|m| m.is_file())
158 |             .unwrap_or(false) {
159 |             println!("cargo:rustc-link-lib=static=icudata");
160 |         }
161 |         if fs::metadata("/usr/local/opt/icu4c/lib/libicudata.a")
162 |             .map(|m| m.is_file())
163 |             .unwrap_or(false) {
164 |             println!("cargo:rustc-link-lib=static=icudata");
165 |         }
166 |     }
167 | }
168 | 
169 | fn maybe_search<P>(dir: P)
170 |     where P: AsRef<path::Path>
171 | {
172 |     let dir = dir.as_ref();
173 |     if fs::metadata(dir).map(|m| m.is_dir()).unwrap_or(false) {
174 |         println!("cargo:rustc-link-search=native={}", dir.to_string_lossy());
175 |     }
176 | }
177 | 
178 | fn gen_bindings(out_dir_path: &path::Path, bindings_path: &path::Path) {
179 |     use std::io::Write;
180 |     let mut bindings = bindgen::builder()
181 |     .header("src/v8-glue.h")
182 |     .emit_builtins()
183 |     .no_unstable_rust()
184 |     //bindings.remove_prefix("v8_");
185 |     .clang_arg("-Isrc")
186 |     .clang_arg(format!("-I{}", out_dir_path.to_string_lossy()));
187 | 
188 |     if let Some(dir_str) = env::var_os("V8_SOURCE") {
189 |         println!("V8_SOURCE={:?}", dir_str);
190 |         let dir = path::Path::new(&dir_str);
191 |         bindings = bindings.clang_arg(format!("-I{}", dir.join("include").to_string_lossy()));
192 |     } else {
193 |         println!("V8_SOURCE not set, searching system paths");
194 |     }
195 | 
196 |     let generated_bindings = bindings.generate().unwrap();
197 | 
198 |     let mut bindings_file = fs::File::create(bindings_path).unwrap();
199 |     writeln!(bindings_file, "mod ffi {{").unwrap();
200 |     generated_bindings.write(Box::new(&mut bindings_file)).unwrap();
201 |     writeln!(bindings_file, "}}").unwrap();
202 | }
203 | 
204 | fn build_glue(out_dir_path: &path::Path) {
205 |     let mut config = gcc::Config::new();
206 | 
207 |     if let Some(dir_str) = env::var_os("V8_SOURCE") {
208 |         let dir = path::Path::new(&dir_str);
209 |         config.include(dir.join("include"));
210 |     }
211 | 
212 |     if path::Path::new("v8-build").exists() {
213 |         config.include("v8-build/include");
214 |     }
215 | 
216 |     config.include("src");
217 |     config.include(out_dir_path);
218 |     config.cpp(true);
219 | 
220 |     if let Ok(target) = env::var("TARGET") {
221 |         if target.contains("musl") {
222 |             // This is a bit of a hack... we know this string is inserted as a
223 |             // "cargo:rustc-link-lib={}" format argument, so we can force it to be linked statically
224 |             // like this.
225 |             config.cpp_link_stdlib(Some("static=stdc++"));
226 |         }
227 |     }
228 | 
229 |     config.flag("-std=c++11");
230 |     config.flag("-Wall");
231 |     config.file("src/v8-glue.cc");
232 |     config.compile("libv8sysglue.a");
233 | }
234 | 
235 | fn write_decl_header<W>(api: &v8_api::Api, mut out: W) -> io::Result<()>
236 |     where W: io::Write
237 | {
238 |     try!(writeln!(out, "#pragma once"));
239 | 
240 |     for class in api.classes.iter() {
241 |         try!(writeln!(out, ""));
242 |         try!(writeln!(out, "#if defined __cplusplus"));
243 |         try!(writeln!(out, "typedef v8::{class} *{class}Ptr;", class = class.name));
244 |         try!(writeln!(out,
245 |                       "typedef v8::Persistent<v8::{class}> *{class}Ref;",
246 |                       class = class.name));
247 |         try!(writeln!(out, "#else"));
248 |         try!(writeln!(out,
249 |                       "typedef struct _{class} *{class}Ptr;",
250 |                       class = class.name));
251 |         try!(writeln!(out,
252 |                       "typedef struct _{class}Ref *{class}Ref;",
253 |                       class = class.name));
254 |         try!(writeln!(out, "#endif /* defined __cplusplus */"));
255 |     }
256 | 
257 |     Ok(())
258 | }
259 | 
260 | fn write_header<W>(api: &v8_api::Api, mut out: W) -> io::Result<()>
261 |     where W: io::Write
262 | {
263 |     try!(writeln!(out, "#pragma once"));
264 | 
265 |     for class in api.classes.iter() {
266 |         try!(writeln!(out, ""));
267 | 
268 |         for method in class.methods.iter() {
269 |             try!(write!(out,
270 |                         "{retty} v8_{class}_{method}(RustContext c",
271 |                         retty = C(&method.ret_type),
272 |                         class = class.name,
273 |                         method = method.mangled_name));
274 | 
275 |             if !method.is_static {
276 |                 try!(write!(out, ", {class}Ref self", class = class.name));
277 |             }
278 | 
279 |             for arg in method.args.iter() {
280 |                 try!(write!(out, ", {arg}", arg = C(arg)));
281 |             }
282 |             try!(writeln!(out, ");"));
283 |         }
284 | 
285 |         try!(writeln!(out,
286 |                       "{class}Ref v8_{class}_CloneRef(RustContext c, {class}Ref self);",
287 |                       class = class.name));
288 | 
289 |         try!(writeln!(out,
290 |                       "void v8_{class}_DestroyRef({class}Ref self);",
291 |                       class = class.name));
292 | 
293 |         try!(writeln!(out,
294 |                       "void v8_{class}_DestroyPtr({class}Ptr self);",
295 |                       class = class.name));
296 |     }
297 | 
298 |     Ok(())
299 | }
300 | 
301 | fn write_cc_file<W>(api: &v8_api::Api, mut out: W) -> io::Result<()>
302 |     where W: io::Write
303 | {
304 |     for class in api.classes.iter() {
305 |         for method in class.methods.iter() {
306 |             try!(writeln!(out, ""));
307 |             try!(write!(out,
308 |                         "{retty} v8_{class}_{method}(RustContext c",
309 |                         retty = C(&method.ret_type),
310 |                         class = class.name,
311 |                         method = method.mangled_name));
312 | 
313 |             if !method.is_static {
314 |                 try!(write!(out, ", {class}Ref self", class = class.name));
315 |             }
316 | 
317 |             for arg in method.args.iter() {
318 |                 try!(write!(out, ", {arg}", arg = C(arg)));
319 |             }
320 |             try!(writeln!(out, ") {{"));
321 | 
322 |             try!(writeln!(out, "  v8::Isolate::Scope __isolate_scope(c.isolate);"));
323 |             try!(writeln!(out, "  v8::HandleScope __handle_scope(c.isolate);"));
324 |             try!(writeln!(out, "  v8::TryCatch __try_catch(c.isolate);"));
325 | 
326 |             let context_type = v8_api::Type::Ref(Box::new(v8_api::Type::Class("Context"
327 |                 .to_owned())));
328 |             if let Some(arg) = method.args.iter().find(|ref a| a.arg_type == context_type) {
329 |                 // There should only be one context but who knows
330 |                 try!(writeln!(out,
331 |                               "  auto wrapped_{ctx} = wrap(c.isolate, {ctx});",
332 |                               ctx = arg.name));
333 |                 try!(writeln!(out,
334 |                               "  v8::Context::Scope {ctx}_scope(wrapped_{ctx});",
335 |                               ctx = arg.name));
336 |             }
337 | 
338 |             for arg in method.args.iter() {
339 |                 try!(writeln!(out,
340 |                               "  auto {arg}_wrapped = wrap(c.isolate, {arg});",
341 |                               arg = arg.name));
342 |             }
343 | 
344 |             if let v8_api::RetType::Direct(v8_api::Type::Void) = method.ret_type {
345 |                 try!(write!(out, "  "));
346 |             } else {
347 |                 try!(write!(out, "  auto result = "));
348 |             }
349 |             if method.is_static {
350 |                 try!(write!(out,
351 |                             "v8::{class}::{method}(",
352 |                             class = class.name,
353 |                             method = method.name));
354 |             } else {
355 |                 try!(write!(out, "self->Get(c.isolate)->{method}(", method = method.name));
356 |             }
357 | 
358 |             let mut needs_sep = false;
359 |             for arg in method.args.iter() {
360 |                 if needs_sep {
361 |                     try!(write!(out, ", "));
362 |                 }
363 |                 needs_sep = true;
364 |                 try!(write!(out, "{arg}_wrapped", arg = arg.name));
365 |             }
366 |             try!(writeln!(out, ");"));
367 |             if let v8_api::RetType::Direct(v8_api::Type::Void) = method.ret_type {
368 |                 try!(writeln!(out, "  handle_exception(c, __try_catch);"));
369 |             } else {
370 |                 try!(writeln!(out, "  handle_exception(c, __try_catch);"));
371 |                 try!(writeln!(out,
372 |                               "  return {unwrapper}(c.isolate, result);",
373 |                               unwrapper = unwrapper(&method.ret_type)));
374 |             }
375 |             try!(writeln!(out, "}}"));
376 |         }
377 | 
378 |         try!(writeln!(out, ""));
379 |         try!(writeln!(out,
380 |                       "{class}Ref v8_{class}_CloneRef(RustContext c, {class}Ref self) {{",
381 |                       class = class.name));
382 |         try!(writeln!(out, "  v8::HandleScope __handle_scope(c.isolate);"));
383 |         try!(writeln!(out, "  return unwrap(c.isolate, wrap(c.isolate, self));"));
384 |         try!(writeln!(out, "}}"));
385 |         try!(writeln!(out, ""));
386 |         try!(writeln!(out,
387 |                       "void v8_{class}_DestroyRef({class}Ref self) {{",
388 |                       class = class.name));
389 |         try!(writeln!(out, "  self->Reset();"));
390 |         try!(writeln!(out, "  delete self;"));
391 |         try!(writeln!(out, "}}"));
392 |         try!(writeln!(out, ""));
393 |         try!(writeln!(out,
394 |                       "void v8_{class}_DestroyPtr({class}Ptr self) {{",
395 |                       class = class.name));
396 |         try!(writeln!(out, "  delete self;"));
397 |         try!(writeln!(out, "}}"));
398 |     }
399 | 
400 |     Ok(())
401 | }
402 | 
403 | fn unwrapper(ret_type: &v8_api::RetType) -> &str {
404 |     use v8_api::*;
405 |     match *ret_type {
406 |         RetType::Maybe(Type::Bool) => "unwrap_maybe_bool",
407 |         RetType::Maybe(Type::Int) => "unwrap_maybe_int",
408 |         RetType::Maybe(Type::UInt) => "unwrap_maybe_uint",
409 |         RetType::Maybe(Type::Long) => "unwrap_maybe_long",
410 |         RetType::Maybe(Type::ULong) => "unwrap_maybe_ulong",
411 |         RetType::Maybe(Type::U32) => "unwrap_maybe_u32",
412 |         RetType::Maybe(Type::I32) => "unwrap_maybe_i32",
413 |         RetType::Maybe(Type::U64) => "unwrap_maybe_u64",
414 |         RetType::Maybe(Type::I64) => "unwrap_maybe_i64",
415 |         RetType::Maybe(Type::F64) => "unwrap_maybe_f64",
416 |         _ => "unwrap",
417 |     }
418 | }
419 | 
420 | impl DisplayAsC for v8_api::Arg {
421 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
422 |         write!(f, "{} {}", C(&self.arg_type), self.name)
423 |     }
424 | }
425 | 
426 | impl DisplayAsC for v8_api::RetType {
427 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
428 |         use v8_api::*;
429 |         match *self {
430 |             RetType::Direct(ref t) => DisplayAsC::fmt(t, f),
431 |             RetType::Maybe(Type::Bool) => write!(f, "MaybeBool"),
432 |             RetType::Maybe(Type::Int) => write!(f, "MaybeInt"),
433 |             RetType::Maybe(Type::UInt) => write!(f, "MaybeUInt"),
434 |             RetType::Maybe(Type::Long) => write!(f, "MaybeLong"),
435 |             RetType::Maybe(Type::ULong) => write!(f, "MaybeULong"),
436 |             RetType::Maybe(Type::U32) => write!(f, "MaybeU32"),
437 |             RetType::Maybe(Type::I32) => write!(f, "MaybeI32"),
438 |             RetType::Maybe(Type::F64) => write!(f, "MaybeF64"),
439 |             RetType::Maybe(Type::U64) => write!(f, "MaybeU64"),
440 |             RetType::Maybe(Type::I64) => write!(f, "MaybeI64"),
441 |             // TODO: potentially maybeify more types here
442 |             RetType::Maybe(ref t) => DisplayAsC::fmt(t, f),
443 |         }
444 |     }
445 | }
446 | 
447 | impl DisplayAsC for v8_api::Type {
448 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
449 |         use v8_api::*;
450 |         match *self {
451 |             Type::Void => write!(f, "void"),
452 |             Type::Bool => write!(f, "bool"),
453 |             Type::UChar => write!(f, "char"),
454 |             Type::ConstUChar => write!(f, "const char"),
455 |             Type::Char => write!(f, "char"),
456 |             Type::ConstChar => write!(f, "const char"),
457 |             Type::UInt => write!(f, "unsigned int"),
458 |             Type::Int => write!(f, "int"),
459 |             Type::ULong => write!(f, "unsigned long"),
460 |             Type::Long => write!(f, "long"),
461 |             Type::U8 => write!(f, "uint8_t"),
462 |             Type::I8 => write!(f, "int8_t"),
463 |             Type::U16 => write!(f, "uint16_t"),
464 |             Type::I16 => write!(f, "int16_t"),
465 |             Type::U32 => write!(f, "uint32_t"),
466 |             Type::I32 => write!(f, "int32_t"),
467 |             Type::U64 => write!(f, "uint64_t"),
468 |             Type::I64 => write!(f, "int64_t"),
469 |             Type::F64 => write!(f, "double"),
470 |             Type::USize => write!(f, "size_t"),
471 |             Type::Class(ref name) => write!(f, "{}", name),
472 |             Type::Enum(ref name) => write!(f, "{}", name),
473 |             Type::Callback(ref name) => write!(f, "{}", name),
474 |             Type::CallbackLValue(ref name) => write!(f, "{}", name),
475 |             Type::Ref(ref target) => {
476 |                 match **target {
477 |                     Type::Class(ref name) => write!(f, "{}Ref", name),
478 |                     ref t => write!(f, "&{}", C(t)),
479 |                 }
480 |             }
481 |             Type::Ptr(ref target) => {
482 |                 match **target {
483 |                     Type::Class(ref name) => write!(f, "{}Ptr", name),
484 |                     ref t => write!(f, "{} *", C(t)),
485 |                 }
486 |             }
487 |             Type::Arr(ref target) => write!(f, "{}[]", C(&**target)),
488 |         }
489 |     }
490 | }
491 | 


--------------------------------------------------------------------------------
/v8-api/src/lib.rs:
--------------------------------------------------------------------------------
  1 | extern crate clang;
  2 | #[macro_use]
  3 | extern crate log;
  4 | 
  5 | use std::env;
  6 | use std::fmt;
  7 | use std::path;
  8 | 
  9 | /// A description of the V8 API.
 10 | #[derive(Debug)]
 11 | pub struct Api {
 12 |     /// The classes that the API consists of.
 13 |     pub classes: Vec<Class>,
 14 | }
 15 | 
 16 | /// A C++ class,
 17 | #[derive(Debug)]
 18 | pub struct Class {
 19 |     /// The simple name of the class (without the `v8::` prefix).
 20 |     pub name: String,
 21 |     /// The methods of this class, in declaration order.
 22 |     pub methods: Vec<Method>,
 23 | }
 24 | 
 25 | /// A C++ method
 26 | #[derive(Debug)]
 27 | pub struct Method {
 28 |     /// Whether the method is static.
 29 |     pub is_static: bool,
 30 |     /// The name of the method.
 31 |     pub name: String,
 32 |     /// A mangled version of the method that makes it unique among all
 33 |     /// of the methods of its class.
 34 |     pub mangled_name: String,
 35 |     /// The arguments that the method takes, in declaration order.
 36 |     pub args: Vec<Arg>,
 37 |     /// The return type of the method.
 38 |     pub ret_type: RetType,
 39 | }
 40 | 
 41 | /// The return type of a method.
 42 | #[derive(Debug)]
 43 | pub enum RetType {
 44 |     /// The type is directly returned.  For primitives `T`, this means
 45 |     /// just `T` (e.g. `int`).  For references to `T`, this means
 46 |     /// `Local<T>` (e.g. `Local<String>`).  For pointers to `T`, this
 47 |     /// means a non-null pointer `T *`.
 48 |     Direct(Type),
 49 |     /// The type might be absent.  For primitives `T`, this means
 50 |     /// `Maybe<T>` (e.g. `Maybe<int>`).  For references to `T`, this
 51 |     /// means `MaybeLocal<T>`.  For pointers to `T`, this means a
 52 |     /// nullable pointer `T *`.
 53 |     Maybe(Type),
 54 | }
 55 | 
 56 | /// A method argument.
 57 | #[derive(Debug)]
 58 | pub struct Arg {
 59 |     /// The argument name.
 60 |     pub name: String,
 61 |     /// The type of the argument.
 62 |     pub arg_type: Type,
 63 | }
 64 | 
 65 | /// The types used in V8.
 66 | #[derive(Debug, Eq, PartialEq)]
 67 | pub enum Type {
 68 |     /// The `void` type.
 69 |     Void,
 70 |     /// The `bool` type.
 71 |     Bool,
 72 | 
 73 |     /// The `unsigned char` type.
 74 |     UChar,
 75 |     /// The `const unsigned char` type.
 76 |     ConstUChar,
 77 |     /// The `char` type.
 78 |     Char,
 79 |     /// The `const char` type.
 80 |     ConstChar,
 81 |     /// The `unsigned int` type.
 82 |     UInt,
 83 |     /// The `int` type.
 84 |     Int,
 85 |     /// The `unsigned long` type.
 86 |     ULong,
 87 |     /// The `long` type.
 88 |     Long,
 89 | 
 90 |     /// The `uint8_t` type.
 91 |     U8,
 92 |     /// The `int8_t` type.
 93 |     I8,
 94 |     /// The `uint16_t` type.
 95 |     U16,
 96 |     /// The `int16_t` type.
 97 |     I16,
 98 |     /// The `uint32_t` type.
 99 |     U32,
100 |     /// The `int32_t` type.
101 |     I32,
102 |     /// The `uint64_t` type.
103 |     U64,
104 |     /// The `int64_t` type.
105 |     I64,
106 |     /// The `double` type.
107 |     F64,
108 | 
109 |     /// The `size_t` type.
110 |     USize,
111 | 
112 |     /// A class with the specified name, without the `v8::` prefix.
113 |     Class(String),
114 |     /// An enum with the specified name, without the `v8::` prefix.
115 |     Enum(String),
116 |     /// A callback function pointer name, without the `v8::` prefix.
117 |     Callback(String),
118 |     /// An argument to a callback
119 |     CallbackLValue(String),
120 | 
121 |     /// A reference to the specified type, meaning a `Local<T>` or
122 |     /// `MaybeLocal<T>`.
123 |     Ref(Box<Type>),
124 |     /// A pointer to the specified type, i.e. `T *`.
125 |     Ptr(Box<Type>),
126 |     /// An array of the specified type, i.e. `T[]`.
127 |     Arr(Box<Type>),
128 | }
129 | 
130 | /// A method mangle rule.
131 | struct MethodMangle {
132 |     /// The exact name of the method to mangle.
133 |     name: &'static str,
134 |     /// A unique part of the method signature.
135 |     signature: &'static str,
136 |     /// The mangled name of the method.
137 |     mangle: &'static str,
138 | }
139 | 
140 | /// Classes that we should not return because they are special.
141 | #[cfg_attr(rustfmt, rustfmt_skip)]
142 | const SPECIAL_CLASSES: &'static [&'static str] = &[
143 |     // v8.h
144 |     // Allocation stuff
145 |     "Isolate", // Because part of RustContext (so chicken and egg methods)
146 |     "HandleScope", // Because stack local
147 |     "EscapableHandleScope", // Because stack local
148 |     "SealHandleScope", // Because stack local
149 |     "TryCatch", // Because stack local
150 | 
151 |     // Annoying classes
152 |     "ScriptOrigin", // Because it's sent around by-value
153 |     "PersistentHandleVisitor", // Only used on Isolate?
154 |     "EmbedderHeapTracer", // Can't be heap allocated?
155 |     "ValueSerializer", // Weird API and only on modern V8's
156 |     "ValueDeserializer", // Weird API and only on modern V8's
157 |     "ExtensionConfiguration", // Weird API
158 |     "Module", // Too experimental
159 |     "SnapshotCreator", // Snapshots not supported
160 | 
161 |     // v8-platform.h
162 |     // These are all pre-requisites for creating an Isolate so
163 |     // hand-roll them
164 |     "Platform",
165 |     "Task",
166 |     "IdleTask",
167 | ];
168 | 
169 | /// Methods that we should not return because they are special.
170 | #[cfg_attr(rustfmt, rustfmt_skip)]
171 | const SPECIAL_METHODS: &'static [(&'static str, &'static str)] = &[
172 |     ("Script", "Compile"), // Because ScriptOrigin param
173 |     ("Message", "GetScriptOrigin"), // Because ScriptOrigin
174 |     ("String", "WriteUtf8"), // Because annoying-to-map signature
175 |     ("Object", "SetAlignedPointerInInternalFields"), // Because annoying-to-map signature
176 |     ("Object", "CallAsFunction"), // Because annoying-to-map signature
177 |     ("Object", "CallAsConstructor"), // Because annoying-to-map signature
178 |     ("Object", "NewInstance"), // Because annoying-to-map signature
179 |     ("Object", "Call"), // Because annoying-to-map signature
180 |     ("Function", "New"), // Because annoying-to-map signature
181 |     ("Function", "GetScriptOrigin"), // Because ScriptOrigin
182 |     ("Function", "NewInstance"), // Because annoying-to-map signature
183 |     ("Function", "Call"), // Because annoying-to-map signature
184 |     ("Template", "SetNativeDataProperty"), // Because annoying-to-map signature
185 |     ("Template", "SetLazyDataProperty"), // Because annoying-to-map signature
186 |     ("FunctionTemplate", "New"), // Because annoying-to-map signature
187 |     ("FunctionTemplate", "NewWithCache"), // Because annoying-to-map signature
188 |     ("ObjectTemplate", "SetAccessor"), // Because annoying-to-map signature
189 |     ("ObjectTemplate", "SetNamedPropertyHandler"), // Because annoying-to-map signature
190 |     ("ObjectTemplate", "SetIndexedPropertyHandler"), // Because annoying-to-map signature
191 |     ("ObjectTemplate", "SetCallAsFunctionHandler"), // Because annoying-to-map signature
192 |     ("ObjectTemplate", "SetAccessCheckCallback"), // Because annoying-to-map signature
193 |     ("ObjectTemplate", "SetAccessCheckCallbackAndHandler"), // Because annoying-to-map signature
194 |     ("Value", "IsFloat32x4"), // Too experimental
195 |     ("WasmCompiledModule", "Serialize"), // Breaks on ARM/Mac
196 |     ("WasmCompiledModule", "Deserialize"), // Breaks on ARM/Mac
197 |     ("ConvertableToTraceFormat", "AppendAsTraceFormat"), // Breaks on ARM
198 |     ("V8", "CreateSnapshotDataBlob"), // Because annoying-to-map signature
199 |     ("V8", "WarmUpSnapshotDataBlob"), // Because annoying-to-map signature
200 |     ("V8", "Initialize"), // V8::Initialize takes no context
201 |     ("V8", "Dispose"), // V8::Dispose takes no context
202 |     ("V8", "InitializePlatform"), // V8::InitializePlatform takes no context
203 |     ("V8", "ShutdownPlatform"), // V8::ShutdownPlatform takes no context
204 | ];
205 | 
206 | /// Default mangle rules.
207 | #[cfg_attr(rustfmt, rustfmt_skip)]
208 | const METHOD_MANGLES: &'static [MethodMangle] = &[
209 |     MethodMangle { name: "Set", signature: "index", mangle: "Set_Index"},
210 |     MethodMangle { name: "Set", signature: "key", mangle: "Set_Key"},
211 |     MethodMangle { name: "CreateDataProperty", signature: "index", mangle: "CreateDataProperty_Index"},
212 |     MethodMangle { name: "CreateDataProperty", signature: "key", mangle: "CreateDataProperty_Key"},
213 |     MethodMangle { name: "Get", signature: "index", mangle: "Get_Index"},
214 |     MethodMangle { name: "Get", signature: "key", mangle: "Get_Key"},
215 |     MethodMangle { name: "Has", signature: "index", mangle: "Has_Index"},
216 |     MethodMangle { name: "Has", signature: "key", mangle: "Has_Key"},
217 |     MethodMangle { name: "Delete", signature: "index", mangle: "Delete_Index"},
218 |     MethodMangle { name: "Delete", signature: "key", mangle: "Delete_Key"},
219 |     MethodMangle { name: "HasOwnProperty", signature: "index", mangle: "HasOwnProperty_Index"},
220 |     MethodMangle { name: "HasOwnProperty", signature: "key", mangle: "HasOwnProperty_Key"},
221 |     MethodMangle { name: "GetPropertyNames", signature: "mode", mangle: "GetPropertyNames_Filter"},
222 |     MethodMangle { name: "GetOwnPropertyNames", signature: "filter", mangle: "GetOwnPropertyNames_Filter"},
223 |     MethodMangle { name: "InitializeExternalStartupData", signature: "natives_blob", mangle: "InitializeExternalStartupData_Blobs"},
224 |     MethodMangle { name: "InitializeExternalStartupData", signature: "directory_path", mangle: "InitializeExternalStartupData_Directory"},
225 |     MethodMangle { name: "New", signature: "shared_array_buffer", mangle: "New_Shared"},
226 |     MethodMangle { name: "New", signature: "array_buffer", mangle: "New_Owned"},
227 |     MethodMangle { name: "New", signature: "mode", mangle: "New_Mode"},
228 |     MethodMangle { name: "Set", signature: "char", mangle: "Set_Raw"},
229 |     MethodMangle { name: "SetNativeDataProperty", signature: "v8::Name", mangle: "SetNativeDataProperty_Name"},
230 |     MethodMangle { name: "SetAccessor", signature: "v8::Name", mangle: "SetAccessor_Name"},
231 |     MethodMangle { name: "SetHandler", signature: "v8::Name", mangle: "SetHandler_Name"},
232 | ];
233 | 
234 | /// Reads the V8 API from the given file path pointing to a `v8.h`
235 | /// file (or a file that includes `v8.h`), using the specified extra
236 | /// includes if necessary.
237 | ///
238 | /// # Panics
239 | ///
240 | /// Since this library is supposed to be used in a build script,
241 | /// panics if anything goes wrong whatsoever.
242 | pub fn read<P1, P2>(file_path: P1, extra_includes: &[P2]) -> Api
243 |     where P1: AsRef<path::Path>,
244 |           P2: AsRef<path::Path>
245 | {
246 |     let clang = clang::Clang::new().unwrap();
247 |     let index = clang::Index::new(&clang, false, true);
248 | 
249 |     let mut args = vec!["-x".to_owned(),
250 |                         "c++".to_owned(),
251 |                         "--std=c++11".to_owned(),
252 |                         "-DV8_DEPRECATION_WARNINGS".to_owned(),
253 |                         "-DV8_IMMINENT_DEPRECATION_WARNINGS".to_owned()];
254 | 
255 |     if cfg!(all(windows, target_env = "msvc")) {
256 |         args.push("-fms-compatibility-version=19".to_owned());
257 |     }
258 | 
259 |     if let Ok(target) = env::var("TARGET") {
260 |         args.push("-target".to_owned());
261 |         args.push(target.to_owned());
262 |     }
263 | 
264 |     for include in extra_includes {
265 |         println!("-I{:?}", include.as_ref());
266 |         if let Some(include_str) = include.as_ref().to_str() {
267 |             args.push(format!("-I{}", include_str));
268 |         }
269 |     }
270 | 
271 |     let translation_unit = index.parser(file_path.as_ref())
272 |         .arguments(&args)
273 |         .parse()
274 |         .unwrap();
275 | 
276 |     build_api(&translation_unit.get_entity())
277 | }
278 | 
279 | fn build_api(entity: &clang::Entity) -> Api {
280 |     let namespaces = entity.get_children()
281 |         .into_iter()
282 |         .filter(|e| e.get_name().map(|n| n == "v8").unwrap_or(false));
283 |     let classes = namespaces.flat_map(|n| build_classes(&n).into_iter()).collect();
284 |     Api { classes: classes }
285 | }
286 | 
287 | fn build_classes(entity: &clang::Entity) -> Vec<Class> {
288 |     entity.get_children()
289 |         .into_iter()
290 |         // Is a class
291 |         .filter(|e| e.get_kind() == clang::EntityKind::ClassDecl)
292 |         // Is not just a declaration
293 |         .filter(|e| !e.get_children().is_empty())
294 |         // Is not nameless or special
295 |         .filter(|e| {
296 |             e.get_name().map(|ref n| !SPECIAL_CLASSES.contains(&n.as_str())).unwrap_or(false)
297 |         })
298 |         .map(|e| build_class(&e))
299 |         .collect::<Vec<_>>()
300 | }
301 | 
302 | fn build_class(entity: &clang::Entity) -> Class {
303 |     let name = entity.get_name().unwrap();
304 |     Class {
305 |         methods: entity.get_children()
306 |             .into_iter()
307 |             // Is a method
308 |             .filter(|e| e.get_kind() == clang::EntityKind::Method)
309 |             // Is not deprecated
310 |             .filter(|e| e.get_availability() == clang::Availability::Available)
311 |             // Is public
312 |             .filter(|e| e.get_accessibility() == Some(clang::Accessibility::Public))
313 |             // Is not an operator or special
314 |             .filter(|e| {
315 |                 e.get_name()
316 |                     .map(|ref n| {
317 |                         !n.starts_with("operator") &&
318 |                             !SPECIAL_METHODS.iter()
319 |                             .any(|m| m.0 == name &&  m.1 == n)
320 |                     })
321 |                     .unwrap_or(false)
322 |             })
323 |             .flat_map(|e| build_method(&e)
324 |                       .map_err(|err| {
325 |                           warn!("Could not translate method {}", e.get_display_name().unwrap_or_else(||"(unnamed)".to_owned()));
326 |                           err
327 |                       }))
328 |             .collect(),
329 |         name: name,
330 |     }
331 | }
332 | 
333 | fn build_method(entity: &clang::Entity) -> Result<Method, ()> {
334 |     let display_name = try!(entity.get_display_name().ok_or(()));
335 |     let name = try!(entity.get_name().ok_or(()));
336 |     let args = try!(entity.get_arguments().ok_or(()));
337 |     let args: Vec<Arg> = try!(args.iter().map(|e| build_arg(&e)).collect());
338 | 
339 |     let method_type = try!(entity.get_type().ok_or(()));
340 |     let method_type_display_name = method_type.get_display_name();
341 |     let ret_type = try!(method_type.get_result_type().ok_or(()));
342 |     let ret_type = try!(build_ret_type(&ret_type));
343 | 
344 |     let mangled_name = METHOD_MANGLES.iter()
345 |         .find(|m| {
346 |             m.name == name &&
347 |             (args.iter().any(|a| a.name == m.signature) || display_name.contains(m.signature) ||
348 |              method_type_display_name.contains(m.signature))
349 |         })
350 |         .map(|m| m.mangle.to_owned());
351 | 
352 |     Ok(Method {
353 |         is_static: entity.is_static_method(),
354 |         mangled_name: mangled_name.unwrap_or_else(|| name.clone()),
355 |         name: name,
356 |         args: args,
357 |         ret_type: ret_type,
358 |     })
359 | }
360 | 
361 | fn build_arg(entity: &clang::Entity) -> Result<Arg, ()> {
362 |     Ok(Arg {
363 |         name: try!(entity.get_name().ok_or(())),
364 |         arg_type: try!(build_type(&entity.get_type().unwrap())),
365 |     })
366 | }
367 | 
368 | fn build_ret_type(typ: &clang::Type) -> Result<RetType, ()> {
369 |     if typ.get_kind() == clang::TypeKind::Unexposed {
370 |         let name = typ.get_display_name();
371 | 
372 |         if name.starts_with("MaybeLocal<") {
373 |             let ref_type = try!(build_type(&get_first_tpl_arg(typ)));
374 |             Ok(RetType::Maybe(Type::Ref(Box::new(ref_type))))
375 |         } else if name.starts_with("Maybe<") {
376 |             let ref_type = try!(build_type(&get_first_tpl_arg(typ)));
377 |             Ok(RetType::Maybe(ref_type))
378 |         } else {
379 |             Ok(RetType::Direct(try!(build_type(typ))))
380 |         }
381 |     } else {
382 |         Ok(RetType::Direct(try!(build_type(typ))))
383 |     }
384 | }
385 | 
386 | fn build_type(typ: &clang::Type) -> Result<Type, ()> {
387 |     match typ.get_kind() {
388 |         clang::TypeKind::Void => Ok(Type::Void),
389 |         clang::TypeKind::Bool => Ok(Type::Bool),
390 |         clang::TypeKind::CharS => {
391 |             if typ.is_const_qualified() {
392 |                 Ok(Type::ConstChar)
393 |             } else {
394 |                 Ok(Type::Char)
395 |             }
396 |         },
397 |         clang::TypeKind::CharU => {
398 |             if typ.is_const_qualified() {
399 |                 Ok(Type::ConstUChar)
400 |             } else {
401 |                 Ok(Type::UChar)
402 |             }
403 |         },
404 |         clang::TypeKind::UInt => Ok(Type::UInt),
405 |         clang::TypeKind::Int => Ok(Type::Int),
406 |         clang::TypeKind::ULong => Ok(Type::ULong),
407 |         clang::TypeKind::Long => Ok(Type::Long),
408 |         clang::TypeKind::Double => Ok(Type::F64),
409 |         clang::TypeKind::LongLong => Ok(Type::I64),
410 |         clang::TypeKind::ULongLong => Ok(Type::U64),
411 |         clang::TypeKind::Pointer => {
412 |             let inner = try!(typ.get_pointee_type().ok_or(()));
413 |             let inner = try!(build_type(&inner));
414 |             Ok(Type::Ptr(Box::new(inner)))
415 |         }
416 |         clang::TypeKind::IncompleteArray => {
417 |             let inner = try!(typ.get_element_type().ok_or(()));
418 |             let inner = try!(build_type(&inner));
419 |             Ok(Type::Arr(Box::new(inner)))
420 |         }
421 |         clang::TypeKind::Record => {
422 |             // TODO: is this right?
423 |             let name = typ.get_display_name().replace("v8::", "");
424 |             if name.contains("::") {
425 |                 warn!("No support for nested type {:?}", name);
426 |                 Err(())
427 |             } else {
428 |                 Ok(Type::Class(name))
429 |             }
430 |         }
431 |         clang::TypeKind::Enum => {
432 |             // TODO: is this right?
433 |             let name = typ.get_display_name().replace("v8::", "");
434 |             if name.contains("::") {
435 |                 warn!("No support for nested type {:?}", name);
436 |                 Err(())
437 |             } else {
438 |                 Ok(Type::Enum(name))
439 |             }
440 |         }
441 |         clang::TypeKind::Typedef => {
442 |             // TODO: is this right?
443 |             match typ.get_display_name().as_str() {
444 |                 "uint8_t" | "const uint8_t" => Ok(Type::U8),
445 |                 "int8_t" | "const int8_t" => Ok(Type::I8),
446 |                 "uint16_t" | "const uint16_t" => Ok(Type::U16),
447 |                 "int16_t" | "const int16_t" => Ok(Type::I16),
448 |                 "uint32_t" | "const uint32_t" => Ok(Type::U32),
449 |                 "int32_t" | "const int32_t" => Ok(Type::I32),
450 |                 "uint64_t" | "const uint64_t" => Ok(Type::U64),
451 |                 "int64_t" | "const int64_t" => Ok(Type::I64),
452 |                 "double" | "const double" => Ok(Type::F64),
453 |                 "size_t" | "const size_t" => Ok(Type::USize),
454 |                 s if s.ends_with("Callback") => Ok(Type::Callback(s.to_owned())),
455 |                 s => {
456 |                     warn!("Unmapped type {:?} (a typedef)", s);
457 |                     Err(())
458 |                 }
459 |             }
460 |         }
461 |         clang::TypeKind::Unexposed | clang::TypeKind::Elaborated => {
462 |             if typ.get_display_name().starts_with("Local<") {
463 |                 let ref_type = try!(build_type(&get_first_tpl_arg(typ)));
464 |                 Ok(Type::Ref(Box::new(ref_type)))
465 |             } else {
466 |                 match typ.get_display_name().as_str() {
467 |                     // For some reason these fail to map
468 |                     "v8::Isolate" => Ok(Type::Class("Isolate".to_owned())),
469 |                     "v8::ObjectTemplate" => Ok(Type::Class("ObjectTemplate".to_owned())),
470 |                     "v8::Value" => Ok(Type::Class("Value".to_owned())),
471 |                     "v8::Local<v8::String>" => {
472 |                         Ok(Type::Ref(Box::new(Type::Class("String".to_owned()))))
473 |                     }
474 |                     "v8::Local<v8::FunctionTemplate>" => {
475 |                         Ok(Type::Ref(Box::new(Type::Class("FunctionTemplate".to_owned()))))
476 |                     }
477 |                     n => {
478 |                         warn!("Unmapped type {:?} of kind {:?} (in unexposed exception table)",
479 |                               n,
480 |                               typ.get_kind());
481 |                         Err(())
482 |                     }
483 |                 }
484 |             }
485 |         }
486 |         clang::TypeKind::LValueReference => {
487 |             match typ.get_display_name().as_str() {
488 |                 "const v8::NamedPropertyHandlerConfiguration &" => {
489 |                     Ok(Type::CallbackLValue("NamedPropertyHandlerConfiguration".to_owned()))
490 |                 }
491 |                 "const v8::IndexedPropertyHandlerConfiguration &" => {
492 |                     Ok(Type::CallbackLValue("IndexedPropertyHandlerConfiguration".to_owned()))
493 |                 }
494 |                 n => {
495 |                     warn!("Unmapped type {:?} of kind {:?} (in lvalue reference exception table)",
496 |                           n,
497 |                           typ.get_kind());
498 |                     Err(())
499 |                 }
500 |             }
501 |         }
502 |         _ => {
503 |             warn!("Unmapped type {:?} of kind {:?} (in kind dispatch table)",
504 |                   typ.get_display_name(),
505 |                   typ.get_kind());
506 |             Err(())
507 |         }
508 |     }
509 | }
510 | 
511 | fn get_first_tpl_arg<'a>(typ: &clang::Type<'a>) -> clang::Type<'a> {
512 |     let tpl_args = typ.get_template_argument_types().unwrap();
513 |     tpl_args[0].unwrap()
514 | }
515 | 
516 | impl fmt::Display for Api {
517 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
518 |         for class in self.classes.iter() {
519 |             try!(writeln!(f, "{}", class));
520 |         }
521 |         Ok(())
522 |     }
523 | }
524 | 
525 | impl fmt::Display for Class {
526 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
527 |         try!(writeln!(f, "class {}", self.name));
528 |         for method in self.methods.iter() {
529 |             try!(writeln!(f, "  {}", method));
530 |         }
531 |         Ok(())
532 |     }
533 | }
534 | 
535 | impl fmt::Display for Method {
536 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
537 |         if self.is_static {
538 |             try!(write!(f, "static "));
539 |         }
540 |         try!(write!(f, "{}(", self.name));
541 | 
542 |         let mut needs_sep = false;
543 |         for arg in self.args.iter() {
544 |             if needs_sep {
545 |                 try!(write!(f, ", "));
546 |             }
547 |             needs_sep = true;
548 |             try!(write!(f, "{}", arg));
549 |         }
550 |         try!(write!(f, ") -> {}", self.ret_type));
551 | 
552 |         if self.mangled_name != self.name {
553 |             try!(write!(f, " {{{}}}", self.mangled_name));
554 |         }
555 | 
556 |         Ok(())
557 |     }
558 | }
559 | 
560 | impl fmt::Display for Arg {
561 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
562 |         write!(f, "{type} {name}", name=self.name, type=self.arg_type)
563 |     }
564 | }
565 | 
566 | impl fmt::Display for RetType {
567 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
568 |         match *self {
569 |             RetType::Direct(ref t) => write!(f, "{}", t),
570 |             RetType::Maybe(ref t) => write!(f, "maybe {}", t),
571 |         }
572 |     }
573 | }
574 | 
575 | impl fmt::Display for Type {
576 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
577 |         match *self {
578 |             Type::Void => write!(f, "()"),
579 |             Type::Bool => write!(f, "bool"),
580 | 
581 |             Type::UChar => write!(f, "::std::os::raw::c_uchar"),
582 |             Type::ConstUChar => write!(f, "::std::os::raw::c_uchar"),
583 |             Type::Char => write!(f, "::std::os::raw::c_char"),
584 |             Type::ConstChar => write!(f, "::std::os::raw::c_char"),
585 |             Type::UInt => write!(f, "::std::os::raw::c_uint"),
586 |             Type::Int => write!(f, "::std::os::raw::c_int"),
587 |             Type::ULong => write!(f, "::std::os::raw::c_ulong"),
588 |             Type::Long => write!(f, "::std::os::raw::c_long"),
589 | 
590 |             Type::U8 => write!(f, "u8"),
591 |             Type::I8 => write!(f, "i8"),
592 |             Type::U16 => write!(f, "u16"),
593 |             Type::I16 => write!(f, "i16"),
594 |             Type::U32 => write!(f, "u32"),
595 |             Type::I32 => write!(f, "i32"),
596 |             Type::U64 => write!(f, "u64"),
597 |             Type::I64 => write!(f, "i64"),
598 |             Type::F64 => write!(f, "f64"),
599 |             Type::USize => write!(f, "usize"),
600 |             Type::Enum(ref e) => write!(f, "enum {}", e),
601 |             Type::Class(ref class) => write!(f, "class {}", class),
602 |             Type::Callback(ref callback) => write!(f, "callback {}", callback),
603 |             Type::CallbackLValue(ref v) => write!(f, "callback lvalue {}", v),
604 |             Type::Ptr(ref target) => write!(f, "*mut {}", target),
605 |             Type::Ref(ref target) => write!(f, "&{}", target),
606 |             Type::Arr(ref target) => write!(f, "[{}]", target),
607 |         }
608 |     }
609 | }
610 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | //! A high-level wrapper around the [V8 Javascript engine][1].
  2 | //!
  3 | //! # Usage
  4 | //!
  5 | //! First, you need to create an [`Isolate`](isolate/struct.Isolate.html).  An isolate is a VM
  6 | //! instance with its own heap.  You should most likely create one per thread and re-use it as much
  7 | //! as possible.
  8 | //!
  9 | //! Then, you need to create a [`Context`](context/struct.Context.html).  A context is an execution
 10 | //! environment that allows separate, unrelated, JavaScript code to run in a single instance of V8.
 11 | //! You must explicitly specify the context in which you want any JavaScript code to be run.  You
 12 | //! should keep track of the context of a script manually as part of your application.
 13 | //!
 14 | //! # Example
 15 | //!
 16 | //! ```
 17 | //! use v8::{self, value};
 18 | //!
 19 | //! // Create a V8 heap
 20 | //! let isolate = v8::Isolate::new();
 21 | //! // Create a new context of execution
 22 | //! let context = v8::Context::new(&isolate);
 23 | //!
 24 | //! // Load the source code that we want to evaluate
 25 | //! let source = value::String::from_str(&isolate, "'Hello, ' + 'World!'");
 26 | //!
 27 | //! // Compile the source code.  `unwrap()` panics if the code is invalid,
 28 | //! // e.g. if there is a syntax  error.
 29 | //! let script = v8::Script::compile(&isolate, &context, &source).unwrap();
 30 | //!
 31 | //! // Run the compiled script.  `unwrap()` panics if the code threw an
 32 | //! // exception.
 33 | //! let result = script.run(&context).unwrap();
 34 | //!
 35 | //! // Convert the result to a value::String.
 36 | //! let result_str = result.to_string(&context);
 37 | //!
 38 | //! // Success!
 39 | //! assert_eq!("Hello, World!", result_str.value());
 40 | //! ```
 41 | //!
 42 | //! # Isolate foreground tasks
 43 | //!
 44 | //! Javascript can produce "deferred" or "time-outed" tasks that need to run on the main thread.
 45 | //! Additionally, V8 has a bunch of internal tasks it wants to perform regularly (for example GC).
 46 | //! The user should therefore call `isolate.run_enqueued_tasks()` regularly to allow these tasks to
 47 | //! run.
 48 | //!
 49 | //! [1]: https://developers.google.com/v8/
 50 | 
 51 | #![cfg_attr(all(feature="unstable", test), feature(test))]
 52 | 
 53 | #[macro_use]
 54 | extern crate error_chain;
 55 | #[macro_use]
 56 | extern crate lazy_static;
 57 | extern crate num_cpus;
 58 | extern crate v8_sys;
 59 | 
 60 | mod allocator;
 61 | mod platform;
 62 | #[macro_use]
 63 | mod util;
 64 | 
 65 | pub mod context;
 66 | pub mod error;
 67 | pub mod isolate;
 68 | pub mod script;
 69 | pub mod template;
 70 | pub mod value;
 71 | 
 72 | pub use context::Context;
 73 | pub use isolate::Isolate;
 74 | pub use script::Script;
 75 | pub use value::Value;
 76 | 
 77 | #[cfg(test)]
 78 | mod tests {
 79 |     use super::*;
 80 | 
 81 |     fn eval(source: &str) -> error::Result<(Isolate, Context, Value)> {
 82 |         let isolate = Isolate::new();
 83 |         let context = Context::new(&isolate);
 84 |         let name = value::String::from_str(&isolate, "test.js");
 85 |         let source = value::String::from_str(&isolate, source);
 86 |         let script = try!(Script::compile_with_name(&isolate, &context, &name, &source));
 87 |         let result = try!(script.run(&context));
 88 |         Ok((isolate, context, result))
 89 |     }
 90 | 
 91 |     #[test]
 92 |     fn hello_world() {
 93 |         let (_, _, v) = eval("'Hello, ' + 'World!'").unwrap();
 94 |         assert!(v.is_string());
 95 |         let result = v.into_string().unwrap().value();
 96 |         assert_eq!("Hello, World!", result);
 97 |     }
 98 | 
 99 |     #[test]
100 |     fn eval_undefined() {
101 |         let (_, _, v) = eval("undefined").unwrap();
102 |         assert!(v.is_undefined());
103 |     }
104 | 
105 |     #[test]
106 |     fn eval_null() {
107 |         let (_, _, v) = eval("null").unwrap();
108 |         assert!(v.is_null());
109 |     }
110 | 
111 |     #[test]
112 |     fn eval_bool_false() {
113 |         let (_, c, v) = eval("false").unwrap();
114 |         assert!(v.is_boolean());
115 |         assert!(v.is_false());
116 |         assert_eq!(false, v.boolean_value(&c));
117 |         let v = v.into_boolean().unwrap();
118 |         assert_eq!(false, v.value());
119 |     }
120 | 
121 |     #[test]
122 |     fn eval_bool_true() {
123 |         let (_, c, v) = eval("true").unwrap();
124 |         assert!(v.is_boolean());
125 |         assert!(v.is_true());
126 |         assert_eq!(true, v.boolean_value(&c));
127 |         let v = v.into_boolean().unwrap();
128 |         assert_eq!(true, v.value());
129 |     }
130 | 
131 |     #[test]
132 |     fn eval_string() {
133 |         let (_, c, v) = eval("'foo'").unwrap();
134 |         assert!(v.is_string());
135 |         assert_eq!("foo", v.to_string(&c).value());
136 |         let v = v.into_string().unwrap();
137 |         assert_eq!("foo", v.value());
138 |     }
139 | 
140 |     #[test]
141 |     fn eval_string_length() {
142 |         let (_, _, v) = eval("'foo'").unwrap();
143 |         assert!(v.is_string());
144 |         let v = v.into_string().unwrap();
145 |         assert_eq!(3, v.length());
146 |     }
147 | 
148 |     #[test]
149 |     fn eval_string_utf8_length_1() {
150 |         let (_, _, v) = eval("'a'").unwrap();
151 |         assert!(v.is_string());
152 |         let v = v.into_string().unwrap();
153 |         assert_eq!(1, v.utf8_length());
154 |     }
155 | 
156 |     #[test]
157 |     fn eval_string_utf8_length_2() {
158 |         let (_, _, v) = eval("'ä'").unwrap();
159 |         assert!(v.is_string());
160 |         let v = v.into_string().unwrap();
161 |         assert_eq!(2, v.utf8_length());
162 |     }
163 | 
164 |     #[test]
165 |     fn eval_string_utf8_length_3() {
166 |         let (_, _, v) = eval("'௵'").unwrap();
167 |         assert!(v.is_string());
168 |         let v = v.into_string().unwrap();
169 |         assert_eq!(3, v.utf8_length());
170 |     }
171 | 
172 |     #[test]
173 |     fn eval_string_utf8_length_4() {
174 |         let (_, _, v) = eval("'𒀰'").unwrap();
175 |         assert!(v.is_string());
176 |         let v = v.into_string().unwrap();
177 |         assert_eq!(4, v.utf8_length());
178 |     }
179 | 
180 |     #[test]
181 |     fn eval_string_edge_cases() {
182 |         let (_, _, v) = eval(r#"'foo\u0000\uffff௵𒀰\uD808\uDC30'"#).unwrap();
183 |         assert!(v.is_string());
184 |         let v = v.into_string().unwrap();
185 |         assert_eq!("foo\u{0000}\u{ffff}௵𒀰𒀰", v.value());
186 |     }
187 | 
188 |     #[test]
189 |     fn eval_uint32() {
190 |         let (_, c, v) = eval("42").unwrap();
191 |         assert!(v.is_number());
192 |         assert!(v.is_uint32());
193 |         assert_eq!(42, v.uint32_value(&c));
194 |         let v = v.into_uint32().unwrap();
195 |         assert_eq!(42, v.value());
196 |     }
197 | 
198 |     #[test]
199 |     fn eval_int32() {
200 |         let (_, c, v) = eval("-42").unwrap();
201 |         assert!(v.is_number());
202 |         assert!(v.is_int32());
203 |         assert_eq!(-42, v.int32_value(&c));
204 |         let v = v.into_int32().unwrap();
205 |         assert_eq!(-42, v.value());
206 |     }
207 | 
208 |     #[test]
209 |     fn eval_integer() {
210 |         // Use largest possible integer n such that all values of 0..n
211 |         // can be represented in Javascript
212 |         let (_, c, v) = eval("9007199254740992").unwrap();
213 |         assert!(v.is_number());
214 |         assert_eq!(9007199254740992, v.integer_value(&c));
215 |     }
216 | 
217 |     #[test]
218 |     fn eval_function() {
219 |         let (i, c, v) = eval("(function(a, b) { return a + b; })").unwrap();
220 |         let a = value::Integer::new(&i, 3);
221 |         let b = value::Integer::new(&i, 4);
222 |         let f = v.into_function().unwrap();
223 |         let r = f.call(&c, &[&a, &b]).unwrap();
224 |         assert!(r.is_int32());
225 |         assert_eq!(7, r.int32_value(&c));
226 |     }
227 | 
228 |     #[test]
229 |     fn eval_equals_true() {
230 |         let (i, c, v) = eval("({a: '', b: []})").unwrap();
231 |         assert!(v.is_object());
232 |         let v = v.into_object().unwrap();
233 |         let a_key = value::String::from_str(&i, "a");
234 |         let b_key = value::String::from_str(&i, "b");
235 |         assert!(v.get(&c, &a_key).equals(&c, &v.get(&c, &b_key)));
236 |     }
237 | 
238 |     #[test]
239 |     fn eval_equals_false() {
240 |         let (i, c, v) = eval("({a: '', b: 1})").unwrap();
241 |         assert!(v.is_object());
242 |         let v = v.into_object().unwrap();
243 |         let a_key = value::String::from_str(&i, "a");
244 |         let b_key = value::String::from_str(&i, "b");
245 |         assert!(!v.get(&c, &a_key).equals(&c, &v.get(&c, &b_key)));
246 |     }
247 | 
248 |     #[test]
249 |     fn eval_strict_equals_true() {
250 |         let (i, c, v) = eval("({a: 2, b: 2})").unwrap();
251 |         assert!(v.is_object());
252 |         let v = v.into_object().unwrap();
253 |         let a_key = value::String::from_str(&i, "a");
254 |         let b_key = value::String::from_str(&i, "b");
255 |         assert!(v.get(&c, &a_key).strict_equals(&v.get(&c, &b_key)));
256 |     }
257 | 
258 |     #[test]
259 |     fn eval_strict_equals_false() {
260 |         let (i, c, v) = eval("({a: '', b: []})").unwrap();
261 |         assert!(v.is_object());
262 |         let v = v.into_object().unwrap();
263 |         let a_key = value::String::from_str(&i, "a");
264 |         let b_key = value::String::from_str(&i, "b");
265 |         assert!(!v.get(&c, &a_key).strict_equals(&v.get(&c, &b_key)));
266 |     }
267 | 
268 |     #[test]
269 |     fn eval_same_value_true() {
270 |         let (i, c, v) = eval("(function() { var a = {}; return {a: a, b: a}; })()").unwrap();
271 |         assert!(v.is_object());
272 |         let v = v.into_object().unwrap();
273 |         let a_key = value::String::from_str(&i, "a");
274 |         let b_key = value::String::from_str(&i, "b");
275 |         assert!(v.get(&c, &a_key).same_value(&v.get(&c, &b_key)));
276 |     }
277 | 
278 |     #[test]
279 |     fn eval_same_value_false() {
280 |         let (i, c, v) = eval("({a: {}, b: {}})").unwrap();
281 |         assert!(v.is_object());
282 |         let v = v.into_object().unwrap();
283 |         let a_key = value::String::from_str(&i, "a");
284 |         let b_key = value::String::from_str(&i, "b");
285 |         assert!(!v.get(&c, &a_key).same_value(&v.get(&c, &b_key)));
286 |     }
287 | 
288 |     #[test]
289 |     fn eval_function_then_call() {
290 |         let (i, c, v) = eval("(function(a) { return a + a; })").unwrap();
291 |         assert!(v.is_function());
292 |         let f = v.into_function().unwrap();
293 |         let s = value::String::from_str(&i, "123");
294 |         let r = f.call(&c, &[&s]).unwrap();
295 |         assert!(r.is_string());
296 |         assert_eq!("123123", r.into_string().unwrap().value());
297 |     }
298 | 
299 |     #[test]
300 |     fn eval_function_then_call_with_this() {
301 |         let (i, c, v) = eval("(function() { return this.length; })").unwrap();
302 |         assert!(v.is_function());
303 |         let f = v.into_function().unwrap();
304 |         let s = value::String::from_str(&i, "123");
305 |         let r = f.call_with_this(&c, &s, &[]).unwrap();
306 |         assert!(r.is_int32());
307 |         assert_eq!(3, r.int32_value(&c));
308 |     }
309 | 
310 |     #[test]
311 |     fn eval_function_then_construct() {
312 |         let (i, c, v) = eval("(function ctor(a) { this.a = a; })").unwrap();
313 |         assert!(v.is_function());
314 |         let f = v.into_function().unwrap();
315 |         let a_key = value::String::from_str(&i, "a");
316 |         let s = value::String::from_str(&i, "123");
317 |         let r = f.call_as_constructor(&c, &[&s]).unwrap();
318 |         assert!(r.is_object());
319 |         let r = r.into_object().unwrap();
320 |         let r = r.get(&c, &a_key);
321 |         assert!(r.is_string());
322 |         let r = r.to_string(&c);
323 |         assert_eq!("123", r.value());
324 |     }
325 | 
326 |     #[test]
327 |     fn eval_array() {
328 |         let (_, c, v) = eval("[1, true, null]").unwrap();
329 |         assert!(v.is_array());
330 |         let v = v.into_object().unwrap();
331 |         assert!(v.get_index(&c, 0).is_number());
332 |         assert!(v.get_index(&c, 1).is_boolean());
333 |         assert!(v.get_index(&c, 2).is_null());
334 |     }
335 | 
336 |     #[test]
337 |     fn eval_object() {
338 |         let (i, c, v) = eval("({a: 2, b: true})").unwrap();
339 |         assert!(v.is_object());
340 |         let result = v.into_object().unwrap();
341 |         let a_key = value::String::from_str(&i, "a");
342 |         let b_key = value::String::from_str(&i, "b");
343 |         assert_eq!(2, result.get(&c, &a_key).integer_value(&c));
344 |         assert_eq!(true, result.get(&c, &b_key).boolean_value(&c));
345 |     }
346 | 
347 |     #[test]
348 |     fn eval_date() {
349 |         let (_, _, v) = eval("new Date(0)").unwrap();
350 |         assert!(v.is_date());
351 |     }
352 | 
353 |     #[test]
354 |     fn eval_arguments_object() {
355 |         let (_, _, v) = eval("(function() { return arguments; })()").unwrap();
356 |         assert!(v.is_arguments_object());
357 |     }
358 | 
359 |     #[test]
360 |     fn eval_boolean_object() {
361 |         let (_, _, v) = eval("new Boolean(true)").unwrap();
362 |         assert!(v.is_boolean_object());
363 |     }
364 | 
365 |     #[test]
366 |     fn eval_number_object() {
367 |         let (_, _, v) = eval("new Number(42)").unwrap();
368 |         assert!(v.is_number_object());
369 |     }
370 | 
371 |     #[test]
372 |     fn eval_string_object() {
373 |         let (_, _, v) = eval("new String('abc')").unwrap();
374 |         assert!(v.is_string_object());
375 |     }
376 | 
377 |     #[test]
378 |     fn eval_symbol_object() {
379 |         let (_, _, v) = eval("Object(Symbol('abc'))").unwrap();
380 |         assert!(v.is_symbol_object());
381 |     }
382 | 
383 |     #[test]
384 |     fn eval_native_error() {
385 |         let (_, _, v) = eval("new Error()").unwrap();
386 |         assert!(v.is_native_error());
387 |     }
388 | 
389 |     #[test]
390 |     fn eval_reg_exp() {
391 |         let (_, _, v) = eval("/./").unwrap();
392 |         assert!(v.is_reg_exp());
393 |     }
394 | 
395 |     #[test]
396 |     fn eval_generator_function() {
397 |         let (_, _, v) = eval("(function* () {})").unwrap();
398 |         assert!(v.is_generator_function());
399 |     }
400 | 
401 |     #[test]
402 |     fn eval_generator_object() {
403 |         let (_, _, v) = eval("(function* () {})()").unwrap();
404 |         assert!(v.is_generator_object());
405 |     }
406 | 
407 |     #[test]
408 |     fn eval_promise() {
409 |         let (_, _, v) = eval("new Promise(function() {})").unwrap();
410 |         assert!(v.is_promise());
411 |     }
412 | 
413 |     #[test]
414 |     fn eval_map() {
415 |         let (_, _, v) = eval("new Map()").unwrap();
416 |         assert!(v.is_map());
417 |     }
418 | 
419 |     #[test]
420 |     fn eval_set() {
421 |         let (_, _, v) = eval("new Set()").unwrap();
422 |         assert!(v.is_set());
423 |     }
424 | 
425 |     #[test]
426 |     fn eval_map_iterator() {
427 |         // TODO: how?
428 |     }
429 | 
430 |     #[test]
431 |     fn eval_set_iterator() {
432 |         // TODO: how?
433 |     }
434 | 
435 |     #[test]
436 |     fn eval_syntax_error() {
437 |         let result = eval("(");
438 | 
439 |         let error = result.unwrap_err();
440 |         match error.kind() {
441 |             &error::ErrorKind::Javascript(ref msg, _) => {
442 |                 assert_eq!("Uncaught SyntaxError: Unexpected end of input", msg);
443 |             }
444 |             x => panic!("Unexpected error kind: {:?}", x),
445 |         }
446 |     }
447 | 
448 |     #[test]
449 |     fn eval_exception() {
450 |         let result = eval("throw 'x';");
451 | 
452 |         let error = result.unwrap_err();
453 |         match error.kind() {
454 |             &error::ErrorKind::Javascript(ref msg, _) => {
455 |                 assert_eq!("Uncaught x", msg);
456 |             }
457 |             x => panic!("Unexpected error kind: {:?}", x),
458 |         }
459 |     }
460 | 
461 |     #[test]
462 |     fn eval_exception_stack() {
463 |         let result = eval(r#"
464 | (function() {
465 |   function x() {
466 |     y();
467 |   }
468 |   function y() {
469 |     eval("z()");
470 |   }
471 |   function z() {
472 |     new w();
473 |   }
474 |   function w() {
475 |     throw new Error('x');
476 |   }
477 |   x();
478 | })();
479 | "#);
480 | 
481 |         let error = result.unwrap_err();
482 |         match error.kind() {
483 |             &error::ErrorKind::Javascript(ref msg, ref stack_trace) => {
484 |                 assert_eq!("Uncaught Error: x", msg);
485 |                 assert_eq!("    at new w (test.js:13:11)\n    at z (test.js:10:5)\n    at eval \
486 |                             <anon>:1:1\n    at y (test.js:7:5)\n    at x (test.js:4:5)\n    at \
487 |                             test.js:15:3\n    at test.js:16:3\n",
488 |                            format!("{}", stack_trace));
489 |             }
490 |             x => panic!("Unexpected error kind: {:?}", x),
491 |         }
492 |     }
493 | 
494 |     #[test]
495 |     fn run_native_function_call() {
496 |         let isolate = Isolate::new();
497 |         let context = Context::new(&isolate);
498 | 
499 |         let function = value::Function::new(&isolate,
500 |                                             &context,
501 |                                             1,
502 |                                             Box::new(|mut info| Ok(info.args.remove(0))));
503 |         let param = value::Integer::new(&isolate, 42);
504 | 
505 |         let result = function.call(&context, &[&param]).unwrap();
506 |         assert_eq!(42, result.uint32_value(&context));
507 |     }
508 | 
509 |     #[test]
510 |     fn run_defined_function() {
511 |         let i = Isolate::new();
512 |         let c = Context::new(&i);
513 | 
514 |         let fi = i.clone();
515 |         let fc = c.clone();
516 |         let f = value::Function::new(&i,
517 |                                      &c,
518 |                                      2,
519 |                                      Box::new(move |info| {
520 |             assert_eq!(2, info.length);
521 |             let ref a = info.args[0];
522 |             assert!(a.is_int32());
523 |             let a = a.int32_value(&fc);
524 |             let ref b = info.args[1];
525 |             assert!(b.is_int32());
526 |             let b = b.int32_value(&fc);
527 | 
528 |             Ok(value::Integer::new(&fi, a + b).into())
529 |         }));
530 | 
531 |         let k = value::String::from_str(&i, "f");
532 |         c.global().set(&c, &k, &f);
533 | 
534 |         let name = value::String::from_str(&i, "test.js");
535 |         let source = value::String::from_str(&i, "f(2, 3)");
536 |         let script = Script::compile_with_name(&i, &c, &name, &source).unwrap();
537 |         let result = script.run(&c).unwrap();
538 | 
539 |         assert!(result.is_int32());
540 |         assert_eq!(5, result.int32_value(&c));
541 |     }
542 | 
543 |     fn test_function(info: value::FunctionCallbackInfo) -> Result<value::Value, value::Value> {
544 |         let i = info.isolate;
545 |         let c = i.current_context().unwrap();
546 | 
547 |         assert_eq!(2, info.length);
548 |         let ref a = info.args[0];
549 |         assert!(a.is_int32());
550 |         let a = a.int32_value(&c);
551 |         let ref b = info.args[1];
552 |         assert!(b.is_int32());
553 |         let b = b.int32_value(&c);
554 | 
555 |         Ok(value::Integer::new(&i, a + b).into())
556 |     }
557 | 
558 |     #[test]
559 |     fn run_defined_static_function() {
560 |         let i = Isolate::new();
561 |         let c = Context::new(&i);
562 |         let f = value::Function::new(&i, &c, 2, Box::new(test_function));
563 | 
564 |         let k = value::String::from_str(&i, "f");
565 |         c.global().set(&c, &k, &f);
566 | 
567 |         let name = value::String::from_str(&i, "test.js");
568 |         let source = value::String::from_str(&i, "f(2, 3)");
569 |         let script = Script::compile_with_name(&i, &c, &name, &source).unwrap();
570 |         let result = script.run(&c).unwrap();
571 | 
572 |         assert!(result.is_int32());
573 |         assert_eq!(5, result.int32_value(&c));
574 |     }
575 | 
576 |     #[test]
577 |     fn run_defined_function_template_instance() {
578 |         let i = Isolate::new();
579 |         let c = Context::new(&i);
580 |         let ft = template::FunctionTemplate::new(&i, &c, Box::new(test_function));
581 |         let f = ft.get_function(&c);
582 | 
583 |         let k = value::String::from_str(&i, "f");
584 |         c.global().set(&c, &k, &f);
585 | 
586 |         let name = value::String::from_str(&i, "test.js");
587 |         let source = value::String::from_str(&i, "f(2, 3)");
588 |         let script = Script::compile_with_name(&i, &c, &name, &source).unwrap();
589 |         let result = script.run(&c).unwrap();
590 | 
591 |         assert!(result.is_int32());
592 |         assert_eq!(5, result.int32_value(&c));
593 |     }
594 | 
595 |     #[test]
596 |     fn create_object_instance() {
597 |         let i = Isolate::new();
598 |         let c = Context::new(&i);
599 |         value::Object::new(&i, &c);
600 |     }
601 | 
602 |     #[test]
603 |     fn create_array_instance() {
604 |         let i = Isolate::new();
605 |         let c = Context::new(&i);
606 |         value::Array::new(&i, &c, 42);
607 |     }
608 | 
609 |     #[test]
610 |     fn create_object_template_instance() {
611 |         let i = Isolate::new();
612 |         let c = Context::new(&i);
613 |         let ot = template::ObjectTemplate::new(&i);
614 |         ot.set("test", &value::Integer::new(&i, 5));
615 | 
616 |         let o = ot.new_instance(&c);
617 |         let k = value::String::from_str(&i, "o");
618 |         c.global().set(&c, &k, &o);
619 | 
620 |         let name = value::String::from_str(&i, "test.js");
621 |         let source = value::String::from_str(&i, "o.test");
622 |         let script = Script::compile_with_name(&i, &c, &name, &source).unwrap();
623 |         let result = script.run(&c).unwrap();
624 | 
625 |         assert!(result.is_int32());
626 |         assert_eq!(5, result.int32_value(&c));
627 |     }
628 | 
629 |     #[test]
630 |     fn run_object_template_instance_function() {
631 |         let i = Isolate::new();
632 |         let c = Context::new(&i);
633 |         let ot = template::ObjectTemplate::new(&i);
634 |         let ft = template::FunctionTemplate::new(&i, &c, Box::new(test_function));
635 |         ot.set("f", &ft);
636 | 
637 |         let o = ot.new_instance(&c);
638 |         let k = value::String::from_str(&i, "o");
639 |         c.global().set(&c, &k, &o);
640 | 
641 |         let name = value::String::from_str(&i, "test.js");
642 |         let source = value::String::from_str(&i, "o.f(2, 3)");
643 |         let script = Script::compile_with_name(&i, &c, &name, &source).unwrap();
644 |         let result = script.run(&c).unwrap();
645 | 
646 |         assert!(result.is_int32());
647 |         assert_eq!(5, result.int32_value(&c));
648 |     }
649 | 
650 |     #[test]
651 |     fn isolate_rc() {
652 |         let (f, c, p) = {
653 |             let isolate = Isolate::new();
654 |             let context = Context::new(&isolate);
655 |             let param = value::Integer::new(&isolate, 42);
656 | 
657 |             let function = value::Function::new(&isolate,
658 |                                                 &context,
659 |                                                 1,
660 |                                                 Box::new(|mut info| Ok(info.args.remove(0))));
661 |             (function, context, param)
662 |         };
663 | 
664 |         let result = f.call(&c, &[&p]).unwrap();
665 |         assert_eq!(42, result.uint32_value(&c));
666 |     }
667 | 
668 |     #[test]
669 |     #[should_panic]
670 |     fn isolate_exception() {
671 |         let isolate = Isolate::new();
672 |         let context = Context::new(&isolate);
673 | 
674 |         let closure_isolate = isolate.clone();
675 |         let f = value::Function::new(&isolate,
676 |                 &context,
677 |                 0,
678 |                 Box::new(move |_| {
679 |                     let msg = value::String::from_str(&closure_isolate, "FooBar");
680 |                     let ex = value::Exception::error(&closure_isolate, &msg);
681 |                     Err(ex)
682 |                 }));
683 | 
684 |         let name = value::String::from_str(&isolate, "f");
685 |         context.global().set(&context, &name, &f);
686 | 
687 |         let source = value::String::from_str(&isolate, "f();");
688 |         let script = Script::compile(&isolate, &context, &source).unwrap();
689 |         script.run(&context).unwrap();
690 |     }
691 | 
692 |     #[test]
693 |     fn closure_lifetime() {
694 |         struct Foo {
695 |             msg: String,
696 |         }
697 | 
698 |         let isolate = Isolate::new();
699 |         let context = Context::new(&isolate);
700 | 
701 |         let f = {
702 |             let foo = Foo { msg: "Hello, World!".into() };
703 | 
704 |             let closure_isolate = isolate.clone();
705 |             value::Function::new(&isolate,
706 |                                  &context,
707 |                                  0,
708 |                                  Box::new(move |_| {
709 |                                      assert_eq!("Hello, World!", &foo.msg);
710 |                                      Ok(value::undefined(&closure_isolate).into())
711 |                                  }))
712 |         };
713 | 
714 |         let bar = Foo { msg: "Goodbye, World!".into() };
715 |         let name = value::String::from_str(&isolate, "f");
716 |         context.global().set(&context, &name, &f);
717 | 
718 |         let source = value::String::from_str(&isolate, "f();");
719 |         let script = Script::compile(&isolate, &context, &source).unwrap();
720 |         let result = script.run(&context).unwrap();
721 | 
722 |         assert_eq!("Goodbye, World!", bar.msg);
723 |         assert!(result.is_undefined());
724 |     }
725 | 
726 |     #[test]
727 |     #[should_panic="You dun goofed"]
728 |     fn propagate_panic() {
729 |         let isolate = Isolate::new();
730 |         let context = Context::new(&isolate);
731 | 
732 |         let f = value::Function::new(&isolate,
733 |                                      &context,
734 |                                      0,
735 |                                      Box::new(|_| panic!("You dun goofed")));
736 | 
737 |         f.call(&context, &[]).unwrap();
738 |     }
739 | 
740 |     #[test]
741 |     fn catch_panic() {
742 |         let isolate = Isolate::new();
743 |         let context = Context::new(&isolate);
744 | 
745 |         let f = value::Function::new(&isolate,
746 |                                      &context,
747 |                                      0,
748 |                                      Box::new(|_| panic!("Something: {}", 42)));
749 | 
750 |         let f_key = value::String::from_str(&isolate, "f");
751 |         context.global().set(&context, &f_key, &f);
752 | 
753 |         let source = value::String::from_str(&isolate,
754 |                                              "(function() { try { f(); } catch (e) { return \
755 |                                               e.message; } })()");
756 |         let script = Script::compile(&isolate, &context, &source).unwrap();
757 |         let result = script.run(&context).unwrap();
758 | 
759 |         let result = result.into_string().unwrap();
760 | 
761 |         assert_eq!("Rust panic: Something: 42", result.value());
762 |     }
763 | }
764 | 
765 | #[cfg(all(feature="unstable", test))]
766 | mod benches {
767 |     extern crate test;
768 | 
769 |     use super::*;
770 | 
771 |     #[bench]
772 |     fn js_function_call(bencher: &mut test::Bencher) {
773 |         let isolate = Isolate::new();
774 |         let context = Context::new(&isolate);
775 |         let name = value::String::from_str(&isolate, "test.js");
776 |         let source = value::String::from_str(&isolate, "(function(a) { return a; })");
777 |         let script = Script::compile_with_name(&isolate, &context, &name, &source).unwrap();
778 |         let result = script.run(&context).unwrap();
779 | 
780 |         let function = result.into_function().unwrap();
781 |         let param = value::Integer::new(&isolate, 42);
782 | 
783 |         bencher.iter(|| function.call(&context, &[&param]).unwrap());
784 |     }
785 | 
786 |     #[bench]
787 |     fn native_function_call(bencher: &mut test::Bencher) {
788 |         let isolate = Isolate::new();
789 |         let context = Context::new(&isolate);
790 | 
791 |         let function = value::Function::new(&isolate,
792 |                                             &context,
793 |                                             1,
794 |                                             Box::new(|mut info| Ok(info.args.remove(0))));
795 |         let param = value::Integer::new(&isolate, 42);
796 | 
797 |         bencher.iter(|| function.call(&context, &[&param]).unwrap());
798 |     }
799 | }
800 | 


--------------------------------------------------------------------------------
/v8-sys/src/v8-glue.cc:
--------------------------------------------------------------------------------
   1 | #include "v8-glue.h"
   2 | 
   3 | #include <cstdlib>
   4 | #include <cstring>
   5 | 
   6 | 
   7 | template<typename A> v8::Persistent<A> *unwrap(v8::Isolate *isolate,
   8 |                                                v8::Local<A> value)
   9 | {
  10 |     if (value.IsEmpty()) {
  11 |         return nullptr;
  12 |     } else {
  13 |         return new v8::Persistent<A>(isolate, value);
  14 |     }
  15 | }
  16 | 
  17 | template<typename A> v8::Persistent<A> *unwrap(v8::Isolate *isolate,
  18 |                                                v8::MaybeLocal<A> value)
  19 | {
  20 |     v8::Local<A> local;
  21 | 
  22 |     if (value.ToLocal(&local)) {
  23 |         return new v8::Persistent<A>(isolate, local);
  24 |     } else {
  25 |         return nullptr;
  26 |     }
  27 | }
  28 | 
  29 | #define UNWRAP_MAYBE_PRIM(PRIM, NAME, MAYBE)    \
  30 |     MAYBE unwrap_maybe_##NAME(                  \
  31 |         v8::Isolate *isolate,                   \
  32 |         v8::Maybe<PRIM> maybe_value)            \
  33 |     {                                           \
  34 |         PRIM value;                             \
  35 |         bool is_set = maybe_value.To(&value);   \
  36 |                                                 \
  37 |         return MAYBE {                          \
  38 |             is_set,                             \
  39 |             value,                              \
  40 |         };                                      \
  41 |     }
  42 | 
  43 | UNWRAP_MAYBE_PRIM(bool, bool, MaybeBool)
  44 | UNWRAP_MAYBE_PRIM(int, int, MaybeInt)
  45 | UNWRAP_MAYBE_PRIM(unsigned int, uint, MaybeUInt)
  46 | UNWRAP_MAYBE_PRIM(long, long, MaybeLong)
  47 | UNWRAP_MAYBE_PRIM(unsigned long, ulong, MaybeULong)
  48 | UNWRAP_MAYBE_PRIM(uint32_t, u32, MaybeU32)
  49 | UNWRAP_MAYBE_PRIM(int32_t, i32, MaybeI32)
  50 | UNWRAP_MAYBE_PRIM(uint64_t, u64, MaybeU64)
  51 | UNWRAP_MAYBE_PRIM(int64_t, i64, MaybeI64)
  52 | UNWRAP_MAYBE_PRIM(double, f64, MaybeF64)
  53 | 
  54 | PropertyAttribute unwrap(
  55 |     v8::Isolate *isolate,
  56 |     v8::Maybe<v8::PropertyAttribute> maybe_value) {
  57 |     v8::PropertyAttribute value;
  58 | 
  59 |     if (maybe_value.To(&value)) {
  60 |         PropertyAttribute result = PropertyAttribute_None;
  61 | 
  62 |         if (value & v8::PropertyAttribute::ReadOnly) {
  63 |             result = PropertyAttribute(result | PropertyAttribute_ReadOnly);
  64 |         }
  65 | 
  66 |         if (value & v8::PropertyAttribute::DontEnum) {
  67 |             result = PropertyAttribute(result | PropertyAttribute_DontEnum);
  68 |         }
  69 | 
  70 |         if (value & v8::PropertyAttribute::DontDelete) {
  71 |             result = PropertyAttribute(result | PropertyAttribute_DontDelete);
  72 |         }
  73 | 
  74 |         return result;
  75 |     } else {
  76 |         return PropertyAttribute_Absent;
  77 |     }
  78 | }
  79 | 
  80 | PromiseRejectEvent unwrap(
  81 |     v8::Isolate *isolate,
  82 |     v8::PromiseRejectEvent value) {
  83 |     switch (value) {
  84 |     default:
  85 |     case v8::PromiseRejectEvent::kPromiseRejectWithNoHandler:
  86 |         return PromiseRejectEvent_kPromiseRejectWithNoHandler;
  87 |     case v8::kPromiseHandlerAddedAfterReject:
  88 |         return PromiseRejectEvent_kPromiseHandlerAddedAfterReject;
  89 |     }
  90 | }
  91 | 
  92 | template<typename A> A unwrap(v8::Isolate *isolate, A &&value) {
  93 |     return value;
  94 | }
  95 | 
  96 | template<typename A> v8::Local<A> wrap(v8::Isolate *isolate,
  97 |                                        v8::Persistent<A> *value)
  98 | {
  99 |     if (value) {
 100 |         return value->Get(isolate);
 101 |     } else {
 102 |         return v8::Local<A>();
 103 |     }
 104 | }
 105 | 
 106 | v8::AccessControl wrap(v8::Isolate *isolate, AccessControl value) {
 107 |     v8::AccessControl result = v8::AccessControl::DEFAULT;
 108 | 
 109 |     if (value & AccessControl_ALL_CAN_READ) {
 110 |         result = v8::AccessControl(result | v8::AccessControl::ALL_CAN_READ);
 111 |     }
 112 | 
 113 |     if (value & AccessControl_ALL_CAN_WRITE) {
 114 |         result = v8::AccessControl(result | v8::AccessControl::ALL_CAN_WRITE);
 115 |     }
 116 | 
 117 |     if (value & AccessControl_PROHIBITS_OVERWRITING) {
 118 |         result = v8::AccessControl(result | v8::AccessControl::PROHIBITS_OVERWRITING);
 119 |     }
 120 | 
 121 |     return result;
 122 | }
 123 | 
 124 | v8::PropertyFilter wrap(v8::Isolate *isolate, PropertyFilter value) {
 125 |     v8::PropertyFilter result = v8::PropertyFilter::ALL_PROPERTIES;
 126 | 
 127 |     if (value & PropertyFilter_ONLY_WRITABLE) {
 128 |         result = v8::PropertyFilter(result | v8::PropertyFilter::ONLY_WRITABLE);
 129 |     }
 130 | 
 131 |     if (value & PropertyFilter_ONLY_ENUMERABLE) {
 132 |         result = v8::PropertyFilter(result | v8::PropertyFilter::ONLY_ENUMERABLE);
 133 |     }
 134 | 
 135 |     if (value & PropertyFilter_ONLY_CONFIGURABLE) {
 136 |         result = v8::PropertyFilter(result | v8::PropertyFilter::ONLY_CONFIGURABLE);
 137 |     }
 138 | 
 139 |     if (value & PropertyFilter_SKIP_STRINGS) {
 140 |         result = v8::PropertyFilter(result | v8::PropertyFilter::SKIP_STRINGS);
 141 |     }
 142 | 
 143 |     if (value & PropertyFilter_SKIP_SYMBOLS) {
 144 |         result = v8::PropertyFilter(result | v8::PropertyFilter::SKIP_SYMBOLS);
 145 |     }
 146 | 
 147 |     return result;
 148 | }
 149 | 
 150 | v8::KeyCollectionMode wrap(v8::Isolate *isolate, KeyCollectionMode value) {
 151 |     switch (value) {
 152 |     default:
 153 |     case KeyCollectionMode_kOwnOnly:
 154 |         return v8::KeyCollectionMode::kOwnOnly;
 155 |     case KeyCollectionMode_kIncludePrototypes:
 156 |         return v8::KeyCollectionMode::kIncludePrototypes;
 157 |     }
 158 | }
 159 | 
 160 | v8::IndexFilter wrap(v8::Isolate *isolate, IndexFilter value) {
 161 |     switch (value) {
 162 |     default:
 163 |     case IndexFilter_kIncludeIndices:
 164 |         return v8::IndexFilter::kIncludeIndices;
 165 |     case IndexFilter_kSkipIndices:
 166 |         return v8::IndexFilter::kSkipIndices;
 167 |     }
 168 | }
 169 | 
 170 | v8::IntegrityLevel wrap(v8::Isolate *isolate, IntegrityLevel value) {
 171 |     switch (value) {
 172 |     default:
 173 |     case IntegrityLevel_kFrozen:
 174 |         return v8::IntegrityLevel::kFrozen;
 175 |     case IntegrityLevel_kSealed:
 176 |         return v8::IntegrityLevel::kSealed;
 177 |     }
 178 | }
 179 | 
 180 | v8::PropertyAttribute wrap(v8::Isolate *isolate, PropertyAttribute value) {
 181 |     if (value == PropertyAttribute_Absent) {
 182 |         return v8::PropertyAttribute::None;
 183 |     }
 184 | 
 185 |     v8::PropertyAttribute result = v8::PropertyAttribute::None;
 186 | 
 187 |     if (value & PropertyAttribute_ReadOnly) {
 188 |         result = v8::PropertyAttribute(result | v8::PropertyAttribute::ReadOnly);
 189 |     }
 190 | 
 191 |     if (value & PropertyAttribute_DontEnum) {
 192 |         result = v8::PropertyAttribute(result | v8::PropertyAttribute::DontEnum);
 193 |     }
 194 | 
 195 |     if (value & PropertyAttribute_DontDelete) {
 196 |         result = v8::PropertyAttribute(result | v8::PropertyAttribute::DontDelete);
 197 |     }
 198 | 
 199 |     return result;
 200 | }
 201 | 
 202 | v8::PropertyHandlerFlags wrap(v8::Isolate *isolate, PropertyHandlerFlags value) {
 203 |     v8::PropertyHandlerFlags result = v8::PropertyHandlerFlags::kNone;
 204 | 
 205 |     if (value & PropertyHandlerFlags_kAllCanRead) {
 206 |         result = v8::PropertyHandlerFlags(int(result) | int(v8::PropertyHandlerFlags::kAllCanRead));
 207 |     }
 208 | 
 209 |     if (value & PropertyHandlerFlags_kNonMasking) {
 210 |         result = v8::PropertyHandlerFlags(int(result) | int(v8::PropertyHandlerFlags::kNonMasking));
 211 |     }
 212 | 
 213 |     if (value & PropertyHandlerFlags_kOnlyInterceptStrings) {
 214 |         result = v8::PropertyHandlerFlags(int(result) | int(v8::PropertyHandlerFlags::kOnlyInterceptStrings));
 215 |     }
 216 | 
 217 |     return result;
 218 | }
 219 | 
 220 | v8::ConstructorBehavior wrap(v8::Isolate *isolate, ConstructorBehavior value) {
 221 |     switch (value) {
 222 |     default:
 223 |     case ConstructorBehavior_kThrow:
 224 |         return v8::ConstructorBehavior::kThrow;
 225 |     case ConstructorBehavior_kAllow:
 226 |         return v8::ConstructorBehavior::kAllow;
 227 |     }
 228 | }
 229 | 
 230 | v8::PromiseRejectEvent wrap(v8::Isolate *isolate, PromiseRejectEvent value) {
 231 |     switch (value) {
 232 |     default:
 233 |     case PromiseRejectEvent_kPromiseRejectWithNoHandler:
 234 |         return v8::PromiseRejectEvent::kPromiseRejectWithNoHandler;
 235 |     case PromiseRejectEvent_kPromiseHandlerAddedAfterReject:
 236 |         return v8::PromiseRejectEvent::kPromiseHandlerAddedAfterReject;
 237 |     }
 238 | }
 239 | 
 240 | v8::Intrinsic wrap(v8::Isolate *isolate, Intrinsic value) {
 241 |     switch (value) {
 242 |     default:
 243 | #define V8_SWITCH_INTRINSIC(name, iname) case Intrinsic_k##name: return v8::Intrinsic::k##name;
 244 |         V8_INTRINSICS_LIST(V8_SWITCH_INTRINSIC)
 245 | #undef V8_SWITCH_INTRINSIC
 246 |     }
 247 | }
 248 | 
 249 | v8::ArrayBufferCreationMode wrap(v8::Isolate *isolate, ArrayBufferCreationMode value) {
 250 |     switch (value) {
 251 |     default:
 252 |     case ArrayBufferCreationMode_kInternalized:
 253 |         return v8::ArrayBufferCreationMode::kInternalized;
 254 |     case ArrayBufferCreationMode_kExternalized:
 255 |         return v8::ArrayBufferCreationMode::kExternalized;
 256 |     }
 257 | }
 258 | 
 259 | template<typename A>
 260 | PropertyCallbackInfo build_callback_info(
 261 |     const v8::PropertyCallbackInfo<A> &info,
 262 |     v8::Local<v8::Value> data) {
 263 | 
 264 |     v8::Isolate *isolate = info.GetIsolate();
 265 | 
 266 |     PropertyCallbackInfo result = PropertyCallbackInfo {
 267 |         isolate,
 268 |         unwrap(isolate, data),
 269 |         unwrap(isolate, info.This()),
 270 |         unwrap(isolate, info.Holder()),
 271 |         nullptr,
 272 |         info.ShouldThrowOnError(),
 273 |         nullptr,
 274 |     };
 275 | 
 276 |     return result;
 277 | }
 278 | 
 279 | template<typename A>
 280 | FunctionCallbackInfo build_callback_info(
 281 |     const v8::FunctionCallbackInfo<A> &info,
 282 |     v8::Local<v8::Value> data) {
 283 | 
 284 |     v8::Isolate *isolate = info.GetIsolate();
 285 | 
 286 |     int length = info.Length();
 287 |     ValueRef *args = new ValueRef[length];
 288 | 
 289 |     for (int i = 0; i < length; i++) {
 290 |         v8::Local<v8::Value> arg = info[i];
 291 |         ValueRef unwrapped_arg = unwrap(isolate, arg);
 292 |         args[i] = unwrapped_arg;
 293 |     }
 294 | 
 295 |     FunctionCallbackInfo result = FunctionCallbackInfo {
 296 |         length,
 297 |         args,
 298 |         unwrap(isolate, info.This()),
 299 |         unwrap(isolate, info.Holder()),
 300 |         unwrap(isolate, info.NewTarget()),
 301 |         info.IsConstructCall(),
 302 |         unwrap(isolate, data),
 303 |         isolate,
 304 |         nullptr,
 305 |         nullptr,
 306 |     };
 307 | 
 308 |     return result;
 309 | }
 310 | 
 311 | enum class PropertyHandlerFields {
 312 |     Getter, Setter, Query, Deleter, Enumerator, Data, Flags, Max
 313 | };
 314 | 
 315 | void generic_named_property_handler_getter(
 316 |     v8::Local<v8::Name> property,
 317 |     const v8::PropertyCallbackInfo<v8::Value> &info) {
 318 |     v8::Isolate *isolate = info.GetIsolate();
 319 |     v8::Isolate::Scope isolate_scope(isolate);
 320 |     v8::HandleScope scope(isolate);
 321 |     v8::Local<v8::Object> outer_data =
 322 |         v8::Local<v8::Object>::Cast(info.Data());
 323 |     GenericNamedPropertyGetterCallback getter =
 324 |         (GenericNamedPropertyGetterCallback)
 325 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Getter);
 326 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 327 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 328 | 
 329 |     getter(unwrap(isolate, property), &callback_info);
 330 | 
 331 |     if (callback_info.ThrownValue) {
 332 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 333 |     } else if (callback_info.ReturnValue) {
 334 |         info.GetReturnValue().Set(wrap(isolate, callback_info.ReturnValue));
 335 |     }
 336 | }
 337 | 
 338 | void generic_named_property_handler_setter(
 339 |     v8::Local<v8::Name> property,
 340 |     v8::Local<v8::Value> value,
 341 |     const v8::PropertyCallbackInfo<v8::Value> &info) {
 342 |     v8::Isolate *isolate = info.GetIsolate();
 343 |     v8::Isolate::Scope isolate_scope(isolate);
 344 |     v8::HandleScope scope(isolate);
 345 |     v8::Local<v8::Object> outer_data =
 346 |         v8::Local<v8::Object>::Cast(info.Data());
 347 |     GenericNamedPropertySetterCallback setter =
 348 |         (GenericNamedPropertySetterCallback)
 349 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Setter);
 350 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 351 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 352 | 
 353 |     setter(unwrap(isolate, property), unwrap(isolate, value), &callback_info);
 354 | 
 355 |     if (callback_info.ThrownValue) {
 356 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 357 |     } else if (callback_info.ReturnValue) {
 358 |         info.GetReturnValue().Set(wrap(isolate, callback_info.ReturnValue));
 359 |     }
 360 | }
 361 | 
 362 | void generic_named_property_handler_query(
 363 |     v8::Local<v8::Name> property,
 364 |     const v8::PropertyCallbackInfo<v8::Integer> &info) {
 365 |     v8::Isolate *isolate = info.GetIsolate();
 366 |     v8::Isolate::Scope isolate_scope(isolate);
 367 |     v8::HandleScope scope(isolate);
 368 |     v8::Local<v8::Object> outer_data =
 369 |         v8::Local<v8::Object>::Cast(info.Data());
 370 |     GenericNamedPropertyQueryCallback query =
 371 |         (GenericNamedPropertyQueryCallback)
 372 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Query);
 373 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 374 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 375 | 
 376 |     query(unwrap(isolate, property), &callback_info);
 377 | 
 378 |     if (callback_info.ThrownValue) {
 379 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 380 |     } else if (callback_info.ReturnValue) {
 381 |         info.GetReturnValue().Set(v8::Local<v8::Integer>::Cast(wrap(isolate, callback_info.ReturnValue)));
 382 |     }
 383 | }
 384 | 
 385 | void generic_named_property_handler_deleter(
 386 |     v8::Local<v8::Name> property,
 387 |     const v8::PropertyCallbackInfo<v8::Boolean> &info) {
 388 |     v8::Isolate *isolate = info.GetIsolate();
 389 |     v8::Isolate::Scope isolate_scope(isolate);
 390 |     v8::HandleScope scope(isolate);
 391 |     v8::Local<v8::Object> outer_data =
 392 |         v8::Local<v8::Object>::Cast(info.Data());
 393 |     GenericNamedPropertyDeleterCallback deleter =
 394 |         (GenericNamedPropertyDeleterCallback)
 395 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Deleter);
 396 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 397 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 398 | 
 399 |     deleter(unwrap(isolate, property), &callback_info);
 400 | 
 401 |     if (callback_info.ThrownValue) {
 402 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 403 |     } else if (callback_info.ReturnValue) {
 404 |         info.GetReturnValue().Set(v8::Local<v8::Boolean>::Cast(wrap(isolate, callback_info.ReturnValue)));
 405 |     }
 406 | }
 407 | 
 408 | void generic_named_property_handler_enumerator(
 409 |     const v8::PropertyCallbackInfo<v8::Array> &info) {
 410 |     v8::Isolate *isolate = info.GetIsolate();
 411 |     v8::Isolate::Scope isolate_scope(isolate);
 412 |     v8::HandleScope scope(isolate);
 413 |     v8::Local<v8::Object> outer_data =
 414 |         v8::Local<v8::Object>::Cast(info.Data());
 415 |     GenericNamedPropertyEnumeratorCallback enumerator =
 416 |         (GenericNamedPropertyEnumeratorCallback)
 417 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Enumerator);
 418 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 419 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 420 | 
 421 |     enumerator(&callback_info);
 422 | 
 423 |     if (callback_info.ThrownValue) {
 424 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 425 |     } else if (callback_info.ReturnValue) {
 426 |         info.GetReturnValue().Set(v8::Local<v8::Array>::Cast(wrap(isolate, callback_info.ReturnValue)));
 427 |     }
 428 | }
 429 | 
 430 | v8::NamedPropertyHandlerConfiguration wrap(
 431 |     v8::Isolate *isolate,
 432 |     NamedPropertyHandlerConfiguration value) {
 433 |     v8::Local<v8::ObjectTemplate> outer_data_template =
 434 |         v8::ObjectTemplate::New(isolate);
 435 |     outer_data_template->SetInternalFieldCount((int) PropertyHandlerFields::Max);
 436 |     v8::Local<v8::Object> outer_data = outer_data_template->NewInstance();
 437 | 
 438 |     v8::GenericNamedPropertyGetterCallback getter;
 439 |     v8::GenericNamedPropertySetterCallback setter;
 440 |     v8::GenericNamedPropertyQueryCallback query;
 441 |     v8::GenericNamedPropertyDeleterCallback deleter;
 442 |     v8::GenericNamedPropertyEnumeratorCallback enumerator;
 443 | 
 444 |     if (value.getter) {
 445 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Getter, (void *) value.getter);
 446 |         getter = generic_named_property_handler_getter;
 447 |     } else {
 448 |         getter = nullptr;
 449 |     }
 450 | 
 451 |     if (value.setter) {
 452 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Setter, (void *) value.setter);
 453 |         setter = generic_named_property_handler_setter;
 454 |     } else {
 455 |         setter = nullptr;
 456 |     }
 457 | 
 458 |     if (value.query) {
 459 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Query, (void *) value.query);
 460 |         query = generic_named_property_handler_query;
 461 |     } else {
 462 |         query = nullptr;
 463 |     }
 464 | 
 465 |     if (value.deleter) {
 466 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Deleter, (void *) value.deleter);
 467 |         deleter = generic_named_property_handler_deleter;
 468 |     } else {
 469 |         deleter = nullptr;
 470 |     }
 471 | 
 472 |     if (value.enumerator) {
 473 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Enumerator, (void *) value.enumerator);
 474 |         enumerator = generic_named_property_handler_enumerator;
 475 |     } else {
 476 |         enumerator = nullptr;
 477 |     }
 478 | 
 479 |     outer_data->SetInternalField((int) PropertyHandlerFields::Data, wrap(isolate, value.data));
 480 | 
 481 |     return v8::NamedPropertyHandlerConfiguration(
 482 |         getter,
 483 |         setter,
 484 |         query,
 485 |         deleter,
 486 |         enumerator,
 487 |         outer_data,
 488 |         wrap(isolate, value.flags));
 489 | }
 490 | 
 491 | void indexed_property_handler_getter(
 492 |     uint32_t index,
 493 |     const v8::PropertyCallbackInfo<v8::Value> &info) {
 494 |     v8::Isolate *isolate = info.GetIsolate();
 495 |     v8::Isolate::Scope isolate_scope(isolate);
 496 |     v8::HandleScope scope(isolate);
 497 |     v8::Local<v8::Object> outer_data =
 498 |         v8::Local<v8::Object>::Cast(info.Data());
 499 |     IndexedPropertyGetterCallback getter =
 500 |         (IndexedPropertyGetterCallback)
 501 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Getter);
 502 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 503 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 504 | 
 505 |     getter(index, &callback_info);
 506 | 
 507 |     if (callback_info.ThrownValue) {
 508 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 509 |     } else if (callback_info.ReturnValue) {
 510 |         info.GetReturnValue().Set(wrap(isolate, callback_info.ReturnValue));
 511 |     }
 512 | }
 513 | 
 514 | void indexed_property_handler_setter(
 515 |     uint32_t index,
 516 |     v8::Local<v8::Value> value,
 517 |     const v8::PropertyCallbackInfo<v8::Value> &info) {
 518 |     v8::Isolate *isolate = info.GetIsolate();
 519 |     v8::Isolate::Scope isolate_scope(isolate);
 520 |     v8::HandleScope scope(isolate);
 521 |     v8::Local<v8::Object> outer_data =
 522 |         v8::Local<v8::Object>::Cast(info.Data());
 523 |     IndexedPropertySetterCallback setter =
 524 |         (IndexedPropertySetterCallback)
 525 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Setter);
 526 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 527 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 528 | 
 529 |     setter(index, unwrap(isolate, value), &callback_info);
 530 | 
 531 |     if (callback_info.ThrownValue) {
 532 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 533 |     } else if (callback_info.ReturnValue) {
 534 |         info.GetReturnValue().Set(wrap(isolate, callback_info.ReturnValue));
 535 |     }
 536 | }
 537 | 
 538 | void indexed_property_handler_query(
 539 |     uint32_t index,
 540 |     const v8::PropertyCallbackInfo<v8::Integer> &info) {
 541 |     v8::Isolate *isolate = info.GetIsolate();
 542 |     v8::Isolate::Scope isolate_scope(isolate);
 543 |     v8::HandleScope scope(isolate);
 544 |     v8::Local<v8::Object> outer_data =
 545 |         v8::Local<v8::Object>::Cast(info.Data());
 546 |     IndexedPropertyQueryCallback query =
 547 |         (IndexedPropertyQueryCallback)
 548 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Query);
 549 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 550 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 551 | 
 552 |     query(index, &callback_info);
 553 | 
 554 |     if (callback_info.ThrownValue) {
 555 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 556 |     } else if (callback_info.ReturnValue) {
 557 |         info.GetReturnValue().Set(v8::Local<v8::Integer>::Cast(wrap(isolate, callback_info.ReturnValue)));
 558 |     }
 559 | }
 560 | 
 561 | void indexed_property_handler_deleter(
 562 |     uint32_t index,
 563 |     const v8::PropertyCallbackInfo<v8::Boolean> &info) {
 564 |     v8::Isolate *isolate = info.GetIsolate();
 565 |     v8::Isolate::Scope isolate_scope(isolate);
 566 |     v8::HandleScope scope(isolate);
 567 |     v8::Local<v8::Object> outer_data =
 568 |         v8::Local<v8::Object>::Cast(info.Data());
 569 |     IndexedPropertyDeleterCallback deleter =
 570 |         (IndexedPropertyDeleterCallback)
 571 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Deleter);
 572 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 573 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 574 | 
 575 |     deleter(index, &callback_info);
 576 | 
 577 |     if (callback_info.ThrownValue) {
 578 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 579 |     } else if (callback_info.ReturnValue) {
 580 |         info.GetReturnValue().Set(v8::Local<v8::Boolean>::Cast(wrap(isolate, callback_info.ReturnValue)));
 581 |     }
 582 | }
 583 | 
 584 | void indexed_property_handler_enumerator(
 585 |     const v8::PropertyCallbackInfo<v8::Array> &info) {
 586 |     v8::Isolate *isolate = info.GetIsolate();
 587 |     v8::Isolate::Scope isolate_scope(isolate);
 588 |     v8::HandleScope scope(isolate);
 589 |     v8::Local<v8::Object> outer_data =
 590 |         v8::Local<v8::Object>::Cast(info.Data());
 591 |     IndexedPropertyEnumeratorCallback enumerator =
 592 |         (IndexedPropertyEnumeratorCallback)
 593 |         outer_data->GetAlignedPointerFromInternalField((int) PropertyHandlerFields::Enumerator);
 594 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) PropertyHandlerFields::Data);
 595 |     PropertyCallbackInfo callback_info = build_callback_info(info, data);
 596 | 
 597 |     enumerator(&callback_info);
 598 | 
 599 |     if (callback_info.ThrownValue) {
 600 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
 601 |     } else if (callback_info.ReturnValue) {
 602 |         info.GetReturnValue().Set(v8::Local<v8::Array>::Cast(wrap(isolate, callback_info.ReturnValue)));
 603 |     }
 604 | }
 605 | 
 606 | v8::IndexedPropertyHandlerConfiguration wrap(
 607 |     v8::Isolate *isolate,
 608 |     IndexedPropertyHandlerConfiguration value) {
 609 |     v8::Local<v8::ObjectTemplate> outer_data_template =
 610 |         v8::ObjectTemplate::New(isolate);
 611 |     outer_data_template->SetInternalFieldCount((int) PropertyHandlerFields::Max);
 612 |     v8::Local<v8::Object> outer_data = outer_data_template->NewInstance();
 613 | 
 614 |     v8::IndexedPropertyGetterCallback getter;
 615 |     v8::IndexedPropertySetterCallback setter;
 616 |     v8::IndexedPropertyQueryCallback query;
 617 |     v8::IndexedPropertyDeleterCallback deleter;
 618 |     v8::IndexedPropertyEnumeratorCallback enumerator;
 619 | 
 620 |     if (value.getter) {
 621 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Getter, (void *) value.getter);
 622 |         getter = indexed_property_handler_getter;
 623 |     } else {
 624 |         getter = nullptr;
 625 |     }
 626 | 
 627 |     if (value.setter) {
 628 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Setter, (void *) value.setter);
 629 |         setter = indexed_property_handler_setter;
 630 |     } else {
 631 |         setter = nullptr;
 632 |     }
 633 | 
 634 |     if (value.query) {
 635 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Query, (void *) value.query);
 636 |         query = indexed_property_handler_query;
 637 |     } else {
 638 |         query = nullptr;
 639 |     }
 640 | 
 641 |     if (value.deleter) {
 642 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Deleter, (void *) value.deleter);
 643 |         deleter = indexed_property_handler_deleter;
 644 |     } else {
 645 |         deleter = nullptr;
 646 |     }
 647 | 
 648 |     if (value.enumerator) {
 649 |         outer_data->SetAlignedPointerInInternalField((int) PropertyHandlerFields::Enumerator, (void *) value.enumerator);
 650 |         enumerator = indexed_property_handler_enumerator;
 651 |     } else {
 652 |         enumerator = nullptr;
 653 |     }
 654 | 
 655 |     outer_data->SetInternalField((int) PropertyHandlerFields::Data, wrap(isolate, value.data));
 656 | 
 657 |     return v8::IndexedPropertyHandlerConfiguration(
 658 |         getter,
 659 |         setter,
 660 |         query,
 661 |         deleter,
 662 |         enumerator,
 663 |         outer_data,
 664 |         wrap(isolate, value.flags));
 665 | }
 666 | 
 667 | template<typename A> A wrap(v8::Isolate *isolate, A value) {
 668 |     return value;
 669 | }
 670 | 
 671 | void handle_exception(RustContext &c, v8::TryCatch &try_catch) {
 672 |     if (try_catch.HasCaught()) {
 673 |         *c.exception = unwrap(c.isolate, try_catch.Exception());
 674 |         *c.message = unwrap(c.isolate, try_catch.Message());
 675 |     }
 676 | }
 677 | 
 678 | class GluePlatform : public v8::Platform {
 679 | public:
 680 |     GluePlatform(v8_PlatformFunctions platform_functions)
 681 |         : _platform_functions(platform_functions)
 682 |     {}
 683 | 
 684 |     virtual ~GluePlatform() {
 685 |         this->_platform_functions.Destroy();
 686 |     }
 687 | 
 688 |     virtual size_t NumberOfAvailableBackgroundThreads() {
 689 |         return this->_platform_functions.NumberOfAvailableBackgroundThreads();
 690 |     }
 691 | 
 692 |     virtual void CallOnBackgroundThread(v8::Task *task,
 693 |                                         v8::Platform::ExpectedRuntime expected_runtime) {
 694 |         v8_ExpectedRuntime rt;
 695 | 
 696 |         switch (expected_runtime) {
 697 |         default:
 698 |         case v8::Platform::kShortRunningTask:
 699 |             rt = SHORT_RUNNING_TASK;
 700 |             break;
 701 |         case v8::Platform::kLongRunningTask:
 702 |             rt = LONG_RUNNING_TASK;
 703 |             break;
 704 |         }
 705 | 
 706 |         this->_platform_functions.CallOnBackgroundThread(task, rt);
 707 |     }
 708 | 
 709 |     virtual void CallOnForegroundThread(v8::Isolate *isolate, v8::Task *task) {
 710 |         this->_platform_functions.CallOnForegroundThread(isolate, task);
 711 |     }
 712 | 
 713 |     virtual void CallDelayedOnForegroundThread(v8::Isolate *isolate, v8::Task *task,
 714 |                                                double delay_in_seconds) {
 715 |         this->_platform_functions.CallDelayedOnForegroundThread(isolate, task, delay_in_seconds);
 716 |     }
 717 | 
 718 |     virtual void CallIdleOnForegroundThread(v8::Isolate *isolate, v8::IdleTask *task) {
 719 |         this->_platform_functions.CallIdleOnForegroundThread(isolate, task);
 720 |     }
 721 | 
 722 |     virtual bool IdleTasksEnabled(v8::Isolate *isolate) {
 723 |         return this->_platform_functions.IdleTasksEnabled(isolate);
 724 |     }
 725 | 
 726 |     virtual double MonotonicallyIncreasingTime() {
 727 |         return this->_platform_functions.MonotonicallyIncreasingTime();
 728 |     }
 729 | 
 730 | private:
 731 |     v8_PlatformFunctions _platform_functions;
 732 | };
 733 | 
 734 | class GlueAllocator : public v8::ArrayBuffer::Allocator {
 735 | public:
 736 |     GlueAllocator(v8_AllocatorFunctions allocator_functions)
 737 |         : _allocator_functions(allocator_functions)
 738 |     {}
 739 | 
 740 |     virtual void* Allocate(size_t length) {
 741 |         return this->_allocator_functions.Allocate(length);
 742 |     }
 743 | 
 744 |     virtual void* AllocateUninitialized(size_t length) {
 745 |         return this->_allocator_functions.AllocateUninitialized(length);
 746 |     }
 747 | 
 748 |     virtual void Free(void* data, size_t length) {
 749 |         this->_allocator_functions.Free(data, length);
 750 |     }
 751 | 
 752 | private:
 753 |     v8_AllocatorFunctions _allocator_functions;
 754 | };
 755 | 
 756 | PlatformPtr v8_Platform_Create(struct v8_PlatformFunctions platform_functions) {
 757 |     return new GluePlatform(platform_functions);
 758 | }
 759 | 
 760 | void v8_Platform_Destroy(PlatformPtr platform) {
 761 |     delete platform;
 762 | }
 763 | 
 764 | void v8_Task_Destroy(TaskPtr task) {
 765 |     delete task;
 766 | }
 767 | 
 768 | void v8_IdleTask_Destroy(IdleTaskPtr idle_task) {
 769 |     delete idle_task;
 770 | }
 771 | 
 772 | void v8_V8_InitializePlatform(PlatformPtr platform) {
 773 |     return v8::V8::InitializePlatform(platform);
 774 | }
 775 | 
 776 | void v8_V8_InitializeICU() {
 777 |     v8::V8::InitializeICU();
 778 | }
 779 | 
 780 | void v8_V8_Initialize() {
 781 |     v8::V8::Initialize();
 782 | }
 783 | 
 784 | void v8_V8_Dispose() {
 785 |     v8::V8::Dispose();
 786 | }
 787 | 
 788 | void v8_V8_ShutdownPlatform() {
 789 |     v8::V8::ShutdownPlatform();
 790 | }
 791 | 
 792 | 
 793 | ArrayBuffer_AllocatorPtr v8_ArrayBuffer_Allocator_Create(struct v8_AllocatorFunctions allocator_functions) {
 794 |     return new GlueAllocator(allocator_functions);
 795 | 
 796 | }
 797 | void v8_ArrayBuffer_Allocator_Destroy(ArrayBuffer_AllocatorPtr allocator) {
 798 |     delete allocator;
 799 | }
 800 | 
 801 | IsolatePtr v8_Isolate_New(ArrayBuffer_AllocatorPtr allocator) {
 802 |     auto params = v8::Isolate::CreateParams();
 803 |     params.array_buffer_allocator = allocator;
 804 |     return v8::Isolate::New(params);
 805 | }
 806 | 
 807 | uint32_t v8_Isolate_GetNumberOfDataSlots(IsolatePtr self) {
 808 |     return self->GetNumberOfDataSlots();
 809 | }
 810 | 
 811 | void v8_Isolate_SetData(IsolatePtr self, uint32_t slot, void *data) {
 812 |     self->SetData(slot, data);
 813 | }
 814 | 
 815 | void *v8_Isolate_GetData(IsolatePtr self, uint32_t slot) {
 816 |     return self->GetData(slot);
 817 | }
 818 | 
 819 | ContextRef v8_Isolate_GetCurrentContext(IsolatePtr self) {
 820 |     return unwrap(self, self->GetCurrentContext());
 821 | }
 822 | 
 823 | ValueRef v8_Isolate_ThrowException(IsolatePtr self, ValueRef exception) {
 824 |   return unwrap(self, self->ThrowException(wrap(self, exception)));
 825 | }
 826 | 
 827 | void v8_Isolate_SetCaptureStackTraceForUncaughtExceptions_Overview(IsolatePtr self, bool capture, int frame_limit) {
 828 |     self->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit, v8::StackTrace::kOverview);
 829 | }
 830 | 
 831 | void v8_Isolate_SetCaptureStackTraceForUncaughtExceptions_Detailed(IsolatePtr self, bool capture, int frame_limit) {
 832 |     self->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit, v8::StackTrace::kDetailed);
 833 | }
 834 | 
 835 | void v8_Isolate_Dispose(IsolatePtr isolate) {
 836 |     isolate->Dispose();
 837 | }
 838 | 
 839 | void v8_Task_Run(TaskPtr task) {
 840 |     task->Run();
 841 | }
 842 | 
 843 | void v8_IdleTask_Run(IdleTaskPtr task, double deadline_in_seconds) {
 844 |     task->Run(deadline_in_seconds);
 845 | }
 846 | 
 847 | #include "v8-glue-generated.cc"
 848 | 
 849 | PrimitiveRef v8_Undefined(RustContext c) {
 850 |     v8::Isolate::Scope isolate_scope(c.isolate);
 851 |     v8::HandleScope scope(c.isolate);
 852 |     v8::TryCatch try_catch(c.isolate);
 853 |     auto result = v8::Undefined(c.isolate);
 854 |     handle_exception(c, try_catch);
 855 |     return unwrap(c.isolate, result);
 856 | }
 857 | 
 858 | PrimitiveRef v8_Null(RustContext c) {
 859 |     v8::Isolate::Scope isolate_scope(c.isolate);
 860 |     v8::HandleScope scope(c.isolate);
 861 |     v8::TryCatch try_catch(c.isolate);
 862 |     auto result = v8::Null(c.isolate);
 863 |     handle_exception(c, try_catch);
 864 |     return unwrap(c.isolate, result);
 865 | }
 866 | 
 867 | BooleanRef v8_True(RustContext c) {
 868 |     v8::Isolate::Scope isolate_scope(c.isolate);
 869 |     v8::HandleScope scope(c.isolate);
 870 |     v8::TryCatch try_catch(c.isolate);
 871 |     auto result = v8::True(c.isolate);
 872 |     handle_exception(c, try_catch);
 873 |     return unwrap(c.isolate, result);
 874 | }
 875 | 
 876 | BooleanRef v8_False(RustContext c) {
 877 |     v8::Isolate::Scope isolate_scope(c.isolate);
 878 |     v8::HandleScope scope(c.isolate);
 879 |     v8::TryCatch try_catch(c.isolate);
 880 |     auto result = v8::False(c.isolate);
 881 |     handle_exception(c, try_catch);
 882 |     return unwrap(c.isolate, result);
 883 | }
 884 | 
 885 | ContextRef v8_Context_New(RustContext c) {
 886 |     v8::Isolate::Scope isolate_scope(c.isolate);
 887 |     v8::HandleScope scope(c.isolate);
 888 |     v8::TryCatch try_catch(c.isolate);
 889 |     auto result = v8::Context::New(c.isolate);
 890 |     handle_exception(c, try_catch);
 891 |     return unwrap(c.isolate, result);
 892 | }
 893 | 
 894 | StringRef v8_String_NewFromUtf8_Normal(RustContext c, const char *data, int length) {
 895 |     v8::Isolate::Scope isolate_scope(c.isolate);
 896 |     v8::HandleScope scope(c.isolate);
 897 |     v8::TryCatch try_catch(c.isolate);
 898 |     auto result = v8::String::NewFromUtf8(c.isolate, data, v8::NewStringType::kNormal, length);
 899 |     handle_exception(c, try_catch);
 900 |     return unwrap(c.isolate, result);
 901 | }
 902 | 
 903 | StringRef v8_String_NewFromUtf8_Internalized(RustContext c, const char *data, int length) {
 904 |     v8::Isolate::Scope isolate_scope(c.isolate);
 905 |     v8::HandleScope scope(c.isolate);
 906 |     v8::TryCatch try_catch(c.isolate);
 907 |     auto result = v8::String::NewFromUtf8(c.isolate, data, v8::NewStringType::kInternalized, length);
 908 |     handle_exception(c, try_catch);
 909 |     return unwrap(c.isolate, result);
 910 | }
 911 | 
 912 | int v8_String_WriteUtf8(RustContext c, StringRef string, char *buffer, int length) {
 913 |     v8::Isolate::Scope isolate_scope(c.isolate);
 914 |     v8::HandleScope scope(c.isolate);
 915 |     v8::TryCatch try_catch(c.isolate);
 916 |     auto result = wrap(c.isolate, string)->WriteUtf8(buffer, length);
 917 |     handle_exception(c, try_catch);
 918 |     return result;
 919 | }
 920 | 
 921 | ScriptRef v8_Script_Compile(RustContext c, ContextRef context, StringRef source) {
 922 |     v8::Isolate::Scope isolate_scope(c.isolate);
 923 |     v8::HandleScope scope(c.isolate);
 924 |     v8::TryCatch try_catch(c.isolate);
 925 |     v8::Context::Scope context_scope(wrap(c.isolate, context));
 926 |     auto result = v8::Script::Compile(wrap(c.isolate, context), wrap(c.isolate, source));
 927 |     handle_exception(c, try_catch);
 928 |     return unwrap(c.isolate, result);
 929 | }
 930 | 
 931 | 
 932 | ScriptRef v8_Script_Compile_Origin(
 933 |     RustContext c,
 934 |     ContextRef context,
 935 |     StringRef source,
 936 |     ValueRef resource_name,
 937 |     IntegerRef resource_line_offset,
 938 |     IntegerRef resource_column_offset,
 939 |     BooleanRef resource_is_shared_cross_origin,
 940 |     IntegerRef script_id,
 941 |     BooleanRef resource_is_embedder_debug_script,
 942 |     ValueRef source_map_url,
 943 |     BooleanRef resource_is_opaque) {
 944 |     v8::Isolate::Scope isolate_scope(c.isolate);
 945 |     v8::HandleScope scope(c.isolate);
 946 |     v8::TryCatch try_catch(c.isolate);
 947 |     v8::Context::Scope context_scope(wrap(c.isolate, context));
 948 | 
 949 |     v8::ScriptOrigin origin(
 950 |         wrap(c.isolate, resource_name),
 951 |         wrap(c.isolate, resource_line_offset),
 952 |         wrap(c.isolate, resource_column_offset),
 953 |         wrap(c.isolate, resource_is_shared_cross_origin),
 954 |         wrap(c.isolate, script_id),
 955 |         #if V8_MAJOR_VERSION < 5 || (V8_MAJOR_VERSION == 5 && V8_MINOR_VERSION < 7)
 956 |             wrap(c.isolate, resource_is_embedder_debug_script),
 957 |         #endif
 958 |         wrap(c.isolate, source_map_url),
 959 |         wrap(c.isolate, resource_is_opaque));
 960 | 
 961 |     auto result = v8::Script::Compile(
 962 |         wrap(c.isolate, context),
 963 |         wrap(c.isolate, source),
 964 |         &origin);
 965 | 
 966 |     handle_exception(c, try_catch);
 967 |     return unwrap(c.isolate, result);
 968 | }
 969 | 
 970 | ValueRef v8_Object_CallAsFunction(RustContext c, ObjectRef self, ContextRef context, ValueRef recv, int argc, ValueRef argv[]) {
 971 |     v8::Isolate::Scope isolate_scope(c.isolate);
 972 |     v8::HandleScope scope(c.isolate);
 973 |     v8::TryCatch try_catch(c.isolate);
 974 |     v8::Context::Scope context_scope(wrap(c.isolate, context));
 975 |     v8::Local<v8::Value> *argv_wrapped = static_cast<v8::Local<v8::Value>*>(alloca(sizeof(v8::Local<v8::Value>) * argc));
 976 |     v8::Local<v8::Value> recv_wrapped;
 977 | 
 978 |     for (int i = 0; i < argc; i++) {
 979 |         argv_wrapped[i] = wrap(c.isolate, argv[i]);
 980 |     }
 981 | 
 982 |     if (recv == nullptr) {
 983 |         recv_wrapped = v8::Undefined(c.isolate);
 984 |     } else {
 985 |         recv_wrapped = wrap(c.isolate, recv);
 986 |     }
 987 | 
 988 |     auto result = wrap(c.isolate, self)->CallAsFunction(wrap(c.isolate, context), recv_wrapped, argc, argv_wrapped);
 989 |     handle_exception(c, try_catch);
 990 |     return unwrap(c.isolate, result);
 991 | }
 992 | 
 993 | ValueRef v8_Object_CallAsConstructor(RustContext c, ObjectRef self, ContextRef context, int argc, ValueRef argv[]) {
 994 |     v8::Isolate::Scope isolate_scope(c.isolate);
 995 |     v8::HandleScope scope(c.isolate);
 996 |     v8::TryCatch try_catch(c.isolate);
 997 |     v8::Context::Scope context_scope(wrap(c.isolate, context));
 998 |     v8::Local<v8::Value> *argv_wrapped = static_cast<v8::Local<v8::Value>*>(alloca(sizeof(v8::Local<v8::Value>) * argc));
 999 | 
1000 |     for (int i = 0; i < argc; i++) {
1001 |         argv_wrapped[i] = wrap(c.isolate, argv[i]);
1002 |     }
1003 | 
1004 |     auto result = wrap(c.isolate, self)->CallAsConstructor(wrap(c.isolate, context), argc, argv_wrapped);
1005 |     handle_exception(c, try_catch);
1006 |     return unwrap(c.isolate, result);
1007 | }
1008 | 
1009 | enum class FunctionHandlerFields {
1010 |     Callback, Data, Max
1011 | };
1012 | 
1013 | 
1014 | void function_callback(const v8::FunctionCallbackInfo<v8::Value> &info) {
1015 |     v8::Isolate *isolate = info.GetIsolate();
1016 |     v8::Isolate::Scope isolate_scope(isolate);
1017 |     v8::HandleScope scope(isolate);
1018 |     v8::Local<v8::Object> outer_data =
1019 |         v8::Local<v8::Object>::Cast(info.Data());
1020 | 
1021 |     FunctionCallback callback =
1022 |         (FunctionCallback)
1023 |         outer_data->GetAlignedPointerFromInternalField((int) FunctionHandlerFields::Callback);
1024 |     v8::Local<v8::Value> data = outer_data->GetInternalField((int) FunctionHandlerFields::Data);
1025 |     FunctionCallbackInfo callback_info = build_callback_info(info, data);
1026 | 
1027 |     callback(&callback_info);
1028 | 
1029 |     delete[] callback_info.Args;
1030 | 
1031 |     if (callback_info.ThrownValue) {
1032 |         isolate->ThrowException(wrap(isolate, callback_info.ThrownValue));
1033 |     } else if (callback_info.ReturnValue) {
1034 |         info.GetReturnValue().Set(wrap(isolate, callback_info.ReturnValue));
1035 |     }
1036 | }
1037 | 
1038 | FunctionRef v8_Function_New(
1039 |     RustContext c,
1040 |     ContextRef context,
1041 |     FunctionCallback wrapped_callback,
1042 |     ValueRef data,
1043 |     int length,
1044 |     ConstructorBehavior behavior) {
1045 |     v8::Isolate::Scope isolate_scope(c.isolate);
1046 |     v8::HandleScope scope(c.isolate);
1047 |     v8::TryCatch try_catch(c.isolate);
1048 |     v8::Local<v8::ObjectTemplate> outer_data_template =
1049 |         v8::ObjectTemplate::New(c.isolate);
1050 |     outer_data_template->SetInternalFieldCount((int) FunctionHandlerFields::Max);
1051 |     v8::Local<v8::Object> outer_data =
1052 |         outer_data_template->NewInstance(wrap(c.isolate, context)).ToLocalChecked();
1053 | 
1054 |     v8::FunctionCallback callback;
1055 | 
1056 |     if (wrapped_callback) {
1057 |         outer_data->SetAlignedPointerInInternalField((int) FunctionHandlerFields::Callback, (void *) wrapped_callback);
1058 |         callback = function_callback;
1059 |     } else {
1060 |         callback = nullptr;
1061 |     }
1062 | 
1063 |     outer_data->SetInternalField((int) FunctionHandlerFields::Data, wrap(c.isolate, data));
1064 | 
1065 |     auto result = v8::Function::New(wrap(c.isolate, context), callback, outer_data, length, wrap(c.isolate, behavior));
1066 | 
1067 |     handle_exception(c, try_catch);
1068 |     return unwrap(c.isolate, result);
1069 | }
1070 | 
1071 | ObjectRef v8_Function_NewInstance(
1072 |     RustContext c,
1073 |     FunctionRef self,
1074 |     ContextRef context,
1075 |     int argc,
1076 |     ValueRef argv[]) {
1077 |     v8::Isolate::Scope isolate_scope(c.isolate);
1078 |     v8::HandleScope scope(c.isolate);
1079 |     v8::TryCatch try_catch(c.isolate);
1080 |     v8::Context::Scope context_scope(wrap(c.isolate, context));
1081 | 
1082 |     v8::Local<v8::Value> *argv_wrapped = static_cast<v8::Local<v8::Value>*>(alloca(sizeof(v8::Local<v8::Value>) * argc));
1083 | 
1084 |     for (int i = 0; i < argc; i++) {
1085 |         argv_wrapped[i] = wrap(c.isolate, argv[i]);
1086 |     }
1087 | 
1088 |     auto result = wrap(c.isolate, self)->NewInstance(wrap(c.isolate, context), argc, argv_wrapped);
1089 | 
1090 |     handle_exception(c, try_catch);
1091 |     return unwrap(c.isolate, result);
1092 | }
1093 | 
1094 | ValueRef v8_Function_Call(
1095 |     RustContext c,
1096 |     FunctionRef self,
1097 |     ContextRef context,
1098 |     ValueRef recv,
1099 |     int argc,
1100 |     ValueRef argv[]) {
1101 |     v8::Isolate::Scope isolate_scope(c.isolate);
1102 |     v8::HandleScope scope(c.isolate);
1103 |     v8::TryCatch try_catch(c.isolate);
1104 |     v8::Context::Scope context_scope(wrap(c.isolate, context));
1105 | 
1106 |     v8::Local<v8::Value> *argv_wrapped = static_cast<v8::Local<v8::Value>*>(alloca(sizeof(v8::Local<v8::Value>) * argc));
1107 |     v8::Local<v8::Value> recv_wrapped;
1108 | 
1109 |     for (int i = 0; i < argc; i++) {
1110 |         argv_wrapped[i] = wrap(c.isolate, argv[i]);
1111 |     }
1112 | 
1113 |     if (recv == nullptr) {
1114 |         recv_wrapped = v8::Undefined(c.isolate);
1115 |     } else {
1116 |         recv_wrapped = wrap(c.isolate, recv);
1117 |     }
1118 | 
1119 |     auto result = wrap(c.isolate, self)->Call(wrap(c.isolate, context), recv_wrapped, argc, argv_wrapped);
1120 | 
1121 |     handle_exception(c, try_catch);
1122 |     return unwrap(c.isolate, result);
1123 | }
1124 | 
1125 | void v8_Template_SetNativeDataProperty(
1126 |     RustContext c,
1127 |     TemplateRef self,
1128 |     StringRef name,
1129 |     AccessorGetterCallback getter,
1130 |     AccessorSetterCallback setter,
1131 |     ValueRef data,
1132 |     PropertyAttribute attribute,
1133 |     AccessorSignatureRef signature,
1134 |     AccessControl settings) {
1135 |     v8::Isolate::Scope isolate_scope(c.isolate);
1136 |     v8::HandleScope scope(c.isolate);
1137 |     v8::TryCatch try_catch(c.isolate);
1138 | 
1139 |     handle_exception(c, try_catch);
1140 | }
1141 | 
1142 | FunctionTemplateRef v8_FunctionTemplate_New(
1143 |     RustContext c,
1144 |     ContextRef context,
1145 |     FunctionCallback wrapped_callback,
1146 |     ValueRef data,
1147 |     SignatureRef signature,
1148 |     int length,
1149 |     ConstructorBehavior behavior) {
1150 |     v8::Isolate::Scope isolate_scope(c.isolate);
1151 |     v8::HandleScope scope(c.isolate);
1152 |     v8::TryCatch try_catch(c.isolate);
1153 |     v8::Local<v8::ObjectTemplate> outer_data_template =
1154 |         v8::ObjectTemplate::New(c.isolate);
1155 |     outer_data_template->SetInternalFieldCount((int) FunctionHandlerFields::Max);
1156 |     v8::Local<v8::Object> outer_data =
1157 |         outer_data_template->NewInstance(wrap(c.isolate, context)).ToLocalChecked();
1158 | 
1159 |     v8::FunctionCallback callback;
1160 | 
1161 |     if (wrapped_callback) {
1162 |         outer_data->SetAlignedPointerInInternalField((int) FunctionHandlerFields::Callback, (void *) wrapped_callback);
1163 |         callback = function_callback;
1164 |     }
1165 | 
1166 |     outer_data->SetInternalField((int) FunctionHandlerFields::Data, wrap(c.isolate, data));
1167 | 
1168 |     auto result = v8::FunctionTemplate::New(c.isolate, callback, outer_data, wrap(c.isolate, signature), length, wrap(c.isolate, behavior));
1169 | 
1170 |     handle_exception(c, try_catch);
1171 |     return unwrap(c.isolate, result);
1172 | }
1173 | 
1174 | void v8_ObjectTemplate_SetAccessor(
1175 |     RustContext c,
1176 |     ObjectTemplateRef self,
1177 |     StringRef name,
1178 |     AccessorGetterCallback getter,
1179 |     AccessorSetterCallback setter,
1180 |     ValueRef data,
1181 |     AccessControl settings,
1182 |     PropertyAttribute attribute,
1183 |     AccessorSignatureRef signature) {
1184 |     v8::Isolate::Scope isolate_scope(c.isolate);
1185 |     v8::HandleScope scope(c.isolate);
1186 |     v8::TryCatch try_catch(c.isolate);
1187 | 
1188 |     handle_exception(c, try_catch);
1189 | }
1190 | 
1191 | void v8_ObjectTemplate_SetAccessor_Name(
1192 |     RustContext c,
1193 |     ObjectTemplateRef self,
1194 |     StringRef name,
1195 |     AccessorNameGetterCallback getter,
1196 |     AccessorNameSetterCallback setter,
1197 |     ValueRef data,
1198 |     AccessControl settings,
1199 |     PropertyAttribute attribute,
1200 |     AccessorSignatureRef signature) {
1201 |     v8::Isolate::Scope isolate_scope(c.isolate);
1202 |     v8::HandleScope scope(c.isolate);
1203 |     v8::TryCatch try_catch(c.isolate);
1204 | 
1205 |     handle_exception(c, try_catch);
1206 | }
1207 | 
1208 | void v8_ObjectTemplate_SetCallAsFunctionHandler(
1209 |     RustContext c,
1210 |     ObjectTemplateRef self,
1211 |     FunctionCallback callback,
1212 |     ValueRef data) {
1213 |     v8::Isolate::Scope isolate_scope(c.isolate);
1214 |     v8::HandleScope scope(c.isolate);
1215 |     v8::TryCatch try_catch(c.isolate);
1216 | 
1217 |     handle_exception(c, try_catch);
1218 | }
1219 | 
1220 | void v8_ObjectTemplate_SetAccessCheckCallback(
1221 |     RustContext c,
1222 |     ObjectTemplateRef self,
1223 |     AccessCheckCallback callback,
1224 |     ValueRef data) {
1225 |     v8::Isolate::Scope isolate_scope(c.isolate);
1226 |     v8::HandleScope scope(c.isolate);
1227 |     v8::TryCatch try_catch(c.isolate);
1228 | 
1229 |     handle_exception(c, try_catch);
1230 | }
1231 | 


--------------------------------------------------------------------------------