mirrors/phpv8
mirrors/phpv8
0
0
Fork 0
mirror of https://github.com/phpv8/v8js.git synced 2024-11-09 15:18:41 +00:00
Code Releases Activity

Merge pull request #132 from stesie/code-cleanup

Browse Source 
Code cleanup
This commit is contained in:
Patrick Reilly 2015-01-03 15:45:22 -08:00
commit bb95374985
22 changed files with 2822 additions and 2417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
config.m4
View File

@ -1,5 +1,3 @@
dnl $Id$
PHP_ARG_WITH(v8js, for V8 Javascript Engine,
[ --with-v8js Include V8 JavaScript Engine])
@ -123,7 +121,20 @@ AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <v8-debug.h>]],
CPPFLAGS=$old_CPPFLAGS
]);
PHP_NEW_EXTENSION(v8js, v8js.cc v8js_array_access.cc v8js_convert.cc v8js_methods.cc v8js_object_export.cc v8js_variables.cc v8js_commonjs.cc, $ext_shared, , "-std="$ac_cv_v8_cstd)
PHP_NEW_EXTENSION(v8js, [ \
v8js_array_access.cc \
v8js.cc \
v8js_class.cc \
v8js_commonjs.cc \
v8js_convert.cc \
v8js_exceptions.cc \
v8js_methods.cc \
v8js_object_export.cc \
v8js_timer.cc \
v8js_v8.cc \
v8js_v8object_class.cc \
v8js_variables.cc \
], $ext_shared, , "-std="$ac_cv_v8_cstd)
PHP_ADD_MAKEFILE_FRAGMENT
fi

2
config.w32
View File

@ -13,7 +13,7 @@ if (PHP_V8JS != "no") {
AC_DEFINE("PHP_V8_API_VERSION", "3017015", "", false);
AC_DEFINE("PHP_V8_VERSION", "3.17.15", "", true);
EXTENSION("v8js", "v8js.cc v8js_array_access.cc v8js_commonjs.cc v8js_convert.cc v8js_methods.cc v8js_object_export.cc v8js_variables.cc", "yes");
EXTENSION("v8js", "v8js_array_access.cc v8js.cc v8js_class.cc v8js_commonjs.cc v8js_convert.cc v8js_exceptions.cc v8js_methods.cc v8js_object_export.cc v8js_timer.cc v8js_v8.cc v8js_v8object_class.cc v8js_variables.cc", "yes");
} else {
WARNING("v8js not enabled, headers or libs not found");

126
php_v8js_macros.h
View File

@ -11,8 +11,6 @@
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifndef PHP_V8JS_MACROS_H
#define PHP_V8JS_MACROS_H
@ -42,6 +40,10 @@ extern "C" {
#include <vector>
#include <mutex>
#include "v8js_class.h"
#include "v8js_v8.h"
#include "v8js_timer.h"
#ifndef PATH_MAX
/* Some platforms (Windows among others) don't have a PATH_MAX, for the moment
* just assume an arbitrary upper bound of 4096 chars.
@ -53,27 +55,6 @@ extern "C" {
/* V8Js Version */
#define V8JS_VERSION "0.1.5"
/* Helper macros */
#define V8JS_SYM(v) v8::String::NewFromUtf8(isolate, v, v8::String::kInternalizedString, sizeof(v) - 1)
#define V8JS_SYML(v, l) v8::String::NewFromUtf8(isolate, v, v8::String::kInternalizedString, l)
#define V8JS_STR(v) v8::String::NewFromUtf8(isolate, v)
#define V8JS_STRL(v, l) v8::String::NewFromUtf8(isolate, v, v8::String::kNormalString, l)
#define V8JS_INT(v) v8::Integer::New(isolate, v)
#define V8JS_UINT(v) v8::Integer::NewFromUnsigned(isolate, v)
#define V8JS_FLOAT(v) v8::Number::New(isolate, v)
#define V8JS_BOOL(v) ((v)?v8::True(isolate):v8::False(isolate))
#define V8JS_DATE(v) v8::Date::New(isolate, v)
#define V8JS_NULL v8::Null(isolate)
#define V8JS_UNDEFINED v8::Undefined(isolate)
#define V8JS_MN(name) v8js_method_##name
#define V8JS_METHOD(name) void V8JS_MN(name)(const v8::FunctionCallbackInfo<v8::Value>& info)
#define V8JS_THROW(isolate, type, message, message_len) (isolate)->ThrowException(v8::Exception::type(V8JS_STRL(message, message_len)))
#define V8JS_GLOBAL(isolate) ((isolate)->GetCurrentContext()->Global())
/* Abbreviate long type names */
typedef v8::Persistent<v8::FunctionTemplate, v8::CopyablePersistentTraits<v8::FunctionTemplate> > v8js_tmpl_t;
typedef v8::Persistent<v8::Object, v8::CopyablePersistentTraits<v8::Object> > v8js_persistent_obj_t;
/* Hidden field name used to link JS wrappers with underlying PHP object */
#define PHPJS_OBJECT_KEY "phpjs::object"
@ -111,104 +92,23 @@ typedef v8::Persistent<v8::Object, v8::CopyablePersistentTraits<v8::Object> > v8
#define V8JS_DEBUG_AUTO_BREAK_ONCE 1
#define V8JS_DEBUG_AUTO_BREAK_ALWAYS 2
/* Extracts a C string from a V8 Utf8Value. */
static inline const char * ToCString(const v8::String::Utf8Value &value) /* {{{ */
{
return *value ? *value : "<string conversion failed>";
}
/* }}} */
/* Extern Class entries */
extern zend_class_entry *php_ce_v8_object;
extern zend_class_entry *php_ce_v8_function;
/* Create PHP V8 object */
void php_v8js_create_v8(zval *, v8::Handle<v8::Value>, int, v8::Isolate * TSRMLS_DC);
/* Fetch V8 object properties */
int php_v8js_v8_get_properties_hash(v8::Handle<v8::Value>, HashTable *, int, v8::Isolate * TSRMLS_DC);
/* Convert zval into V8 value */
v8::Handle<v8::Value> zval_to_v8js(zval *, v8::Isolate * TSRMLS_DC);
/* Convert V8 value into zval */
int v8js_to_zval(v8::Handle<v8::Value>, zval *, int, v8::Isolate * TSRMLS_DC);
struct php_v8js_accessor_ctx
struct v8js_accessor_ctx
{
char *variable_name_string;
uint variable_name_string_len;
v8::Isolate *isolate;
};
void php_v8js_accessor_ctx_dtor(php_v8js_accessor_ctx * TSRMLS_DC);
void v8js_accessor_ctx_dtor(v8js_accessor_ctx * TSRMLS_DC);
/* Register accessors into passed object */
void php_v8js_register_accessors(std::vector<php_v8js_accessor_ctx*> *accessor_list, v8::Local<v8::FunctionTemplate>, zval *, v8::Isolate * TSRMLS_DC);
struct php_v8js_object;
/* {{{ Context container */
struct php_v8js_ctx {
zend_object std;
v8::Persistent<v8::String> object_name;
v8::Persistent<v8::Context> context;
zend_bool report_uncaught;
zval *pending_exception;
int in_execution;
v8::Isolate *isolate;
long time_limit;
bool time_limit_hit;
long memory_limit;
bool memory_limit_hit;
v8::Persistent<v8::FunctionTemplate> global_template;
zval *module_loader;
std::vector<char *> modules_stack;
std::vector<char *> modules_base;
std::map<char *, v8js_persistent_obj_t> modules_loaded;
std::map<const char *,v8js_tmpl_t> template_cache;
std::map<zval *, v8js_persistent_obj_t> weak_objects;
std::map<v8js_tmpl_t *, v8js_persistent_obj_t> weak_closures;
std::list<php_v8js_object *> php_v8js_objects;
std::vector<php_v8js_accessor_ctx *> accessor_list;
char *tz;
#ifdef ZTS
void ***zts_ctx;
#endif
};
/* }}} */
#ifdef ZTS
# define V8JS_TSRMLS_FETCH() TSRMLS_FETCH_FROM_CTX(((php_v8js_ctx *) isolate->GetData(0))->zts_ctx);
#else
# define V8JS_TSRMLS_FETCH()
#endif
// Timer context
struct php_v8js_timer_ctx
{
long time_limit;
long memory_limit;
std::chrono::time_point<std::chrono::high_resolution_clock> time_point;
php_v8js_ctx *v8js_ctx;
bool killed;
};
/* {{{ Object container */
struct php_v8js_object {
zend_object std;
v8::Persistent<v8::Value> v8obj;
int flags;
struct php_v8js_ctx *ctx;
HashTable *properties;
};
/* }}} */
void v8js_register_accessors(std::vector<v8js_accessor_ctx*> *accessor_list, v8::Local<v8::FunctionTemplate>, zval *, v8::Isolate * TSRMLS_DC);
/* Resource declaration */
@ -223,7 +123,7 @@ ZEND_BEGIN_MODULE_GLOBALS(v8js)
bool use_array_access; /* Convert ArrayAccess, Countable objects to array-like objects */
// Timer thread globals
std::deque<php_v8js_timer_ctx *> timer_stack;
std::deque<v8js_timer_ctx *> timer_stack;
std::thread *timer_thread;
std::mutex timer_mutex;
bool timer_stop;
@ -242,15 +142,7 @@ ZEND_EXTERN_MODULE_GLOBALS(v8js)
#endif
/* Register builtin methods into passed object */
void php_v8js_register_methods(v8::Handle<v8::ObjectTemplate>, php_v8js_ctx *c);
typedef struct _php_v8js_script {
char *name;
v8::Isolate *isolate;
v8::Persistent<v8::Script, v8::CopyablePersistentTraits<v8::Script>> *script;
} php_v8js_script;
static void php_v8js_script_free(php_v8js_script *res, bool dispose_persistent);
void v8js_register_methods(v8::Handle<v8::ObjectTemplate>, v8js_ctx *c);
#endif /* PHP_V8JS_MACROS_H */

2189
v8js.cc
View File

File diff suppressed because it is too large Load Diff

42
v8js_array_access.cc
View File

@ -27,7 +27,7 @@ extern "C" {
#include "v8js_object_export.h"
static zval *php_v8js_array_access_dispatch(zval *object, const char *method_name, int param_count,
static zval *v8js_array_access_dispatch(zval *object, const char *method_name, int param_count,
uint32_t index, zval *zvalue_ptr TSRMLS_DC) /* {{{ */
{
zend_class_entry *ce = Z_OBJCE_P(object);
@ -66,7 +66,7 @@ static zval *php_v8js_array_access_dispatch(zval *object, const char *method_nam
void php_v8js_array_access_getter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) /* {{{ */
void v8js_array_access_getter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -76,7 +76,7 @@ void php_v8js_array_access_getter(uint32_t index, const v8::PropertyCallbackInfo
v8::Local<v8::Value> php_object = self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY));
zval *object = reinterpret_cast<zval *>(v8::External::Cast(*php_object)->Value());
zval *php_value = php_v8js_array_access_dispatch(object, "offsetGet", 1, index, NULL TSRMLS_CC);
zval *php_value = v8js_array_access_dispatch(object, "offsetGet", 1, index, NULL TSRMLS_CC);
v8::Local<v8::Value> ret_value = zval_to_v8js(php_value, isolate TSRMLS_CC);
zval_ptr_dtor(&php_value);
@ -84,7 +84,7 @@ void php_v8js_array_access_getter(uint32_t index, const v8::PropertyCallbackInfo
}
/* }}} */
void php_v8js_array_access_setter(uint32_t index, v8::Local<v8::Value> value,
void v8js_array_access_setter(uint32_t index, v8::Local<v8::Value> value,
const v8::PropertyCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
@ -102,7 +102,7 @@ void php_v8js_array_access_setter(uint32_t index, v8::Local<v8::Value> value,
return;
}
zval *php_value = php_v8js_array_access_dispatch(object, "offsetSet", 2, index, zvalue_ptr TSRMLS_CC);
zval *php_value = v8js_array_access_dispatch(object, "offsetSet", 2, index, zvalue_ptr TSRMLS_CC);
zval_ptr_dtor(&php_value);
/* simply pass back the value to tell we intercepted the call
@ -116,9 +116,9 @@ void php_v8js_array_access_setter(uint32_t index, v8::Local<v8::Value> value,
/* }}} */
static int php_v8js_array_access_get_count_result(zval *object TSRMLS_DC) /* {{{ */
static int v8js_array_access_get_count_result(zval *object TSRMLS_DC) /* {{{ */
{
zval *php_value = php_v8js_array_access_dispatch(object, "count", 0, 0, NULL TSRMLS_CC);
zval *php_value = v8js_array_access_dispatch(object, "count", 0, 0, NULL TSRMLS_CC);
if(Z_TYPE_P(php_value) != IS_LONG) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Non-numeric return value from count() method");
@ -132,9 +132,9 @@ static int php_v8js_array_access_get_count_result(zval *object TSRMLS_DC) /* {{{
}
/* }}} */
static bool php_v8js_array_access_isset_p(zval *object, int index TSRMLS_DC) /* {{{ */
static bool v8js_array_access_isset_p(zval *object, int index TSRMLS_DC) /* {{{ */
{
zval *php_value = php_v8js_array_access_dispatch(object, "offsetExists", 1, index, NULL TSRMLS_CC);
zval *php_value = v8js_array_access_dispatch(object, "offsetExists", 1, index, NULL TSRMLS_CC);
if(Z_TYPE_P(php_value) != IS_BOOL) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Non-boolean return value from offsetExists() method");
@ -149,7 +149,7 @@ static bool php_v8js_array_access_isset_p(zval *object, int index TSRMLS_DC) /*
/* }}} */
static void php_v8js_array_access_length(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info) /* {{{ */
static void v8js_array_access_length(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -159,12 +159,12 @@ static void php_v8js_array_access_length(v8::Local<v8::String> property, const v
v8::Local<v8::Value> php_object = self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY));
zval *object = reinterpret_cast<zval *>(v8::External::Cast(*php_object)->Value());
int length = php_v8js_array_access_get_count_result(object TSRMLS_CC);
int length = v8js_array_access_get_count_result(object TSRMLS_CC);
info.GetReturnValue().Set(V8JS_INT(length));
}
/* }}} */
void php_v8js_array_access_deleter(uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean>& info) /* {{{ */
void v8js_array_access_deleter(uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -174,14 +174,14 @@ void php_v8js_array_access_deleter(uint32_t index, const v8::PropertyCallbackInf
v8::Local<v8::Value> php_object = self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY));
zval *object = reinterpret_cast<zval *>(v8::External::Cast(*php_object)->Value());
zval *php_value = php_v8js_array_access_dispatch(object, "offsetUnset", 1, index, NULL TSRMLS_CC);
zval *php_value = v8js_array_access_dispatch(object, "offsetUnset", 1, index, NULL TSRMLS_CC);
zval_ptr_dtor(&php_value);
info.GetReturnValue().Set(V8JS_BOOL(true));
}
/* }}} */
void php_v8js_array_access_query(uint32_t index, const v8::PropertyCallbackInfo<v8::Integer>& info) /* {{{ */
void v8js_array_access_query(uint32_t index, const v8::PropertyCallbackInfo<v8::Integer>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -193,14 +193,14 @@ void php_v8js_array_access_query(uint32_t index, const v8::PropertyCallbackInfo<
/* If index is set, then return an integer encoding a v8::PropertyAttribute;
* otherwise we're expected to return an empty handle. */
if(php_v8js_array_access_isset_p(object, index TSRMLS_CC)) {
if(v8js_array_access_isset_p(object, index TSRMLS_CC)) {
info.GetReturnValue().Set(V8JS_UINT(v8::PropertyAttribute::None));
}
}
/* }}} */
void php_v8js_array_access_enumerator(const v8::PropertyCallbackInfo<v8::Array>& info) /* {{{ */
void v8js_array_access_enumerator(const v8::PropertyCallbackInfo<v8::Array>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -210,13 +210,13 @@ void php_v8js_array_access_enumerator(const v8::PropertyCallbackInfo<v8::Array>&
v8::Local<v8::Value> php_object = self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY));
zval *object = reinterpret_cast<zval *>(v8::External::Cast(*php_object)->Value());
int length = php_v8js_array_access_get_count_result(object TSRMLS_CC);
int length = v8js_array_access_get_count_result(object TSRMLS_CC);
v8::Local<v8::Array> result = v8::Array::New(isolate, length);
int i = 0;
for(int j = 0; j < length; j ++) {
if(php_v8js_array_access_isset_p(object, j TSRMLS_CC)) {
if(v8js_array_access_isset_p(object, j TSRMLS_CC)) {
result->Set(i ++, V8JS_INT(j));
}
}
@ -228,17 +228,17 @@ void php_v8js_array_access_enumerator(const v8::PropertyCallbackInfo<v8::Array>&
void php_v8js_array_access_named_getter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
void v8js_array_access_named_getter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
{
v8::String::Utf8Value cstr(property);
const char *name = ToCString(cstr);
if(strcmp(name, "length") == 0) {
php_v8js_array_access_length(property, info);
v8js_array_access_length(property, info);
return;
}
v8::Local<v8::Value> ret_value = php_v8js_named_property_callback(property, info, V8JS_PROP_GETTER);
v8::Local<v8::Value> ret_value = v8js_named_property_callback(property, info, V8JS_PROP_GETTER);
if(ret_value.IsEmpty()) {
v8::Isolate *isolate = info.GetIsolate();

12
v8js_array_access.h
View File

@ -14,18 +14,18 @@
#define V8JS_ARRAY_ACCESS_H
/* Indexed Property Handlers */
void php_v8js_array_access_getter(uint32_t index,
void v8js_array_access_getter(uint32_t index,
const v8::PropertyCallbackInfo<v8::Value>& info);
void php_v8js_array_access_setter(uint32_t index, v8::Local<v8::Value> value,
void v8js_array_access_setter(uint32_t index, v8::Local<v8::Value> value,
const v8::PropertyCallbackInfo<v8::Value>& info);
void php_v8js_array_access_enumerator(const v8::PropertyCallbackInfo<v8::Array>& info);
void php_v8js_array_access_deleter(uint32_t index,
void v8js_array_access_enumerator(const v8::PropertyCallbackInfo<v8::Array>& info);
void v8js_array_access_deleter(uint32_t index,
const v8::PropertyCallbackInfo<v8::Boolean>& info);
void php_v8js_array_access_query(uint32_t index,
void v8js_array_access_query(uint32_t index,
const v8::PropertyCallbackInfo<v8::Integer>& info);
/* Named Property Handlers */
void php_v8js_array_access_named_getter(v8::Local<v8::String> property,
void v8js_array_access_named_getter(v8::Local<v8::String> property,
const v8::PropertyCallbackInfo<v8::Value> &info);
#endif /* V8JS_ARRAY_ACCESS_H */

1151
v8js_class.cc Normal file
View File

File diff suppressed because it is too large Load Diff

80
v8js_class.h Normal file
View File

@ -0,0 +1,80 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifndef V8JS_CLASS_H
#define V8JS_CLASS_H
/* Abbreviate long type names */
typedef v8::Persistent<v8::FunctionTemplate, v8::CopyablePersistentTraits<v8::FunctionTemplate> > v8js_tmpl_t;
typedef v8::Persistent<v8::Object, v8::CopyablePersistentTraits<v8::Object> > v8js_persistent_obj_t;
/* Forward declarations */
struct v8js_v8object;
struct v8js_accessor_ctx;
/* {{{ Context container */
struct v8js_ctx {
zend_object std;
v8::Persistent<v8::String> object_name;
v8::Persistent<v8::Context> context;
zend_bool report_uncaught;
zval *pending_exception;
int in_execution;
v8::Isolate *isolate;
long time_limit;
bool time_limit_hit;
long memory_limit;
bool memory_limit_hit;
v8::Persistent<v8::FunctionTemplate> global_template;
zval *module_loader;
std::vector<char *> modules_stack;
std::vector<char *> modules_base;
std::map<char *, v8js_persistent_obj_t> modules_loaded;
std::map<const char *,v8js_tmpl_t> template_cache;
std::map<zval *, v8js_persistent_obj_t> weak_objects;
std::map<v8js_tmpl_t *, v8js_persistent_obj_t> weak_closures;
std::list<v8js_v8object *> v8js_v8objects;
std::vector<v8js_accessor_ctx *> accessor_list;
char *tz;
#ifdef ZTS
void ***zts_ctx;
#endif
};
/* }}} */
#ifdef ZTS
# define V8JS_TSRMLS_FETCH() TSRMLS_FETCH_FROM_CTX(((v8js_ctx *) isolate->GetData(0))->zts_ctx);
#else
# define V8JS_TSRMLS_FETCH()
#endif
PHP_MINIT_FUNCTION(v8js_class);
#endif /* V8JS_CLASS_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

8
v8js_commonjs.cc
View File

@ -22,7 +22,7 @@ extern "C" {
#include "php_v8js_macros.h"
void php_v8js_commonjs_split_terms(char *identifier, std::vector<char *> &terms)
void v8js_commonjs_split_terms(char *identifier, std::vector<char *> &terms)
{
char *term = (char *)malloc(PATH_MAX), *ptr = term;
@ -58,14 +58,14 @@ void php_v8js_commonjs_split_terms(char *identifier, std::vector<char *> &terms)
}
}
void php_v8js_commonjs_normalise_identifier(char *base, char *identifier, char *normalised_path, char *module_name)
void v8js_commonjs_normalise_identifier(char *base, char *identifier, char *normalised_path, char *module_name)
{
std::vector<char *> id_terms, terms;
php_v8js_commonjs_split_terms(identifier, id_terms);
v8js_commonjs_split_terms(identifier, id_terms);
// If we have a relative module identifier then include the base terms
if (!strcmp(id_terms.front(), ".") || !strcmp(id_terms.front(), "..")) {
php_v8js_commonjs_split_terms(base, terms);
v8js_commonjs_split_terms(base, terms);
}
terms.insert(terms.end(), id_terms.begin(), id_terms.end());

22
v8js_convert.cc
View File

@ -11,8 +11,6 @@
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
@ -27,11 +25,13 @@ extern "C" {
#include "php_v8js_macros.h"
#include "v8js_object_export.h"
#include "v8js_v8object_class.h"
#include "v8js_v8.h"
#include <stdexcept>
#include <limits>
static int _php_v8js_is_assoc_array(HashTable *myht TSRMLS_DC) /* {{{ */
static int v8js_is_assoc_array(HashTable *myht TSRMLS_DC) /* {{{ */
{
int i;
char *key;
@ -54,14 +54,14 @@ static int _php_v8js_is_assoc_array(HashTable *myht TSRMLS_DC) /* {{{ */
/* }}} */
static v8::Handle<v8::Value> php_v8js_hash_to_jsarr(zval *value, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
static v8::Handle<v8::Value> v8js_hash_to_jsarr(zval *value, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
{
HashTable *myht = HASH_OF(value);
int i = myht ? zend_hash_num_elements(myht) : 0;
/* Return object if dealing with assoc array */
if (i > 0 && _php_v8js_is_assoc_array(myht TSRMLS_CC)) {
return php_v8js_hash_to_jsobj(value, isolate TSRMLS_CC);
if (i > 0 && v8js_is_assoc_array(myht TSRMLS_CC)) {
return v8js_hash_to_jsobj(value, isolate TSRMLS_CC);
}
v8::Local<v8::Array> newarr;
@ -110,7 +110,7 @@ v8::Handle<v8::Value> zval_to_v8js(zval *value, v8::Isolate *isolate TSRMLS_DC)
switch (Z_TYPE_P(value))
{
case IS_ARRAY:
jsValue = php_v8js_hash_to_jsarr(value, isolate TSRMLS_CC);
jsValue = v8js_hash_to_jsarr(value, isolate TSRMLS_CC);
break;
case IS_OBJECT:
@ -126,9 +126,9 @@ v8::Handle<v8::Value> zval_to_v8js(zval *value, v8::Isolate *isolate TSRMLS_DC)
else
jsValue = V8JS_NULL;
} else
jsValue = php_v8js_hash_to_jsobj(value, isolate TSRMLS_CC);
jsValue = v8js_hash_to_jsobj(value, isolate TSRMLS_CC);
} else
jsValue = php_v8js_hash_to_jsobj(value, isolate TSRMLS_CC);
jsValue = v8js_hash_to_jsobj(value, isolate TSRMLS_CC);
break;
case IS_STRING:
@ -246,9 +246,9 @@ int v8js_to_zval(v8::Handle<v8::Value> jsValue, zval *return_value, int flags, v
}
if ((flags & V8JS_FLAG_FORCE_ARRAY) || jsValue->IsArray()) {
array_init(return_value);
return php_v8js_v8_get_properties_hash(jsValue, Z_ARRVAL_P(return_value), flags, isolate TSRMLS_CC);
return v8js_get_properties_hash(jsValue, Z_ARRVAL_P(return_value), flags, isolate TSRMLS_CC);
} else {
php_v8js_create_v8(return_value, jsValue, flags, isolate TSRMLS_CC);
v8js_v8object_create(return_value, jsValue, flags, isolate TSRMLS_CC);
return SUCCESS;
}
}

244
v8js_exceptions.cc Normal file
View File

@ -0,0 +1,244 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
extern "C" {
#include "php.h"
#include "ext/date/php_date.h"
#include "ext/standard/php_string.h"
#include "zend_interfaces.h"
#include "zend_closures.h"
#include "ext/spl/spl_exceptions.h"
#include "zend_exceptions.h"
}
#include "php_v8js_macros.h"
/* {{{ Class Entries */
zend_class_entry *php_ce_v8js_exception;
zend_class_entry *php_ce_v8js_script_exception;
zend_class_entry *php_ce_v8js_time_limit_exception;
zend_class_entry *php_ce_v8js_memory_limit_exception;
/* }}} */
/* {{{ Class: V8JsScriptException */
void v8js_create_script_exception(zval *return_value, v8::TryCatch *try_catch TSRMLS_DC) /* {{{ */
{
v8::String::Utf8Value exception(try_catch->Exception());
const char *exception_string = ToCString(exception);
v8::Handle<v8::Message> tc_message = try_catch->Message();
const char *filename_string, *sourceline_string;
char *message_string;
int linenum, start_col, end_col, message_len;
object_init_ex(return_value, php_ce_v8js_script_exception);
#define PHPV8_EXPROP(type, name, value) \
zend_update_property##type(php_ce_v8js_script_exception, return_value, #name, sizeof(#name) - 1, value TSRMLS_CC);
if (tc_message.IsEmpty()) {
message_len = spprintf(&message_string, 0, "%s", exception_string);
}
else
{
v8::String::Utf8Value filename(tc_message->GetScriptResourceName());
filename_string = ToCString(filename);
PHPV8_EXPROP(_string, JsFileName, filename_string);
v8::String::Utf8Value sourceline(tc_message->GetSourceLine());
sourceline_string = ToCString(sourceline);
PHPV8_EXPROP(_string, JsSourceLine, sourceline_string);
linenum = tc_message->GetLineNumber();
PHPV8_EXPROP(_long, JsLineNumber, linenum);
start_col = tc_message->GetStartColumn();
PHPV8_EXPROP(_long, JsStartColumn, start_col);
end_col = tc_message->GetEndColumn();
PHPV8_EXPROP(_long, JsEndColumn, end_col);
message_len = spprintf(&message_string, 0, "%s:%d: %s", filename_string, linenum, exception_string);
v8::String::Utf8Value stacktrace(try_catch->StackTrace());
if (stacktrace.length() > 0) {
const char* stacktrace_string = ToCString(stacktrace);
PHPV8_EXPROP(_string, JsTrace, stacktrace_string);
}
}
PHPV8_EXPROP(_string, message, message_string);
efree(message_string);
}
/* }}} */
void v8js_throw_script_exception(v8::TryCatch *try_catch TSRMLS_DC) /* {{{ */
{
v8::String::Utf8Value exception(try_catch->Exception());
const char *exception_string = ToCString(exception);
zval *zexception = NULL;
if (try_catch->Message().IsEmpty()) {
zend_throw_exception(php_ce_v8js_script_exception, (char *) exception_string, 0 TSRMLS_CC);
} else {
MAKE_STD_ZVAL(zexception);
v8js_create_script_exception(zexception, try_catch TSRMLS_CC);
zend_throw_exception_object(zexception TSRMLS_CC);
}
}
/* }}} */
#define V8JS_EXCEPTION_METHOD(property) \
static PHP_METHOD(V8JsScriptException, get##property) \
{ \
zval *value; \
\
if (zend_parse_parameters_none() == FAILURE) { \
return; \
} \
value = zend_read_property(php_ce_v8js_script_exception, getThis(), #property, sizeof(#property) - 1, 0 TSRMLS_CC); \
*return_value = *value; \
zval_copy_ctor(return_value); \
INIT_PZVAL(return_value); \
}
/* {{{ proto string V8JsEScriptxception::getJsFileName()
*/
V8JS_EXCEPTION_METHOD(JsFileName);
/* }}} */
/* {{{ proto string V8JsScriptException::getJsLineNumber()
*/
V8JS_EXCEPTION_METHOD(JsLineNumber);
/* }}} */
/* {{{ proto string V8JsScriptException::getJsStartColumn()
*/
V8JS_EXCEPTION_METHOD(JsStartColumn);
/* }}} */
/* {{{ proto string V8JsScriptException::getJsEndColumn()
*/
V8JS_EXCEPTION_METHOD(JsEndColumn);
/* }}} */
/* {{{ proto string V8JsScriptException::getJsSourceLine()
*/
V8JS_EXCEPTION_METHOD(JsSourceLine);
/* }}} */
/* {{{ proto string V8JsScriptException::getJsTrace()
*/
V8JS_EXCEPTION_METHOD(JsTrace);
/* }}} */
ZEND_BEGIN_ARG_INFO(arginfo_v8jsscriptexception_no_args, 0)
ZEND_END_ARG_INFO()
static const zend_function_entry v8js_script_exception_methods[] = { /* {{{ */
PHP_ME(V8JsScriptException, getJsFileName, arginfo_v8jsscriptexception_no_args, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(V8JsScriptException, getJsLineNumber, arginfo_v8jsscriptexception_no_args, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(V8JsScriptException, getJsStartColumn, arginfo_v8jsscriptexception_no_args, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(V8JsScriptException, getJsEndColumn, arginfo_v8jsscriptexception_no_args, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(V8JsScriptException, getJsSourceLine, arginfo_v8jsscriptexception_no_args, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(V8JsScriptException, getJsTrace, arginfo_v8jsscriptexception_no_args, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
};
/* }}} */
/* }}} V8JsScriptException */
/* {{{ Class: V8JsException */
static const zend_function_entry v8js_exception_methods[] = { /* {{{ */
{NULL, NULL, NULL}
};
/* }}} */
/* }}} V8JsException */
/* {{{ Class: V8JsTimeLimitException */
static const zend_function_entry v8js_time_limit_exception_methods[] = { /* {{{ */
{NULL, NULL, NULL}
};
/* }}} */
/* }}} V8JsTimeLimitException */
/* {{{ Class: V8JsMemoryLimitException */
static const zend_function_entry v8js_memory_limit_exception_methods[] = { /* {{{ */
{NULL, NULL, NULL}
};
/* }}} */
/* }}} V8JsMemoryLimitException */
PHP_MINIT_FUNCTION(v8js_exceptions) /* {{{ */
{
zend_class_entry ce;
/* V8JsException Class */
INIT_CLASS_ENTRY(ce, "V8JsException", v8js_exception_methods);
php_ce_v8js_exception = zend_register_internal_class_ex(&ce, spl_ce_RuntimeException, NULL TSRMLS_CC);
/* V8JsScriptException Class */
INIT_CLASS_ENTRY(ce, "V8JsScriptException", v8js_script_exception_methods);
php_ce_v8js_script_exception = zend_register_internal_class_ex(&ce, php_ce_v8js_exception, NULL TSRMLS_CC);
php_ce_v8js_script_exception->ce_flags |= ZEND_ACC_FINAL;
/* Add custom JS specific properties */
zend_declare_property_null(php_ce_v8js_script_exception, ZEND_STRL("JsFileName"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(php_ce_v8js_script_exception, ZEND_STRL("JsLineNumber"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(php_ce_v8js_script_exception, ZEND_STRL("JsStartColumn"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(php_ce_v8js_script_exception, ZEND_STRL("JsEndColumn"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(php_ce_v8js_script_exception, ZEND_STRL("JsSourceLine"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(php_ce_v8js_script_exception, ZEND_STRL("JsTrace"), ZEND_ACC_PROTECTED TSRMLS_CC);
/* V8JsTimeLimitException Class */
INIT_CLASS_ENTRY(ce, "V8JsTimeLimitException", v8js_time_limit_exception_methods);
php_ce_v8js_time_limit_exception = zend_register_internal_class_ex(&ce, php_ce_v8js_exception, NULL TSRMLS_CC);
php_ce_v8js_time_limit_exception->ce_flags |= ZEND_ACC_FINAL;
/* V8JsMemoryLimitException Class */
INIT_CLASS_ENTRY(ce, "V8JsMemoryLimitException", v8js_memory_limit_exception_methods);
php_ce_v8js_memory_limit_exception = zend_register_internal_class_ex(&ce, php_ce_v8js_exception, NULL TSRMLS_CC);
php_ce_v8js_memory_limit_exception->ce_flags |= ZEND_ACC_FINAL;
} /* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

36
v8js_exceptions.h Normal file
View File

@ -0,0 +1,36 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifndef V8JS_EXCEPTIONS_H
#define V8JS_EXCEPTIONS_H
extern zend_class_entry *php_ce_v8js_exception;
extern zend_class_entry *php_ce_v8js_script_exception;
extern zend_class_entry *php_ce_v8js_time_limit_exception;
extern zend_class_entry *php_ce_v8js_memory_limit_exception;
void v8js_create_script_exception(zval *return_value, v8::TryCatch *try_catch TSRMLS_DC);
void v8js_throw_script_exception(v8::TryCatch *try_catch TSRMLS_DC);
PHP_MINIT_FUNCTION(v8js_exceptions);
#endif /* V8JS_EXCEPTIONS_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

18
v8js_methods.cc
View File

@ -11,8 +11,6 @@
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
@ -24,7 +22,7 @@ extern "C" {
}
/* Forward declarations */
void php_v8js_commonjs_normalise_identifier(char *base, char *identifier, char *normalised_path, char *module_name);
void v8js_commonjs_normalise_identifier(char *base, char *identifier, char *normalised_path, char *module_name);
/* global.exit - terminate execution */
V8JS_METHOD(exit) /* {{{ */
@ -56,7 +54,7 @@ V8JS_METHOD(print) /* {{{ */
}
/* }}} */
static void _php_v8js_dumper(v8::Isolate *isolate, v8::Local<v8::Value> var, int level TSRMLS_DC) /* {{{ */
static void v8js_dumper(v8::Isolate *isolate, v8::Local<v8::Value> var, int level TSRMLS_DC) /* {{{ */
{
if (level > 1) {
php_printf("%*c", (level - 1) * 2, ' ');
@ -126,7 +124,7 @@ static void _php_v8js_dumper(v8::Isolate *isolate, v8::Local<v8::Value> var, int
for (unsigned i = 0; i < length; i++) {
php_printf("%*c[%d] =>\n", level * 2, ' ', i);
_php_v8js_dumper(isolate, array->Get(i), level + 1 TSRMLS_CC);
v8js_dumper(isolate, array->Get(i), level + 1 TSRMLS_CC);
}
if (level > 1) {
@ -163,7 +161,7 @@ static void _php_v8js_dumper(v8::Isolate *isolate, v8::Local<v8::Value> var, int
v8::Local<v8::String> key = keys->Get(i)->ToString();
v8::String::Utf8Value kname(key);
php_printf("%*c[\"%s\"] =>\n", level * 2, ' ', ToCString(kname));
_php_v8js_dumper(isolate, object->Get(key), level + 1 TSRMLS_CC);
v8js_dumper(isolate, object->Get(key), level + 1 TSRMLS_CC);
}
}
@ -187,7 +185,7 @@ V8JS_METHOD(var_dump) /* {{{ */
V8JS_TSRMLS_FETCH();
for (int i = 0; i < info.Length(); i++) {
_php_v8js_dumper(isolate, info[i], 1 TSRMLS_CC);
v8js_dumper(isolate, info[i], 1 TSRMLS_CC);
}
info.GetReturnValue().Set(V8JS_NULL);
@ -201,7 +199,7 @@ V8JS_METHOD(require)
// Get the extension context
v8::Handle<v8::External> data = v8::Handle<v8::External>::Cast(info.Data());
php_v8js_ctx *c = static_cast<php_v8js_ctx*>(data->Value());
v8js_ctx *c = static_cast<v8js_ctx*>(data->Value());
// Check that we have a module loader
if (c->module_loader == NULL) {
@ -216,7 +214,7 @@ V8JS_METHOD(require)
char *normalised_path = (char *)emalloc(PATH_MAX);
char *module_name = (char *)emalloc(PATH_MAX);
php_v8js_commonjs_normalise_identifier(c->modules_base.back(), module_id, normalised_path, module_name);
v8js_commonjs_normalise_identifier(c->modules_base.back(), module_id, normalised_path, module_name);
efree(module_id);
char *normalised_module_id = (char *)emalloc(strlen(normalised_path)+1+strlen(module_name)+1);
@ -391,7 +389,7 @@ V8JS_METHOD(require)
efree(normalised_module_id);
}
void php_v8js_register_methods(v8::Handle<v8::ObjectTemplate> global, php_v8js_ctx *c) /* {{{ */
void v8js_register_methods(v8::Handle<v8::ObjectTemplate> global, v8js_ctx *c) /* {{{ */
{
v8::Isolate *isolate = c->isolate;
global->Set(V8JS_SYM("exit"), v8::FunctionTemplate::New(isolate, V8JS_MN(exit)), v8::ReadOnly);

111
v8js_object_export.cc
View File

@ -26,11 +26,12 @@ extern "C" {
#include "php_v8js_macros.h"
#include "v8js_array_access.h"
#include "v8js_object_export.h"
#include "v8js_v8object_class.h"
static void php_v8js_weak_object_callback(const v8::WeakCallbackData<v8::Object, zval> &data);
static void v8js_weak_object_callback(const v8::WeakCallbackData<v8::Object, zval> &data);
/* Callback for PHP methods and functions */
static void php_v8js_call_php_func(zval *value, zend_class_entry *ce, zend_function *method_ptr, v8::Isolate *isolate, const v8::FunctionCallbackInfo<v8::Value>& info TSRMLS_DC) /* {{{ */
static void v8js_call_php_func(zval *value, zend_class_entry *ce, zend_function *method_ptr, v8::Isolate *isolate, const v8::FunctionCallbackInfo<v8::Value>& info TSRMLS_DC) /* {{{ */
{
v8::Handle<v8::Value> return_value;
zend_fcall_info fci;
@ -40,7 +41,7 @@ static void php_v8js_call_php_func(zval *value, zend_class_entry *ce, zend_funct
char *error;
int error_len, i, flags = V8JS_FLAG_NONE;
php_v8js_ctx *ctx = (php_v8js_ctx *) isolate->GetData(0);
v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
/* Set parameter limits */
min_num_args = method_ptr->common.required_num_args;
@ -160,7 +161,7 @@ failure:
/* }}} */
/* Callback for PHP methods and functions */
static void php_v8js_php_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
static void v8js_php_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -177,11 +178,11 @@ static void php_v8js_php_callback(const v8::FunctionCallbackInfo<v8::Value>& inf
method_ptr = zend_get_closure_invoke_method(value TSRMLS_CC);
}
return php_v8js_call_php_func(value, ce, method_ptr, isolate, info TSRMLS_CC);
return v8js_call_php_func(value, ce, method_ptr, isolate, info TSRMLS_CC);
}
/* Callback for PHP constructor calls */
static void php_v8js_construct_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
static void v8js_construct_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
info.GetReturnValue().Set(V8JS_UNDEFINED);
@ -199,10 +200,10 @@ static void php_v8js_construct_callback(const v8::FunctionCallbackInfo<v8::Value
v8::Local<v8::External> ext_tmpl = v8::Local<v8::External>::Cast(cons_data->Get(0));
v8::Local<v8::External> ext_ce = v8::Local<v8::External>::Cast(cons_data->Get(1));
php_v8js_ctx *ctx = (php_v8js_ctx *) isolate->GetData(0);
v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
if (info[0]->IsExternal()) {
// Object created by v8js in php_v8js_hash_to_jsobj, PHP object passed as v8::External.
// Object created by v8js in v8js_hash_to_jsobj, PHP object passed as v8::External.
php_object = v8::Local<v8::External>::Cast(info[0]);
value = reinterpret_cast<zval *>(php_object->Value());
@ -234,7 +235,7 @@ static void php_v8js_construct_callback(const v8::FunctionCallbackInfo<v8::Value
// Call __construct function
if (ctor_ptr != NULL) {
php_v8js_call_php_func(value, ce, ctor_ptr, isolate, info TSRMLS_CC);
v8js_call_php_func(value, ce, ctor_ptr, isolate, info TSRMLS_CC);
}
php_object = v8::External::New(isolate, value);
}
@ -246,7 +247,7 @@ static void php_v8js_construct_callback(const v8::FunctionCallbackInfo<v8::Value
// decides to dispose the JS object, we add a weak persistent handle and register
// a callback function that removes the reference.
ctx->weak_objects[value].Reset(isolate, newobj);
ctx->weak_objects[value].SetWeak(value, php_v8js_weak_object_callback);
ctx->weak_objects[value].SetWeak(value, v8js_weak_object_callback);
// Just tell v8 that we're allocating some external memory
// (for the moment we just always tell 1k instead of trying to find out actual values)
@ -255,13 +256,13 @@ static void php_v8js_construct_callback(const v8::FunctionCallbackInfo<v8::Value
/* }}} */
static void php_v8js_weak_object_callback(const v8::WeakCallbackData<v8::Object, zval> &data) {
static void v8js_weak_object_callback(const v8::WeakCallbackData<v8::Object, zval> &data) {
v8::Isolate *isolate = data.GetIsolate();
zval *value = data.GetParameter();
zval_ptr_dtor(&value);
php_v8js_ctx *ctx = (php_v8js_ctx *) isolate->GetData(0);
v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
ctx->weak_objects.at(value).Reset();
ctx->weak_objects.erase(value);
@ -269,14 +270,14 @@ static void php_v8js_weak_object_callback(const v8::WeakCallbackData<v8::Object,
isolate->AdjustAmountOfExternalAllocatedMemory(-1024);
}
static void php_v8js_weak_closure_callback(const v8::WeakCallbackData<v8::Object, v8js_tmpl_t> &data) {
static void v8js_weak_closure_callback(const v8::WeakCallbackData<v8::Object, v8js_tmpl_t> &data) {
v8::Isolate *isolate = data.GetIsolate();
v8js_tmpl_t *persist_tpl_ = data.GetParameter();
persist_tpl_->Reset();
delete persist_tpl_;
php_v8js_ctx *ctx = (php_v8js_ctx *) isolate->GetData(0);
v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
ctx->weak_closures.at(persist_tpl_).Reset();
ctx->weak_closures.erase(persist_tpl_);
@ -292,10 +293,10 @@ static void php_v8js_weak_closure_callback(const v8::WeakCallbackData<v8::Object
!strncasecmp(key, mname, key_len - 1))
#define PHP_V8JS_CALLBACK(isolate, mptr, tmpl) \
v8::FunctionTemplate::New((isolate), php_v8js_php_callback, v8::External::New((isolate), mptr), v8::Signature::New((isolate), tmpl))->GetFunction()
v8::FunctionTemplate::New((isolate), v8js_php_callback, v8::External::New((isolate), mptr), v8::Signature::New((isolate), tmpl))->GetFunction()
static void php_v8js_named_property_enumerator(const v8::PropertyCallbackInfo<v8::Array> &info) /* {{{ */
static void v8js_named_property_enumerator(const v8::PropertyCallbackInfo<v8::Array> &info) /* {{{ */
{
// note: 'special' properties like 'constructor' are not enumerated.
v8::Isolate *isolate = info.GetIsolate();
@ -392,7 +393,7 @@ static void php_v8js_named_property_enumerator(const v8::PropertyCallbackInfo<v8
}
/* }}} */
static void php_v8js_invoke_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
static void v8js_invoke_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -409,7 +410,7 @@ static void php_v8js_invoke_callback(const v8::FunctionCallbackInfo<v8::Value>&
}
if (info.IsConstructCall()) {
php_v8js_ctx *ctx = (php_v8js_ctx *) isolate->GetData(0);
v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
v8::String::Utf8Value str(self->GetConstructorName()->ToString());
const char *constructor_name = ToCString(str);
@ -431,7 +432,7 @@ static void php_v8js_invoke_callback(const v8::FunctionCallbackInfo<v8::Value>&
// this is a magic '__call' implementation for PHP classes which don't actually
// have a '__call' magic function. This way we can always force a method
// call (as opposed to a property get) from JavaScript using __call.
static void php_v8js_fake_call_impl(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
static void v8js_fake_call_impl(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::Local<v8::Object> self = info.Holder();
@ -499,7 +500,7 @@ static void php_v8js_fake_call_impl(const v8::FunctionCallbackInfo<v8::Value>& i
v8::Local<v8::FunctionTemplate> tmpl =
v8::Local<v8::FunctionTemplate>::New
(isolate, *reinterpret_cast<v8js_tmpl_t *>(self->GetAlignedPointerFromInternalField(0)));
// use php_v8js_php_callback to actually execute the method
// use v8js_php_callback to actually execute the method
v8::Local<v8::Function> cb = PHP_V8JS_CALLBACK(isolate, method_ptr, tmpl);
uint32_t i, argc = args->Length();
v8::Local<v8::Value> *argv = static_cast<v8::Local<v8::Value> *>(alloca(sizeof(v8::Local<v8::Value>) * argc));
@ -514,7 +515,7 @@ static void php_v8js_fake_call_impl(const v8::FunctionCallbackInfo<v8::Value>& i
/* This method handles named property and method get/set/query/delete. */
template<typename T>
inline v8::Local<v8::Value> php_v8js_named_property_callback(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<T> &info, property_op_t callback_type, v8::Local<v8::Value> set_value) /* {{{ */
inline v8::Local<v8::Value> v8js_named_property_callback(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<T> &info, property_op_t callback_type, v8::Local<v8::Value> set_value) /* {{{ */
{
v8::Isolate *isolate = info.GetIsolate();
v8::String::Utf8Value cstr(property);
@ -569,7 +570,7 @@ inline v8::Local<v8::Value> php_v8js_named_property_callback(v8::Local<v8::Strin
// there is no actual PHP __call() implementation)
v8::Local<v8::Function> cb =
v8::FunctionTemplate::New(isolate,
php_v8js_fake_call_impl, V8JS_NULL,
v8js_fake_call_impl, V8JS_NULL,
v8::Signature::New(isolate, tmpl))->GetFunction();
cb->SetName(property);
ret_value = cb;
@ -734,30 +735,30 @@ inline v8::Local<v8::Value> php_v8js_named_property_callback(v8::Local<v8::Strin
}
/* }}} */
static void php_v8js_named_property_getter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
static void v8js_named_property_getter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
{
info.GetReturnValue().Set(php_v8js_named_property_callback(property, info, V8JS_PROP_GETTER));
info.GetReturnValue().Set(v8js_named_property_callback(property, info, V8JS_PROP_GETTER));
}
/* }}} */
static void php_v8js_named_property_setter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
static void v8js_named_property_setter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
{
info.GetReturnValue().Set(php_v8js_named_property_callback(property, info, V8JS_PROP_SETTER, value));
info.GetReturnValue().Set(v8js_named_property_callback(property, info, V8JS_PROP_SETTER, value));
}
/* }}} */
static void php_v8js_named_property_query(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Integer> &info) /* {{{ */
static void v8js_named_property_query(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Integer> &info) /* {{{ */
{
v8::Local<v8::Value> r = php_v8js_named_property_callback(property, info, V8JS_PROP_QUERY);
v8::Local<v8::Value> r = v8js_named_property_callback(property, info, V8JS_PROP_QUERY);
if (!r.IsEmpty()) {
info.GetReturnValue().Set(r->ToInteger());
}
}
/* }}} */
static void php_v8js_named_property_deleter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Boolean> &info) /* {{{ */
static void v8js_named_property_deleter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Boolean> &info) /* {{{ */
{
v8::Local<v8::Value> r = php_v8js_named_property_callback(property, info, V8JS_PROP_DELETER);
v8::Local<v8::Value> r = v8js_named_property_callback(property, info, V8JS_PROP_DELETER);
if (!r.IsEmpty()) {
info.GetReturnValue().Set(r->ToBoolean());
}
@ -766,9 +767,9 @@ static void php_v8js_named_property_deleter(v8::Local<v8::String> property, cons
static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_class_entry *ce, zval *value TSRMLS_DC) /* {{{ */
static v8::Handle<v8::Object> v8js_wrap_object(v8::Isolate *isolate, zend_class_entry *ce, zval *value TSRMLS_DC) /* {{{ */
{
php_v8js_ctx *ctx = (php_v8js_ctx *) isolate->GetData(0);
v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
v8::Local<v8::FunctionTemplate> new_tpl;
v8js_tmpl_t *persist_tpl_;
@ -786,8 +787,8 @@ static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_cl
if (ce == zend_ce_closure) {
/* Got a closure, mustn't cache ... */
persist_tpl_ = new v8js_tmpl_t(isolate, new_tpl);
/* We'll free persist_tpl_ via php_v8js_weak_closure_callback, below */
new_tpl->InstanceTemplate()->SetCallAsFunctionHandler(php_v8js_php_callback);
/* We'll free persist_tpl_ via v8js_weak_closure_callback, below */
new_tpl->InstanceTemplate()->SetCallAsFunctionHandler(v8js_php_callback);
} else {
/* Add new v8::FunctionTemplate to tpl_map, as long as it is not a closure. */
persist_tpl_ = &ctx->template_cache[ce->name];
@ -795,8 +796,8 @@ static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_cl
/* We'll free persist_tpl_ when template_cache is destroyed */
v8::Local<v8::ObjectTemplate> inst_tpl = new_tpl->InstanceTemplate();
v8::NamedPropertyGetterCallback getter = php_v8js_named_property_getter;
v8::NamedPropertyEnumeratorCallback enumerator = php_v8js_named_property_enumerator;
v8::NamedPropertyGetterCallback getter = v8js_named_property_getter;
v8::NamedPropertyEnumeratorCallback enumerator = v8js_named_property_enumerator;
/* Check for ArrayAccess object */
if (V8JSG(use_array_access) && ce) {
@ -813,16 +814,16 @@ static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_cl
}
if(has_array_access && has_countable) {
inst_tpl->SetIndexedPropertyHandler(php_v8js_array_access_getter,
php_v8js_array_access_setter,
php_v8js_array_access_query,
php_v8js_array_access_deleter,
php_v8js_array_access_enumerator);
inst_tpl->SetIndexedPropertyHandler(v8js_array_access_getter,
v8js_array_access_setter,
v8js_array_access_query,
v8js_array_access_deleter,
v8js_array_access_enumerator);
/* Switch to special ArrayAccess getter, which falls back to
* php_v8js_named_property_getter, but possibly bridges the
* v8js_named_property_getter, but possibly bridges the
* call to Array.prototype functions. */
getter = php_v8js_array_access_named_getter;
getter = v8js_array_access_named_getter;
/* Overwrite enumerator, since for(... in ...) loop should
* not see the methods but iterate over the elements. */
@ -834,9 +835,9 @@ static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_cl
// Finish setup of new_tpl
inst_tpl->SetNamedPropertyHandler
(getter, /* getter */
php_v8js_named_property_setter, /* setter */
php_v8js_named_property_query, /* query */
php_v8js_named_property_deleter, /* deleter */
v8js_named_property_setter, /* setter */
v8js_named_property_query, /* query */
v8js_named_property_deleter, /* deleter */
enumerator, /* enumerator */
V8JS_NULL /* data */
);
@ -846,13 +847,13 @@ static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_cl
sizeof(ZEND_INVOKE_FUNC_NAME),
(void**)&invoke_method_ptr) == SUCCESS &&
invoke_method_ptr->common.fn_flags & ZEND_ACC_PUBLIC) {
new_tpl->InstanceTemplate()->SetCallAsFunctionHandler(php_v8js_invoke_callback, PHP_V8JS_CALLBACK(isolate, invoke_method_ptr, new_tpl));
new_tpl->InstanceTemplate()->SetCallAsFunctionHandler(v8js_invoke_callback, PHP_V8JS_CALLBACK(isolate, invoke_method_ptr, new_tpl));
}
}
v8::Local<v8::Array> call_handler_data = v8::Array::New(isolate, 2);
call_handler_data->Set(0, v8::External::New(isolate, persist_tpl_));
call_handler_data->Set(1, v8::External::New(isolate, ce));
new_tpl->SetCallHandler(php_v8js_construct_callback, call_handler_data);
new_tpl->SetCallHandler(v8js_construct_callback, call_handler_data);
}
// Create v8 wrapper object
@ -862,7 +863,7 @@ static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_cl
if (ce == zend_ce_closure) {
// free uncached function template when object is freed
ctx->weak_closures[persist_tpl_].Reset(isolate, newobj);
ctx->weak_closures[persist_tpl_].SetWeak(persist_tpl_, php_v8js_weak_closure_callback);
ctx->weak_closures[persist_tpl_].SetWeak(persist_tpl_, v8js_weak_closure_callback);
}
return newobj;
@ -870,7 +871,7 @@ static v8::Handle<v8::Object> php_v8js_wrap_object(v8::Isolate *isolate, zend_cl
/* }}} */
static v8::Handle<v8::Object> php_v8js_wrap_array_to_object(v8::Isolate *isolate, zval *value TSRMLS_DC) /* {{{ */
static v8::Handle<v8::Object> v8js_wrap_array_to_object(v8::Isolate *isolate, zval *value TSRMLS_DC) /* {{{ */
{
int i;
HashPosition pos;
@ -935,7 +936,7 @@ static v8::Handle<v8::Object> php_v8js_wrap_array_to_object(v8::Isolate *isolate
/* }}} */
v8::Handle<v8::Value> php_v8js_hash_to_jsobj(zval *value, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
v8::Handle<v8::Value> v8js_hash_to_jsobj(zval *value, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
{
HashTable *myht;
zend_class_entry *ce = NULL;
@ -953,8 +954,8 @@ v8::Handle<v8::Value> php_v8js_hash_to_jsobj(zval *value, v8::Isolate *isolate T
}
/* Special case, passing back object originating from JS to JS */
if (ce == php_ce_v8_function) {
php_v8js_object *c = (php_v8js_object *) zend_object_store_get_object(value TSRMLS_CC);
if (ce == php_ce_v8function) {
v8js_v8object *c = (v8js_v8object *) zend_object_store_get_object(value TSRMLS_CC);
if(isolate != c->ctx->isolate) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "V8Function object passed to wrong V8Js instance");
@ -966,12 +967,12 @@ v8::Handle<v8::Value> php_v8js_hash_to_jsobj(zval *value, v8::Isolate *isolate T
/* If it's a PHP object, wrap it */
if (ce) {
return php_v8js_wrap_object(isolate, ce, value TSRMLS_CC);
return v8js_wrap_object(isolate, ce, value TSRMLS_CC);
}
/* Associative PHP arrays cannot be wrapped to JS arrays, convert them to
* JS objects and attach all their array keys as properties. */
return php_v8js_wrap_array_to_object(isolate, value TSRMLS_CC);
return v8js_wrap_array_to_object(isolate, value TSRMLS_CC);
}
/* }}} */

4
v8js_object_export.h
View File

@ -14,7 +14,7 @@
#ifndef V8JS_OBJECT_EXPORT_H
#define V8JS_OBJECT_EXPORT_H
v8::Handle<v8::Value> php_v8js_hash_to_jsobj(zval *value, v8::Isolate *isolate TSRMLS_DC);
v8::Handle<v8::Value> v8js_hash_to_jsobj(zval *value, v8::Isolate *isolate TSRMLS_DC);
typedef enum {
@ -25,7 +25,7 @@ typedef enum {
} property_op_t;
template<typename T>
v8::Local<v8::Value> php_v8js_named_property_callback(v8::Local<v8::String> property,
v8::Local<v8::Value> v8js_named_property_callback(v8::Local<v8::String> property,
const v8::PropertyCallbackInfo<T> &info,
property_op_t callback_type,
v8::Local<v8::Value> set_value = v8::Local<v8::Value>());

143
v8js_timer.cc Normal file
View File

@ -0,0 +1,143 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
extern "C" {
#include "php.h"
#include "ext/date/php_date.h"
#include "ext/standard/php_string.h"
#include "zend_interfaces.h"
#include "zend_closures.h"
#include "ext/spl/spl_exceptions.h"
#include "zend_exceptions.h"
}
#include "php_v8js_macros.h"
#include "v8js_v8.h"
#include "v8js_exceptions.h"
static void v8js_timer_interrupt_handler(v8::Isolate *isolate, void *data) { /* {{{ */
#ifdef ZTS
TSRMLS_D = (void ***) data;
#endif
if (!V8JSG(timer_stack).size()) {
return;
}
v8::Locker locker(isolate);
v8::HeapStatistics hs;
isolate->GetHeapStatistics(&hs);
V8JSG(timer_mutex).lock();
for (std::deque< v8js_timer_ctx* >::iterator it = V8JSG(timer_stack).begin();
it != V8JSG(timer_stack).end(); it ++) {
v8js_timer_ctx *timer_ctx = *it;
v8js_ctx *c = timer_ctx->ctx;
if(c->isolate != isolate || timer_ctx->killed) {
continue;
}
if (timer_ctx->memory_limit > 0 && hs.used_heap_size() > timer_ctx->memory_limit) {
timer_ctx->killed = true;
v8js_terminate_execution(c TSRMLS_CC);
c->memory_limit_hit = true;
}
}
V8JSG(timer_mutex).unlock();
}
/* }}} */
void v8js_timer_thread(TSRMLS_D) /* {{{ */
{
while (!V8JSG(timer_stop)) {
V8JSG(timer_mutex).lock();
if (V8JSG(timer_stack).size()) {
v8js_timer_ctx *timer_ctx = V8JSG(timer_stack).front();
v8js_ctx *c = timer_ctx->ctx;
std::chrono::time_point<std::chrono::high_resolution_clock> now = std::chrono::high_resolution_clock::now();
if(timer_ctx->killed) {
/* execution already terminated, nothing to check anymore,
* but wait for caller to pop this timer context. */
}
else if(timer_ctx->time_limit > 0 && now > timer_ctx->time_point) {
timer_ctx->killed = true;
v8js_terminate_execution(c TSRMLS_CC);
c->time_limit_hit = true;
}
else if (timer_ctx->memory_limit > 0) {
/* If a memory_limit is set, we need to interrupt execution
* and check heap size within the callback. We must *not*
* directly call GetHeapStatistics here, since we don't have
* a v8::Locker on the isolate, but are expected to hold one,
* and cannot aquire it as v8 is executing the script ... */
void *data = NULL;
#ifdef ZTS
data = (void *) TSRMLS_C;
#endif
c->isolate->RequestInterrupt(v8js_timer_interrupt_handler, data);
}
}
V8JSG(timer_mutex).unlock();
// Sleep for 10ms
#ifdef _WIN32
concurrency::wait(10);
#else
std::chrono::milliseconds duration(10);
std::this_thread::sleep_for(duration);
#endif
}
}
/* }}} */
void v8js_timer_push(long time_limit, long memory_limit, v8js_ctx *c TSRMLS_DC) /* {{{ */
{
V8JSG(timer_mutex).lock();
// Create context for this timer
v8js_timer_ctx *timer_ctx = (v8js_timer_ctx *)emalloc(sizeof(v8js_timer_ctx));
// Calculate the time point when the time limit is exceeded
std::chrono::milliseconds duration(time_limit);
std::chrono::time_point<std::chrono::high_resolution_clock> from = std::chrono::high_resolution_clock::now();
// Push the timer context
timer_ctx->time_limit = time_limit;
timer_ctx->memory_limit = memory_limit;
timer_ctx->time_point = from + duration;
timer_ctx->ctx = c;
timer_ctx->killed = false;
V8JSG(timer_stack).push_front(timer_ctx);
V8JSG(timer_mutex).unlock();
}
/* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

39
v8js_timer.h Normal file
View File

@ -0,0 +1,39 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifndef V8JS_TIMER_H
#define V8JS_TIMER_H
// Timer context
struct v8js_timer_ctx
{
long time_limit;
long memory_limit;
std::chrono::time_point<std::chrono::high_resolution_clock> time_point;
v8js_ctx *ctx;
bool killed;
};
void v8js_timer_thread(TSRMLS_D);
void v8js_timer_push(long time_limit, long memory_limit, v8js_ctx *c TSRMLS_DC);
#endif /* V8JS_TIMER_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

270
v8js_v8.cc Normal file
View File

@ -0,0 +1,270 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if !defined(_WIN32) && PHP_V8_API_VERSION >= 3029036
#include <libplatform/libplatform.h>
#endif
extern "C" {
#include "php.h"
#include "ext/date/php_date.h"
#include "ext/standard/php_string.h"
#include "zend_interfaces.h"
#include "zend_closures.h"
#include "zend_exceptions.h"
}
#include "php_v8js_macros.h"
#include "v8js_v8.h"
#include "v8js_timer.h"
#include "v8js_exceptions.h"
void v8js_v8_init(TSRMLS_D) /* {{{ */
{
/* Run only once */
if (V8JSG(v8_initialized)) {
return;
}
#if !defined(_WIN32) && PHP_V8_API_VERSION >= 3029036
v8::Platform* platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform);
#endif
/* Set V8 command line flags (must be done before V8::Initialize()!) */
if (V8JSG(v8_flags)) {
v8::V8::SetFlagsFromString(V8JSG(v8_flags), strlen(V8JSG(v8_flags)));
}
/* Initialize V8 */
v8::V8::Initialize();
/* Run only once */
V8JSG(v8_initialized) = 1;
}
/* }}} */
void v8js_v8_call(v8js_ctx *c, zval **return_value,
long flags, long time_limit, long memory_limit,
std::function< v8::Local<v8::Value>(v8::Isolate *) >& v8_call TSRMLS_DC) /* {{{ */
{
char *tz = NULL;
V8JS_CTX_PROLOGUE(c);
V8JSG(timer_mutex).lock();
c->time_limit_hit = false;
c->memory_limit_hit = false;
V8JSG(timer_mutex).unlock();
/* Catch JS exceptions */
v8::TryCatch try_catch;
/* Set flags for runtime use */
V8JS_GLOBAL_SET_FLAGS(isolate, flags);
/* Check if timezone has been changed and notify V8 */
tz = getenv("TZ");
if (tz != NULL) {
if (c->tz == NULL) {
c->tz = strdup(tz);
}
else if (strcmp(c->tz, tz) != 0) {
v8::Date::DateTimeConfigurationChangeNotification(c->isolate);
free(c->tz);
c->tz = strdup(tz);
}
}
if (time_limit > 0 || memory_limit > 0) {
// If timer thread is not running then start it
if (!V8JSG(timer_thread)) {
// If not, start timer thread
V8JSG(timer_thread) = new std::thread(v8js_timer_thread TSRMLS_CC);
}
}
/* Always pass the timer to the stack so there can be follow-up changes to
* the time & memory limit. */
v8js_timer_push(time_limit, memory_limit, c TSRMLS_CC);
#ifdef ENABLE_DEBUGGER_SUPPORT
if(c == v8js_debug_context && v8js_debug_auto_break_mode != V8JS_DEBUG_AUTO_BREAK_NEVER) {
v8::Debug::DebugBreak(c->isolate);
if(v8js_debug_auto_break_mode == V8JS_DEBUG_AUTO_BREAK_ONCE) {
/* If break-once-mode was enabled, reset flag. */
v8js_debug_auto_break_mode = V8JS_DEBUG_AUTO_BREAK_NEVER;
}
}
#endif /* ENABLE_DEBUGGER_SUPPORT */
/* Execute script */
c->in_execution++;
v8::Local<v8::Value> result = v8_call(c->isolate);
c->in_execution--;
/* Pop our context from the stack and read (possibly updated) limits
* into local variables. */
V8JSG(timer_mutex).lock();
v8js_timer_ctx *timer_ctx = V8JSG(timer_stack).front();
V8JSG(timer_stack).pop_front();
V8JSG(timer_mutex).unlock();
time_limit = timer_ctx->time_limit;
memory_limit = timer_ctx->memory_limit;
efree(timer_ctx);
/* Check for fatal error marker possibly set by v8js_error_handler; just
* rethrow the error since we're now out of V8. */
if(V8JSG(fatal_error_abort)) {
zend_bailout();
}
char exception_string[64];
if (c->time_limit_hit) {
// Execution has been terminated due to time limit
sprintf(exception_string, "Script time limit of %lu milliseconds exceeded", time_limit);
zend_throw_exception(php_ce_v8js_time_limit_exception, exception_string, 0 TSRMLS_CC);
return;
}
if (c->memory_limit_hit) {
// Execution has been terminated due to memory limit
sprintf(exception_string, "Script memory limit of %lu bytes exceeded", memory_limit);
zend_throw_exception(php_ce_v8js_memory_limit_exception, exception_string, 0 TSRMLS_CC);
return;
}
if (!try_catch.CanContinue()) {
// At this point we can't re-throw the exception
return;
}
/* There was pending exception left from earlier executions -> throw to PHP */
if (c->pending_exception) {
zend_throw_exception_object(c->pending_exception TSRMLS_CC);
c->pending_exception = NULL;
}
/* Handle runtime JS exceptions */
if (try_catch.HasCaught()) {
/* Pending exceptions are set only in outer caller, inner caller exceptions are always rethrown */
if (c->in_execution < 1) {
/* Report immediately if report_uncaught is true */
if (c->report_uncaught) {
v8js_throw_script_exception(&try_catch TSRMLS_CC);
return;
}
/* Exception thrown from JS, preserve it for future execution */
if (result.IsEmpty()) {
MAKE_STD_ZVAL(c->pending_exception);
v8js_create_script_exception(c->pending_exception, &try_catch TSRMLS_CC);
return;
}
}
/* Rethrow back to JS */
try_catch.ReThrow();
return;
}
/* Convert V8 value to PHP value */
if (!result.IsEmpty()) {
v8js_to_zval(result, *return_value, flags, c->isolate TSRMLS_CC);
}
}
/* }}} */
void v8js_terminate_execution(v8js_ctx *c TSRMLS_DC) /* {{{ */
{
// Forcefully terminate the current thread of V8 execution in the isolate
v8::V8::TerminateExecution(c->isolate);
}
/* }}} */
int v8js_get_properties_hash(v8::Handle<v8::Value> jsValue, HashTable *retval, int flags, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
{
v8::Local<v8::Object> jsObj = jsValue->ToObject();
if (!jsObj.IsEmpty()) {
v8::Local<v8::Array> jsKeys = jsObj->GetPropertyNames();
for (unsigned i = 0; i < jsKeys->Length(); i++)
{
v8::Local<v8::String> jsKey = jsKeys->Get(i)->ToString();
/* Skip any prototype properties */
if (!jsObj->HasOwnProperty(jsKey) && !jsObj->HasRealNamedProperty(jsKey) && !jsObj->HasRealNamedCallbackProperty(jsKey)) {
continue;
}
v8::Local<v8::Value> jsVal = jsObj->Get(jsKey);
v8::String::Utf8Value cstr(jsKey);
const char *key = ToCString(cstr);
zval *value = NULL;
v8::Local<v8::Value> php_object;
if (jsVal->IsObject()) {
php_object = v8::Local<v8::Object>::Cast(jsVal)->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY));
}
if (!php_object.IsEmpty()) {
/* This is a PHP object, passed to JS and back. */
value = reinterpret_cast<zval *>(v8::External::Cast(*php_object)->Value());
Z_ADDREF_P(value);
}
else {
MAKE_STD_ZVAL(value);
if (v8js_to_zval(jsVal, value, flags, isolate TSRMLS_CC) == FAILURE) {
zval_ptr_dtor(&value);
return FAILURE;
}
}
if ((flags & V8JS_FLAG_FORCE_ARRAY) || jsValue->IsArray()) {
zend_symtable_update(retval, key, strlen(key) + 1, (void *)&value, sizeof(zval *), NULL);
} else {
zend_hash_update(retval, key, strlen(key) + 1, (void *) &value, sizeof(zval *), NULL);
}
}
return SUCCESS;
}
return FAILURE;
}
/* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

81
v8js_v8.h Normal file
View File

@ -0,0 +1,81 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifndef V8JS_V8_H
#define V8JS_V8_H
/* Helper macros */
#define V8JS_SYM(v) v8::String::NewFromUtf8(isolate, v, v8::String::kInternalizedString, sizeof(v) - 1)
#define V8JS_SYML(v, l) v8::String::NewFromUtf8(isolate, v, v8::String::kInternalizedString, l)
#define V8JS_STR(v) v8::String::NewFromUtf8(isolate, v)
#define V8JS_STRL(v, l) v8::String::NewFromUtf8(isolate, v, v8::String::kNormalString, l)
#define V8JS_INT(v) v8::Integer::New(isolate, v)
#define V8JS_UINT(v) v8::Integer::NewFromUnsigned(isolate, v)
#define V8JS_FLOAT(v) v8::Number::New(isolate, v)
#define V8JS_BOOL(v) ((v)?v8::True(isolate):v8::False(isolate))
#define V8JS_DATE(v) v8::Date::New(isolate, v)
#define V8JS_NULL v8::Null(isolate)
#define V8JS_UNDEFINED v8::Undefined(isolate)
#define V8JS_MN(name) v8js_method_##name
#define V8JS_METHOD(name) void V8JS_MN(name)(const v8::FunctionCallbackInfo<v8::Value>& info)
#define V8JS_THROW(isolate, type, message, message_len) (isolate)->ThrowException(v8::Exception::type(V8JS_STRL(message, message_len)))
#define V8JS_GLOBAL(isolate) ((isolate)->GetCurrentContext()->Global())
/* Extracts a C string from a V8 Utf8Value. */
static inline const char * ToCString(const v8::String::Utf8Value &value) /* {{{ */
{
return *value ? *value : "<string conversion failed>";
}
/* }}} */
void v8js_v8_init(TSRMLS_D);
void v8js_v8_call(v8js_ctx *c, zval **return_value,
long flags, long time_limit, long memory_limit,
std::function< v8::Local<v8::Value>(v8::Isolate *) >& v8_call TSRMLS_DC);
void v8js_terminate_execution(v8js_ctx *c TSRMLS_DC);
/* Fetch V8 object properties */
int v8js_get_properties_hash(v8::Handle<v8::Value> jsValue, HashTable *retval, int flags, v8::Isolate *isolate TSRMLS_DC);
#define V8JS_CTX_PROLOGUE(ctx) \
if (!V8JSG(v8_initialized)) { \
zend_error(E_ERROR, "V8 not initialized"); \
return; \
} \
\
v8::Isolate *isolate = (ctx)->isolate; \
v8::Locker locker(isolate); \
v8::Isolate::Scope isolate_scope(isolate); \
v8::HandleScope handle_scope(isolate); \
v8::Local<v8::Context> v8_context = v8::Local<v8::Context>::New(isolate, (ctx)->context); \
v8::Context::Scope context_scope(v8_context);
#define V8JS_BEGIN_CTX(ctx, object) \
v8js_ctx *(ctx); \
(ctx) = (v8js_ctx *) zend_object_store_get_object(object TSRMLS_CC); \
V8JS_CTX_PROLOGUE(ctx);
#endif /* V8JS_V8_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

588
v8js_v8object_class.cc Normal file
View File

@ -0,0 +1,588 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
extern "C" {
#include "php.h"
#include "ext/date/php_date.h"
#include "ext/standard/php_string.h"
#include "zend_interfaces.h"
#include "zend_closures.h"
#include "ext/spl/spl_exceptions.h"
#include "zend_exceptions.h"
}
#include "php_v8js_macros.h"
#include "v8js_exceptions.h"
#include "v8js_v8.h"
#include "v8js_v8object_class.h"
/* {{{ Class Entries */
zend_class_entry *php_ce_v8object;
zend_class_entry *php_ce_v8function;
/* }}} */
/* {{{ Object Handlers */
static zend_object_handlers v8js_v8object_handlers;
/* }}} */
#define V8JS_V8_INVOKE_FUNC_NAME "V8Js::V8::Invoke"
/* V8 Object handlers */
static int v8js_v8object_has_property(zval *object, zval *member, int has_set_exists ZEND_HASH_KEY_DC TSRMLS_DC) /* {{{ */
{
/* param has_set_exists:
* 0 (has) whether property exists and is not NULL - isset()
* 1 (set) whether property exists and is true-ish - empty()
* 2 (exists) whether property exists - property_exists()
*/
int retval = false;
v8js_v8object *obj = (v8js_v8object *) zend_object_store_get_object(object TSRMLS_CC);
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
return retval;
}
v8::Isolate *isolate = obj->ctx->isolate;
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope local_scope(isolate);
v8::Local<v8::Context> temp_context = v8::Context::New(isolate);
v8::Context::Scope temp_scope(temp_context);
v8::Local<v8::Value> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj);
if (Z_TYPE_P(member) == IS_STRING && v8obj->IsObject() && !v8obj->IsFunction())
{
v8::Local<v8::Object> jsObj = v8obj->ToObject();
v8::Local<v8::String> jsKey = V8JS_STRL(Z_STRVAL_P(member), Z_STRLEN_P(member));
v8::Local<v8::Value> jsVal;
/* Skip any prototype properties */
if (jsObj->HasRealNamedProperty(jsKey) || jsObj->HasRealNamedCallbackProperty(jsKey)) {
if (has_set_exists == 2) {
/* property_exists(), that's enough! */
retval = true;
} else {
/* We need to look at the value. */
jsVal = jsObj->Get(jsKey);
if (has_set_exists == 0 ) {
/* isset(): We make 'undefined' equivalent to 'null' */
retval = !( jsVal->IsNull() || jsVal->IsUndefined() );
} else {
/* empty() */
retval = jsVal->BooleanValue();
/* for PHP compatibility, [] should also be empty */
if (jsVal->IsArray() && retval) {
v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(jsVal);
retval = (array->Length() != 0);
}
/* for PHP compatibility, '0' should also be empty */
if (jsVal->IsString() && retval) {
v8::Local<v8::String> str = jsVal->ToString();
if (str->Length() == 1) {
uint16_t c = 0;
str->Write(&c, 0, 1);
if (c == '0') {
retval = false;
}
}
}
}
}
}
}
return retval;
}
/* }}} */
static zval *v8js_v8object_read_property(zval *object, zval *member, int type ZEND_HASH_KEY_DC TSRMLS_DC) /* {{{ */
{
zval *retval = NULL;
v8js_v8object *obj = (v8js_v8object *) zend_object_store_get_object(object TSRMLS_CC);
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
ALLOC_INIT_ZVAL(retval);
return retval;
}
v8::Isolate *isolate = obj->ctx->isolate;
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope local_scope(isolate);
v8::Local<v8::Context> temp_context = v8::Context::New(isolate);
v8::Context::Scope temp_scope(temp_context);
v8::Local<v8::Value> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj);
if (Z_TYPE_P(member) == IS_STRING && v8obj->IsObject() && !v8obj->IsFunction())
{
v8::Local<v8::Object> jsObj = v8obj->ToObject();
v8::Local<v8::String> jsKey = V8JS_STRL(Z_STRVAL_P(member), Z_STRLEN_P(member));
v8::Local<v8::Value> jsVal;
/* Skip any prototype properties */
if (jsObj->HasRealNamedProperty(jsKey) || jsObj->HasRealNamedCallbackProperty(jsKey)) {
jsVal = jsObj->Get(jsKey);
if (jsVal->IsObject()) {
ALLOC_INIT_ZVAL(retval);
Z_SET_REFCOUNT_P(retval, 0);
} else {
MAKE_STD_ZVAL(retval);
}
if (v8js_to_zval(jsVal, retval, obj->flags, isolate TSRMLS_CC) == SUCCESS) {
return retval;
}
}
}
ALLOC_INIT_ZVAL(retval);
return retval;
}
/* }}} */
static void v8js_v8object_write_property(zval *object, zval *member, zval *value ZEND_HASH_KEY_DC TSRMLS_DC) /* {{{ */
{
v8js_v8object *obj = (v8js_v8object *) zend_object_store_get_object(object TSRMLS_CC);
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
return;
}
v8::Isolate *isolate = obj->ctx->isolate;
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope local_scope(isolate);
v8::Local<v8::Context> temp_context = v8::Context::New(isolate);
v8::Context::Scope temp_scope(temp_context);
v8::Local<v8::Value> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj);
if (v8obj->IsObject() && !v8obj->IsFunction()) {
v8obj->ToObject()->ForceSet(V8JS_SYML(Z_STRVAL_P(member), Z_STRLEN_P(member)), zval_to_v8js(value, isolate TSRMLS_CC));
}
}
/* }}} */
static void v8js_v8object_unset_property(zval *object, zval *member ZEND_HASH_KEY_DC TSRMLS_DC) /* {{{ */
{
v8js_v8object *obj = (v8js_v8object *) zend_object_store_get_object(object TSRMLS_CC);
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
return;
}
v8::Isolate *isolate = obj->ctx->isolate;
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope local_scope(isolate);
v8::Local<v8::Context> temp_context = v8::Context::New(isolate);
v8::Context::Scope temp_scope(temp_context);
v8::Local<v8::Value> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj);
if (v8obj->IsObject() && !v8obj->IsFunction()) {
v8obj->ToObject()->ForceDelete(V8JS_SYML(Z_STRVAL_P(member), Z_STRLEN_P(member)));
}
}
/* }}} */
static HashTable *v8js_v8object_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
v8js_v8object *obj = (v8js_v8object *) zend_object_store_get_object(object TSRMLS_CC);
HashTable *retval;
if (obj->properties == NULL) {
if (GC_G(gc_active)) {
/* the garbage collector is running, don't create more zvals */
return NULL;
}
ALLOC_HASHTABLE(obj->properties);
zend_hash_init(obj->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
if (!obj->ctx) {
/* Half-constructed object, probably due to unserialize call.
* Just pass back properties hash so unserialize can write to
* it (instead of crashing the engine). */
return obj->properties;
}
} else {
zend_hash_clean(obj->properties);
}
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
return NULL;
}
v8::Isolate *isolate = obj->ctx->isolate;
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope local_scope(isolate);
v8::Local<v8::Context> temp_context = v8::Context::New(isolate);
v8::Context::Scope temp_scope(temp_context);
v8::Local<v8::Value> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj);
if (v8js_get_properties_hash(v8obj, obj->properties, obj->flags, isolate TSRMLS_CC) == SUCCESS) {
return obj->properties;
}
return NULL;
}
/* }}} */
static HashTable *v8js_v8object_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
{
*is_temp = 0;
return v8js_v8object_get_properties(object TSRMLS_CC);
}
/* }}} */
static zend_function *v8js_v8object_get_method(zval **object_ptr, char *method, int method_len ZEND_HASH_KEY_DC TSRMLS_DC) /* {{{ */
{
v8js_v8object *obj = (v8js_v8object *) zend_object_store_get_object(*object_ptr TSRMLS_CC);
zend_function *f;
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
return NULL;
}
v8::Isolate *isolate = obj->ctx->isolate;
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope local_scope(isolate);
v8::Local<v8::Context> temp_context = v8::Context::New(isolate);
v8::Context::Scope temp_scope(temp_context);
v8::Local<v8::String> jsKey = V8JS_STRL(method, method_len);
v8::Local<v8::Value> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj);
if (!obj->v8obj.IsEmpty() && v8obj->IsObject() && !v8obj->IsFunction()) {
v8::Local<v8::Object> jsObj = v8obj->ToObject();
if (jsObj->Has(jsKey) && jsObj->Get(jsKey)->IsFunction()) {
f = (zend_function *) ecalloc(1, sizeof(*f));
f->type = ZEND_OVERLOADED_FUNCTION_TEMPORARY;
f->common.function_name = estrndup(method, method_len);
return f;
}
}
return NULL;
}
/* }}} */
#if PHP_VERSION_ID >= 50400
static int v8js_v8object_call_method(const char *method, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
#else
static int v8js_v8object_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
#endif
{
zval *object = this_ptr, ***argv = NULL;
int argc = ZEND_NUM_ARGS();
v8js_v8object *obj;
obj = (v8js_v8object *) zend_object_store_get_object(object TSRMLS_CC);
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
return FAILURE;
}
if (obj->v8obj.IsEmpty()) {
zval_ptr_dtor(&object);
return FAILURE;
}
if (argc > 0) {
argv = (zval***)safe_emalloc(sizeof(zval**), argc, 0);
zend_get_parameters_array_ex(argc, argv);
}
std::function< v8::Local<v8::Value>(v8::Isolate *) > v8_call = [obj, method, argc, argv TSRMLS_CC](v8::Isolate *isolate) {
int i = 0;
v8::Local<v8::String> method_name = V8JS_SYML(method, strlen(method));
v8::Local<v8::Object> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj)->ToObject();
v8::Local<v8::Function> cb;
if (method_name->Equals(V8JS_SYM(V8JS_V8_INVOKE_FUNC_NAME))) {
cb = v8::Local<v8::Function>::Cast(v8obj);
} else {
cb = v8::Local<v8::Function>::Cast(v8obj->Get(method_name));
}
v8::Local<v8::Value> *jsArgv = static_cast<v8::Local<v8::Value> *>(alloca(sizeof(v8::Local<v8::Value>) * argc));
v8::Local<v8::Value> js_retval;
for (i = 0; i < argc; i++) {
new(&jsArgv[i]) v8::Local<v8::Value>;
jsArgv[i] = v8::Local<v8::Value>::New(isolate, zval_to_v8js(*argv[i], isolate TSRMLS_CC));
}
return cb->Call(V8JS_GLOBAL(isolate), argc, jsArgv);
};
v8js_v8_call(obj->ctx, &return_value, obj->flags, obj->ctx->time_limit, obj->ctx->memory_limit, v8_call TSRMLS_CC);
zval_ptr_dtor(&object);
if (argc > 0) {
efree(argv);
}
return SUCCESS;
}
/* }}} */
static int v8js_v8object_get_closure(zval *object, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC) /* {{{ */
{
zend_function *invoke;
v8js_v8object *obj = (v8js_v8object *) zend_object_store_get_object(object TSRMLS_CC);
if (!obj->ctx) {
zend_throw_exception(php_ce_v8js_exception,
"Can't access V8Object after V8Js instance is destroyed!", 0 TSRMLS_CC);
return FAILURE;
}
v8::Isolate *isolate = obj->ctx->isolate;
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope local_scope(isolate);
v8::Local<v8::Context> temp_context = v8::Context::New(isolate);
v8::Context::Scope temp_scope(temp_context);
v8::Local<v8::Value> v8obj = v8::Local<v8::Value>::New(isolate, obj->v8obj);
if (!v8obj->IsFunction()) {
return FAILURE;
}
invoke = (zend_function *) ecalloc(1, sizeof(*invoke));
invoke->type = ZEND_OVERLOADED_FUNCTION_TEMPORARY;
invoke->common.function_name = estrndup(V8JS_V8_INVOKE_FUNC_NAME, sizeof(V8JS_V8_INVOKE_FUNC_NAME) - 1);
*fptr_ptr = invoke;
if (zobj_ptr) {
*zobj_ptr = object;
}
*ce_ptr = NULL;
return SUCCESS;
}
/* }}} */
static void v8js_v8object_free_storage(void *object, zend_object_handle handle TSRMLS_DC) /* {{{ */
{
v8js_v8object *c = (v8js_v8object *) object;
if (c->properties) {
zend_hash_destroy(c->properties);
FREE_HASHTABLE(c->properties);
c->properties = NULL;
}
zend_object_std_dtor(&c->std TSRMLS_CC);
if(c->ctx) {
c->v8obj.Reset();
c->ctx->v8js_v8objects.remove(c);
}
efree(object);
}
/* }}} */
static zend_object_value v8js_v8object_new(zend_class_entry *ce TSRMLS_DC) /* {{{ */
{
zend_object_value retval;
v8js_v8object *c;
c = (v8js_v8object *) ecalloc(1, sizeof(*c));
zend_object_std_init(&c->std, ce TSRMLS_CC);
new(&c->v8obj) v8::Persistent<v8::Value>();
retval.handle = zend_objects_store_put(c, NULL, (zend_objects_free_object_storage_t) v8js_v8object_free_storage, NULL TSRMLS_CC);
retval.handlers = &v8js_v8object_handlers;
return retval;
}
/* }}} */
/* NOTE: We could also override v8js_v8object_handlers.get_constructor to throw
* an exception when invoked, but doing so causes the half-constructed object
* to leak -- this seems to be a PHP bug. So we'll define magic __construct
* methods instead. */
/* {{{ proto V8Object::__construct()
*/
PHP_METHOD(V8Object,__construct)
{
zend_throw_exception(php_ce_v8js_exception,
"Can't directly construct V8 objects!", 0 TSRMLS_CC);
RETURN_FALSE;
}
/* }}} */
/* {{{ proto V8Object::__sleep()
*/
PHP_METHOD(V8Object, __sleep)
{
zend_throw_exception(php_ce_v8js_exception,
"You cannot serialize or unserialize V8Object instances", 0 TSRMLS_CC);
RETURN_FALSE;
}
/* }}} */
/* {{{ proto V8Object::__wakeup()
*/
PHP_METHOD(V8Object, __wakeup)
{
zend_throw_exception(php_ce_v8js_exception,
"You cannot serialize or unserialize V8Object instances", 0 TSRMLS_CC);
RETURN_FALSE;
}
/* }}} */
/* {{{ proto V8Function::__construct()
*/
PHP_METHOD(V8Function,__construct)
{
zend_throw_exception(php_ce_v8js_exception,
"Can't directly construct V8 objects!", 0 TSRMLS_CC);
RETURN_FALSE;
}
/* }}} */
/* {{{ proto V8Function::__sleep()
*/
PHP_METHOD(V8Function, __sleep)
{
zend_throw_exception(php_ce_v8js_exception,
"You cannot serialize or unserialize V8Function instances", 0 TSRMLS_CC);
RETURN_FALSE;
}
/* }}} */
/* {{{ proto V8Function::__wakeup()
*/
PHP_METHOD(V8Function, __wakeup)
{
zend_throw_exception(php_ce_v8js_exception,
"You cannot serialize or unserialize V8Function instances", 0 TSRMLS_CC);
RETURN_FALSE;
}
/* }}} */
void v8js_v8object_create(zval *res, v8::Handle<v8::Value> value, int flags, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
{
v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
v8js_v8object *c;
object_init_ex(res, value->IsFunction() ? php_ce_v8function : php_ce_v8object);
c = (v8js_v8object *) zend_object_store_get_object(res TSRMLS_CC);
c->v8obj.Reset(isolate, value);
c->flags = flags;
c->ctx = ctx;
c->properties = NULL;
ctx->v8js_v8objects.push_front(c);
}
/* }}} */
static const zend_function_entry v8js_v8object_methods[] = { /* {{{ */
PHP_ME(V8Object, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
PHP_ME(V8Object, __sleep, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(V8Object, __wakeup, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
};
/* }}} */
static const zend_function_entry v8js_v8function_methods[] = { /* {{{ */
PHP_ME(V8Function, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
PHP_ME(V8Function, __sleep, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
PHP_ME(V8Function, __wakeup, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
};
/* }}} */
PHP_MINIT_FUNCTION(v8js_v8object_class) /* {{{ */
{
zend_class_entry ce;
/* V8Object Class */
INIT_CLASS_ENTRY(ce, "V8Object", v8js_v8object_methods);
php_ce_v8object = zend_register_internal_class(&ce TSRMLS_CC);
php_ce_v8object->ce_flags |= ZEND_ACC_FINAL;
php_ce_v8object->create_object = v8js_v8object_new;
/* V8Function Class */
INIT_CLASS_ENTRY(ce, "V8Function", v8js_v8function_methods);
php_ce_v8function = zend_register_internal_class(&ce TSRMLS_CC);
php_ce_v8function->ce_flags |= ZEND_ACC_FINAL;
php_ce_v8function->create_object = v8js_v8object_new;
/* V8<Object|Function> handlers */
memcpy(&v8js_v8object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
v8js_v8object_handlers.clone_obj = NULL;
v8js_v8object_handlers.cast_object = NULL;
v8js_v8object_handlers.get_property_ptr_ptr = NULL;
v8js_v8object_handlers.has_property = v8js_v8object_has_property;
v8js_v8object_handlers.read_property = v8js_v8object_read_property;
v8js_v8object_handlers.write_property = v8js_v8object_write_property;
v8js_v8object_handlers.unset_property = v8js_v8object_unset_property;
v8js_v8object_handlers.get_properties = v8js_v8object_get_properties;
v8js_v8object_handlers.get_method = v8js_v8object_get_method;
v8js_v8object_handlers.call_method = v8js_v8object_call_method;
v8js_v8object_handlers.get_debug_info = v8js_v8object_get_debug_info;
v8js_v8object_handlers.get_closure = v8js_v8object_get_closure;
} /* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

44
v8js_v8object_class.h Normal file
View File

@ -0,0 +1,44 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2013 The PHP Group |
+----------------------------------------------------------------------+
| http://www.opensource.org/licenses/mit-license.php MIT License |
+----------------------------------------------------------------------+
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
| Author: Patrick Reilly <preilly@php.net> |
+----------------------------------------------------------------------+
*/
#ifndef V8JS_V8OBJECT_CLASS_H
#define V8JS_V8OBJECT_CLASS_H
/* {{{ Object container */
struct v8js_v8object {
zend_object std;
v8::Persistent<v8::Value> v8obj;
int flags;
struct v8js_ctx *ctx;
HashTable *properties;
};
/* }}} */
extern zend_class_entry *php_ce_v8object;
extern zend_class_entry *php_ce_v8function;
/* Create PHP V8 object */
void v8js_v8object_create(zval *, v8::Handle<v8::Value>, int, v8::Isolate * TSRMLS_DC);
PHP_MINIT_FUNCTION(v8js_v8object_class);
#endif /* V8JS_V8OBJECT_CLASS_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/

12
v8js_variables.cc
View File

@ -25,10 +25,10 @@ extern "C" {
#include <v8.h>
#include <string>
static void php_v8js_fetch_php_variable(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) /* {{{ */
static void v8js_fetch_php_variable(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) /* {{{ */
{
v8::Handle<v8::External> data = v8::Handle<v8::External>::Cast(info.Data());
php_v8js_accessor_ctx *ctx = static_cast<php_v8js_accessor_ctx *>(data->Value());
v8js_accessor_ctx *ctx = static_cast<v8js_accessor_ctx *>(data->Value());
v8::Isolate *isolate = ctx->isolate;
zval **variable;
@ -43,14 +43,14 @@ static void php_v8js_fetch_php_variable(v8::Local<v8::String> name, const v8::Pr
}
/* }}} */
void php_v8js_accessor_ctx_dtor(php_v8js_accessor_ctx *ctx TSRMLS_DC) /* {{{ */
void v8js_accessor_ctx_dtor(v8js_accessor_ctx *ctx TSRMLS_DC) /* {{{ */
{
efree(ctx->variable_name_string);
efree(ctx);
}
/* }}} */
void php_v8js_register_accessors(std::vector<php_v8js_accessor_ctx*> *accessor_list, v8::Local<v8::FunctionTemplate> php_obj_t, zval *array, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
void v8js_register_accessors(std::vector<v8js_accessor_ctx*> *accessor_list, v8::Local<v8::FunctionTemplate> php_obj_t, zval *array, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
{
char *property_name;
uint property_name_len;
@ -80,13 +80,13 @@ void php_v8js_register_accessors(std::vector<php_v8js_accessor_ctx*> *accessor_l
}
// Create context to store accessor data
php_v8js_accessor_ctx *ctx = (php_v8js_accessor_ctx *)emalloc(sizeof(php_v8js_accessor_ctx));
v8js_accessor_ctx *ctx = (v8js_accessor_ctx *)emalloc(sizeof(v8js_accessor_ctx));
ctx->variable_name_string = estrdup(Z_STRVAL_PP(item));
ctx->variable_name_string_len = Z_STRLEN_PP(item);
ctx->isolate = isolate;
/* Set the variable fetch callback for given symbol on named property */
php_obj->SetAccessor(V8JS_STRL(property_name, property_name_len - 1), php_v8js_fetch_php_variable, NULL, v8::External::New(isolate, ctx), v8::PROHIBITS_OVERWRITING, v8::ReadOnly, v8::AccessorSignature::New(isolate, php_obj_t));
php_obj->SetAccessor(V8JS_STRL(property_name, property_name_len - 1), v8js_fetch_php_variable, NULL, v8::External::New(isolate, ctx), v8::PROHIBITS_OVERWRITING, v8::ReadOnly, v8::AccessorSignature::New(isolate, php_obj_t));
/* record the context so we can free it later */
accessor_list->push_back(ctx);