jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'Richie765-master'

Browse source 
Conflicts:
	CHANGES.current
This commit is contained in:
Oliver Buchtala 2014-09-30 18:46:25 +02:00
commit 53d7fc8a16
17 changed files with 590 additions and 305 deletions
Download patch file Download diff file Expand all files Collapse all files

3
CHANGES.current
View file

@ -60,6 +60,9 @@ Version 3.0.3 (in progress)
Issue an error for unknown SWIG preprocessor directives, rather
than quietly ignoring them. Reported by jrhelsey in issue#217.
2014-08-23: richie765
[Javascript] Added support for a variety of V8 versions
2014-08-15: talby
[Perl] Include guard fix for nested modules from Anthony Heading (SF Patch #350).

13
Doc/Manual/Javascript.html
View file

@ -88,6 +88,12 @@ $ swig -javascript -jsc example.i</pre>
<pre>
$ swig -c++ -javascript -jsc example.i</pre>
</div>
<p>The V8 code that SWIG generates should work with most versions from 3.11.10 up to 3.29.14 and later.</p>
<p>Specify the V8 version when running SWIG (e.g. 3.25.30)</p>
<div class="shell">
<pre>
$ swig -c++ -javascript -v8 -DV8_VERSION=0x032530 example.i</pre>
</div>
<p>This creates a C/C++ source file <code>example_wrap.c</code> or <code>example_wrap.cxx</code>. The generated C source file contains the low-level wrappers that need to be compiled and linked with the rest of your C/C++ application to create an extension module.</p>
<p>The name of the wrapper file is derived from the name of the input file. For example, if the input file is <code>example.i</code>, the name of the wrapper file is <code>example_wrap.c</code>. To change this, you can use the -o option. The wrapped module will export one function which must be called to register the module with the Javascript interpreter. For example, if your module is named <code>example</code> the corresponding initializer for JavascriptCore would be</p>
<div class="code">
@ -129,6 +135,11 @@ $ make check-javascript-examples ENGINE=jsc</pre>
<pre>
$ make check-javascript-test-suite ENGINE=jsc</pre>
</div>
<p>You can specify a specific <code>V8</code> version for running the examples and tests</p>
<div class="shell">
<pre>
$ make check-javascript-examples V8_VERSION=0x032530 ENGINE=v8</pre>
</div>
<H3><a name="Javascript_known_issues"></a>26.2.3 Known Issues</H3>
@ -446,7 +457,7 @@ var x = 42;
var y = 105;
var g = example.gcd(x,y);
// Accessing the globak variable
// Accessing the global variable
var f = example.Foo;
example.Foo = 3.1415926;</pre>
</div>

8
Examples/javascript/example.mk
View file

@ -7,12 +7,18 @@ else
JSENGINE=node
endif
ifneq (, $(V8_VERSION))
JSV8_VERSION=$(V8_VERSION)
else
JSV8_VERSION=0x031110
endif
EXAMPLES_TOP=../..
SWIG_TOP=../../..
SWIG = $(SWIG_TOP)/preinst-swig
TARGET = example
INTERFACE = example.i
SWIGOPT=-$(JSENGINE)
SWIGOPT=-$(JSENGINE) -DV8_VERSION=$(JSV8_VERSION)
check: build
$(MAKE) -f $(EXAMPLES_TOP)/Makefile SRCDIR='$(SRCDIR)' JSENGINE='$(JSENGINE)' TARGET='$(TARGET)' javascript_run

8
Examples/javascript/template/runme.js
View file

@ -9,20 +9,20 @@ console.log(example.maxdouble(3.14,2.18));
iv = new example.vecint(100);
dv = new example.vecdouble(1000);
for(i=0;i<=100;i++)
for(i=0;i<100;i++)
iv.setitem(i,2*i);
for(i=0;i<=1000;i++)
for(i=0;i<1000;i++)
dv.setitem(i, 1.0/(i+1));
sum = 0;
for(i=0;i<=100;i++)
for(i=0;i<100;i++)
sum = sum + iv.getitem(i);
console.log(sum);
sum = 0.0;
for(i=0;i<=1000;i++)
for(i=0;i<1000;i++)
sum = sum + dv.getitem(i);
console.log(sum);

8
Examples/test-suite/javascript/Makefile.in
View file

@ -19,8 +19,16 @@ else
JSENGINE=node
endif
ifneq (, $(V8_VERSION))
JSV8_VERSION=$(V8_VERSION)
else
JSV8_VERSION=0x031110
endif
include $(srcdir)/../common.mk
SWIGOPT += -DV8_VERSION=$(JSV8_VERSION)
_setup = \
if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
echo "$(ACTION)ing $(LANGUAGE) ($(JSENGINE)) testcase $* (with run test)" ; \

2
Examples/test-suite/typemap_variables.i
View file

@ -16,7 +16,7 @@
// For Javascript V8 we can not use '0' for out typemaps
#if defined(SWIG_JAVASCRIPT_V8)
%header %{
#define OUT_NULL_VALUE v8::Null()
#define OUT_NULL_VALUE SWIGV8_NULL()
%}
#else
%header %{

133
Lib/javascript/v8/javascriptcode.swg
View file

@ -8,8 +8,9 @@
* ----------------------------------------------------------------------------- */
%fragment("js_ctor", "templates") %{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
v8::HandleScope scope;
static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Object> self = args.Holder();
$jslocals
if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
@ -20,7 +21,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
goto fail;
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
%}
@ -31,10 +32,11 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment ("js_veto_ctor", "templates")
%{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
v8::HandleScope scope;
static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated");
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
%}
@ -46,8 +48,9 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
* ----------------------------------------------------------------------------- */
%fragment ("js_ctor_dispatcher", "templates")
%{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
v8::HandleScope scope;
static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
OverloadErrorHandler errorHandler;
v8::Handle<v8::Value> self;
@ -58,7 +61,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of $jsmangledname");
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
%}
@ -71,8 +74,9 @@ fail:
* - $jsmangledtype: mangled type of class
* ----------------------------------------------------------------------------- */
%fragment("js_overloaded_ctor", "templates") %{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8_ErrorHandler) {
v8::HandleScope scope;
static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Object> self = args.Holder();
$jslocals
if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
@ -83,7 +87,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8
goto fail;
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
%}
@ -98,10 +102,10 @@ fail:
%{
if(args.Length() == $jsargcount) {
errorHandler.err.Clear();
#if SWIG_V8_VERSION < 0x031900
#if (SWIG_V8_VERSION < 0x031903)
self = $jswrapper(args, errorHandler);
if(errorHandler.err.IsEmpty()) {
return scope.Close(self);
SWIGV8_ESCAPE(self);
}
#else
$jswrapper(args, errorHandler);
@ -120,13 +124,18 @@ fail:
%fragment ("js_dtor", "templates")
%{
#if (SWIG_V8_VERSION < 0x031900)
void $jswrapper(v8::Persistent< v8::Value > object, void *parameter)
{
#if (SWIG_V8_VERSION < 0x031710)
static void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) {
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
#elif (SWIG_V8_VERSION < 0x031900)
static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SWIGV8_Proxy *proxy) {
#else
void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWIGV8_Proxy *proxy)
{
static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
v8::Local<v8::Object> object = data.GetValue();
SWIGV8_Proxy *proxy = data.GetParameter();
#endif
if(proxy->swigCMemOwn && proxy->swigCObject) {
@ -138,8 +147,11 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
delete proxy;
object.Clear();
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
object.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
object.Dispose(isolate);
#elif (SWIG_V8_VERSION < 0x032100)
object->Dispose(isolate);
#else
@ -156,26 +168,36 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
* ----------------------------------------------------------------------------- */
%fragment ("js_dtoroverride", "templates")
%{
#if (SWIG_V8_VERSION < 0x031900)
void $jswrapper(v8::Persistent< v8::Value > object, void *parameter)
{
#if (SWIG_V8_VERSION < 0x031710)
static void $jswrapper(v8::Persistent<v8::Value> object, void *parameter) {
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
#elif (SWIG_V8_VERSION < 0x031900)
static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
static void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
#else
void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWIGV8_Proxy *proxy)
{
static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
v8::Local<v8::Object> object = data.GetValue();
SWIGV8_Proxy *proxy = data.GetParameter();
#endif
if(proxy->swigCMemOwn && proxy->swigCObject) {
$jstype arg1 = ($jstype)proxy->swigCObject;
${destructor_action}
}
delete proxy;
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
object.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
object.Dispose(isolate);
#elif (SWIG_V8_VERSION < 0x032100)
object->Dispose(isolate);
#else
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
object->Dispose();
#else
object.Clear();
#endif
}
%}
@ -188,8 +210,9 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
* ----------------------------------------------------------------------------- */
%fragment("js_getter", "templates")
%{
SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo& info) {
v8::HandleScope scope;
static SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult;
$jslocals
$jscode
@ -197,7 +220,7 @@ SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8Propert
goto fail;
fail:
SWIGV8_RETURN_INFO(v8::Undefined(), info);
SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}
%}
@ -209,9 +232,10 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("js_setter", "templates")
%{
void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value,
const SwigV8PropertyCallbackInfoVoid& info) {
v8::HandleScope scope;
static void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value,
const SwigV8PropertyCallbackInfoVoid &info) {
SWIGV8_HANDLESCOPE();
$jslocals
$jscode
goto fail;
@ -228,8 +252,9 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("js_function", "templates")
%{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
v8::HandleScope scope;
static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult;
$jslocals
if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
@ -239,7 +264,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
goto fail;
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
%}
@ -252,8 +277,9 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("js_function_dispatcher", "templates")
%{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
v8::HandleScope scope;
static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult;
OverloadErrorHandler errorHandler;
$jscode
@ -262,7 +288,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
goto fail;
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
%}
@ -274,9 +300,10 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment ("js_overloaded_function", "templates")
%{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8_ErrorHandler)
static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
{
v8::HandleScope scope;
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult;
$jslocals
$jscode
@ -284,7 +311,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8
goto fail;
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
%}
@ -299,10 +326,10 @@ fail:
if(args.Length() == $jsargcount) {
errorHandler.err.Clear();
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031903)
jsresult = $jswrapper(args, errorHandler);
if(errorHandler.err.IsEmpty()) {
return scope.Close(jsresult);
SWIGV8_ESCAPE(jsresult);
}
#else
$jswrapper(args, errorHandler);
@ -330,12 +357,9 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("jsv8_define_class_template", "templates")
%{
/* Name: $jsmangledname, Type: $jsmangledtype, Dtor: $jsdtor */
v8::Handle<v8::FunctionTemplate> $jsmangledname_class = SWIGV8_CreateClassTemplate("$jsmangledname");
#if (SWIG_V8_VERSION < 0x031900)
$jsmangledname_clientData.class_templ = v8::Persistent<v8::FunctionTemplate>::New($jsmangledname_class);
#else
$jsmangledname_clientData.class_templ.Reset(v8::Isolate::GetCurrent(), $jsmangledname_class);
#endif
SWIGV8_SET_CLASS_TEMPL($jsmangledname_clientData.class_templ, $jsmangledname_class);
$jsmangledname_clientData.dtor = $jsdtor;
if (SWIGTYPE_$jsmangledtype->clientdata == 0) {
SWIGTYPE_$jsmangledtype->clientdata = &$jsmangledname_clientData;
@ -352,11 +376,11 @@ fail:
%{
if (SWIGTYPE_p$jsbaseclass->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ.IsEmpty()))
{
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031903)
$jsmangledname_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ);
#else
$jsmangledname_class->Inherit(
v8::Handle<v8::FunctionTemplate>::New(
v8::Local<v8::FunctionTemplate>::New(
v8::Isolate::GetCurrent(),
static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ)
);
@ -379,6 +403,7 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("jsv8_create_class_instance", "templates")
%{
/* Class: $jsname ($jsmangledname) */
v8::Handle<v8::FunctionTemplate> $jsmangledname_class_0 = SWIGV8_CreateClassTemplate("$jsname");
$jsmangledname_class_0->SetCallHandler($jsctor);
$jsmangledname_class_0->Inherit($jsmangledname_class);
@ -394,7 +419,7 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("jsv8_register_class", "templates")
%{
$jsparent_obj->Set(v8::String::NewSymbol("$jsname"), $jsmangledname_obj);
$jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj);
%}
/* -----------------------------------------------------------------------------
@ -403,7 +428,7 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("jsv8_create_namespace", "templates")
%{
v8::Handle<v8::Object> $jsmangledname_obj = v8::Object::New();
v8::Handle<v8::Object> $jsmangledname_obj = SWIGV8_OBJECT_NEW();
%}
/* -----------------------------------------------------------------------------
@ -414,7 +439,7 @@ fail:
* ----------------------------------------------------------------------------- */
%fragment("jsv8_register_namespace", "templates")
%{
$jsparent_obj->Set(v8::String::NewSymbol("$jsname"), $jsmangledname_obj);
$jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj);
%}
/* -----------------------------------------------------------------------------

11
Lib/javascript/v8/javascriptcomplex.swg
View file

@ -15,12 +15,13 @@
SWIGINTERNINLINE v8::Handle<v8::Value>
SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
{
v8::HandleScope scope;
v8::Local<v8::Array> vals = v8::Array::New(2);
SWIGV8_HANDLESCOPE_ESC();
v8::Local<v8::Array> vals = SWIGV8_ARRAY_NEW(2);
vals->Set(0, SWIG_From(double)(Real(c)));
vals->Set(1, SWIG_From(double)(Imag(c)));
return scope.Close(vals);
SWIGV8_ESCAPE(vals);
}
}
%enddef
@ -33,7 +34,7 @@ SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
SWIGINTERN int
SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
{
v8::HandleScope scope;
SWIGV8_HANDLESCOPE();
if (o->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o);
@ -75,7 +76,7 @@ SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
SWIGINTERN int
SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
{
v8::HandleScope scope;
SWIGV8_HANDLESCOPE();
if (o->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o);

23
Lib/javascript/v8/javascripthelpers.swg
View file

@ -1,7 +1,7 @@
%insert(runtime) %{
// Note: since 3.19 there are new CallBack types, since 03.21.9 the old ones have been removed
#if SWIG_V8_VERSION < 0x031900
#if (SWIG_V8_VERSION < 0x031903)
typedef v8::InvocationCallback SwigV8FunctionCallback;
typedef v8::AccessorGetter SwigV8AccessorGetterCallback;
typedef v8::AccessorSetter SwigV8AccessorSetterCallback;
@ -17,20 +17,21 @@ typedef v8::PropertyCallbackInfo<void> SwigV8PropertyCallbackInfoVoid;
* Creates a class template for a class with specified initialization function.
*/
SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const char* symbol) {
v8::HandleScope scope;
v8::Local<v8::FunctionTemplate> class_templ = v8::FunctionTemplate::New();
class_templ->SetClassName(v8::String::NewSymbol(symbol));
SWIGV8_HANDLESCOPE_ESC();
v8::Local<v8::FunctionTemplate> class_templ = SWIGV8_FUNCTEMPLATE_NEW_VOID();
class_templ->SetClassName(SWIGV8_SYMBOL_NEW(symbol));
v8::Handle<v8::ObjectTemplate> inst_templ = class_templ->InstanceTemplate();
inst_templ->SetInternalFieldCount(1);
v8::Handle<v8::ObjectTemplate> equals_templ = class_templ->PrototypeTemplate();
equals_templ->Set(v8::String::NewSymbol("equals"), v8::FunctionTemplate::New(_SWIGV8_wrap_equals));
equals_templ->Set(SWIGV8_SYMBOL_NEW("equals"), SWIGV8_FUNCTEMPLATE_NEW(_SWIGV8_wrap_equals));
v8::Handle<v8::ObjectTemplate> cptr_templ = class_templ->PrototypeTemplate();
cptr_templ->Set(v8::String::NewSymbol("getCPtr"), v8::FunctionTemplate::New(_wrap_getCPtr));
cptr_templ->Set(SWIGV8_SYMBOL_NEW("getCPtr"), SWIGV8_FUNCTEMPLATE_NEW(_wrap_getCPtr));
return scope.Close(class_templ);
SWIGV8_ESCAPE(class_templ);
}
/**
@ -39,7 +40,7 @@ SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const ch
SWIGRUNTIME void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
SwigV8FunctionCallback _func) {
v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->PrototypeTemplate();
proto_templ->Set(v8::String::NewSymbol(symbol), v8::FunctionTemplate::New(_func));
proto_templ->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func));
}
/**
@ -48,7 +49,7 @@ SWIGRUNTIME void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class
SWIGRUNTIME void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->InstanceTemplate();
proto_templ->SetAccessor(v8::String::NewSymbol(symbol), getter, setter);
proto_templ->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
}
/**
@ -56,7 +57,7 @@ SWIGRUNTIME void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class
*/
SWIGRUNTIME void SWIGV8_AddStaticFunction(v8::Handle<v8::Object> obj, const char* symbol,
const SwigV8FunctionCallback& _func) {
obj->Set(v8::String::NewSymbol(symbol), v8::FunctionTemplate::New(_func)->GetFunction());
obj->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction());
}
/**
@ -64,7 +65,7 @@ SWIGRUNTIME void SWIGV8_AddStaticFunction(v8::Handle<v8::Object> obj, const char
*/
SWIGRUNTIME void SWIGV8_AddStaticVariable(v8::Handle<v8::Object> obj, const char* symbol,
SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
obj->SetAccessor(v8::String::NewSymbol(symbol), getter, setter);
obj->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
}
SWIGRUNTIME void JS_veto_set_variable(v8::Local<v8::String> property, v8::Local<v8::Value> value,

19
Lib/javascript/v8/javascriptinit.swg
View file

@ -4,16 +4,16 @@
SWIGRUNTIME void
SWIG_V8_SetModule(void *, swig_module_info *swig_module) {
v8::Local<v8::Object> global_obj = v8::Context::GetCurrent()->Global();
v8::Local<v8::External> mod = v8::External::New(swig_module);
v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
v8::Local<v8::External> mod = SWIGV8_EXTERNAL_NEW(swig_module);
assert(!mod.IsEmpty());
global_obj->SetHiddenValue(v8::String::New("swig_module_info_data"), mod);
global_obj->SetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"), mod);
}
SWIGRUNTIME swig_module_info *
SWIG_V8_GetModule(void *) {
v8::Local<v8::Object> global_obj = v8::Context::GetCurrent()->Global();
v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(v8::String::New("swig_module_info_data"));
v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"));
if (moduleinfo.IsEmpty())
{
@ -61,7 +61,8 @@ void SWIGV8_INIT (v8::Handle<v8::Object> exports, v8::Handle<v8::Object> /*modul
{
SWIG_InitializeModule(static_cast<void *>(&exports));
v8::HandleScope scope;
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Object> exports_obj = exports;
%}
@ -81,11 +82,7 @@ void SWIGV8_INIT (v8::Handle<v8::Object> exports, v8::Handle<v8::Object> /*modul
%fragment("js_initializer", "templates")
%{
// a class template for creating proxies of undefined types
#if (SWIG_V8_VERSION < 0x031900)
SWIGV8_SWIGTYPE_Proxy_class_templ = v8::Persistent<v8::FunctionTemplate>::New(SWIGV8_CreateClassTemplate("SwigProxy"));
#else
SWIGV8_SWIGTYPE_Proxy_class_templ.Reset(v8::Isolate::GetCurrent(), SWIGV8_CreateClassTemplate("SwigProxy"));
#endif
SWIGV8_SET_CLASS_TEMPL(SWIGV8_SWIGTYPE_Proxy_class_templ, SWIGV8_CreateClassTemplate("SwigProxy"));
/* create objects for namespaces */
$jsv8nspaces

14
Lib/javascript/v8/javascriptprimtypes.swg
View file

@ -9,7 +9,7 @@ SWIGINTERNINLINE
v8::Handle<v8::Value>
SWIG_From_dec(bool)(bool value)
{
return v8::Boolean::New(value);
return SWIGV8_BOOLEAN_NEW(value);
}
}
@ -33,7 +33,7 @@ int SWIG_AsVal_dec(bool)(v8::Handle<v8::Value> obj, bool *val)
SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(int)(int value)
{
return v8::Int32::New(value);
return SWIGV8_INT32_NEW(value);
}
}
@ -56,7 +56,7 @@ int SWIG_AsVal_dec(int)(v8::Handle<v8::Value> valRef, int* val)
SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(long)(long value)
{
return v8::Number::New(value);
return SWIGV8_NUMBER_NEW(value);
}
}
@ -82,7 +82,7 @@ SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(unsigned long)(unsigned long value)
{
return (value > LONG_MAX) ?
v8::Integer::NewFromUnsigned(value) : v8::Integer::New(%numeric_cast(value,long));
SWIGV8_INTEGER_NEW_UNS(value) : SWIGV8_INTEGER_NEW(%numeric_cast(value,long));
}
}
@ -116,7 +116,7 @@ int SWIG_AsVal_dec(unsigned long)(v8::Handle<v8::Value> obj, unsigned long *val)
SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(long long)(long long value)
{
return v8::Number::New(value);
return SWIGV8_NUMBER_NEW(value);
}
}
@ -146,7 +146,7 @@ SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(unsigned long long)(unsigned long long value)
{
return (value > LONG_MAX) ?
v8::Integer::NewFromUnsigned(value) : v8::Integer::New(%numeric_cast(value,long));
SWIGV8_INTEGER_NEW_UNS(value) : SWIGV8_INTEGER_NEW(%numeric_cast(value,long));
}
}
@ -179,7 +179,7 @@ int SWIG_AsVal_dec(unsigned long long)(v8::Handle<v8::Value> obj, unsigned long
SWIGINTERN
v8::Handle<v8::Value> SWIG_From_dec(double) (double val)
{
return v8::Number::New(val);
return SWIGV8_NUMBER_NEW(val);
}
}

371
Lib/javascript/v8/javascriptrun.swg
View file

@ -1,3 +1,96 @@
/* ---------------------------------------------------------------------------
* These typedefs and defines are used to deal with v8 API changes
*
* ---------------------------------------------------------------------------*/
// First v8 version that uses "SetWeak" and not "MakeWeak"
#define SWIGV8_SETWEAK_VERSION 0x032224
#if (SWIG_V8_VERSION < 0x031803)
#define SWIGV8_STRING_NEW2(cstr, len) v8::String::New(cstr, len)
#else
#define SWIGV8_STRING_NEW2(cstr, len) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::String::kNormalString, len)
#endif
#if (SWIG_V8_VERSION < 0x031903)
typedef v8::Handle<v8::Value> SwigV8ReturnValue;
typedef v8::Arguments SwigV8Arguments;
typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) return scope.Close(val)
#define SWIGV8_RETURN_INFO(val, info) return scope.Close(val)
#else
typedef void SwigV8ReturnValue;
typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
#endif
#if (SWIG_V8_VERSION < 0x032117)
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope
#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope
#define SWIGV8_ESCAPE(val) return scope.Close(val)
#elif (SWIG_V8_VERSION < 0x032224)
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_ESCAPE(val) return scope.Close(val)
#else
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_ESCAPE(val) return scope.Escape(val)
#endif
#if (SWIG_V8_VERSION < 0x032224)
#define SWIGV8_ADJUST_MEMORY(size) v8::V8::AdjustAmountOfExternalAllocatedMemory(size)
#define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
#define SWIGV8_THROW_EXCEPTION(err) v8::ThrowException(err)
#define SWIGV8_STRING_NEW(str) v8::String::New(str)
#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewSymbol(sym)
#else
#define SWIGV8_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size)
#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
#define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err)
#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym)
#endif
#if (SWIG_V8_VERSION < 0x032318)
#define SWIGV8_ARRAY_NEW() v8::Array::New()
#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(bool)
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(func)
#define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New()
#define SWIGV8_INT32_NEW(num) v8::Int32::New(num)
#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(num)
#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(num)
#define SWIGV8_NUMBER_NEW(num) v8::Number::New(num)
#define SWIGV8_OBJECT_NEW() v8::Object::New()
#define SWIGV8_UNDEFINED() v8::Undefined()
#define SWIGV8_NULL() v8::Null()
#else
#define SWIGV8_ARRAY_NEW() v8::Array::New(v8::Isolate::GetCurrent())
#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(v8::Isolate::GetCurrent(), bool)
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
#define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New(v8::Isolate::GetCurrent())
#define SWIGV8_INT32_NEW(num) v8::Int32::New(v8::Isolate::GetCurrent(), num)
#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(v8::Isolate::GetCurrent(), num)
#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(v8::Isolate::GetCurrent(), num)
#define SWIGV8_NUMBER_NEW(num) v8::Number::New(v8::Isolate::GetCurrent(), num)
#define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
#define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
#define SWIGV8_NULL() v8::Null(v8::Isolate::GetCurrent())
#endif
#if (SWIG_V8_VERSION < 0x031710)
#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(class);
#elif (SWIG_V8_VERSION < 0x031900)
#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), class);
#else
#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ.Reset(v8::Isolate::GetCurrent(), class);
#endif
/* ---------------------------------------------------------------------------
* Error handling
*
@ -8,8 +101,8 @@
#define SWIG_fail goto fail
#define SWIGV8_OVERLOAD false
void SWIG_V8_Raise(const char* msg) {
v8::ThrowException(v8::Exception::Error(v8::String::New(msg)));
static void SWIG_V8_Raise(const char *msg) {
SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
}
/*
@ -28,42 +121,25 @@ void SWIG_V8_Raise(const char* msg) {
class V8ErrorHandler {
public:
virtual ~V8ErrorHandler() {}
virtual void error(int code, const char* msg) {
virtual void error(int code, const char *msg) {
SWIG_V8_Raise(msg);
}
};
// this is used in usually
V8ErrorHandler SWIGV8_ErrorHandler;
static V8ErrorHandler SWIGV8_ErrorHandler;
// instances of this are used in overloaded functions
class OverloadErrorHandler: public V8ErrorHandler {
public:
virtual void error(int code, const char* msg) {
err = v8::Exception::Error(v8::String::New(msg));
virtual void error(int code, const char *msg) {
err = v8::Exception::Error(SWIGV8_STRING_NEW(msg));
if(code != SWIG_TypeError) {
v8::ThrowException(err);
SWIGV8_THROW_EXCEPTION(err);
}
}
v8::Handle<v8::Value> err;
};
// Note: these typedefs and defines are used to deal with v8 API changes since version 3.19.00
#if (SWIG_V8_VERSION < 0x031900)
typedef v8::Handle<v8::Value> SwigV8ReturnValue;
typedef v8::Arguments SwigV8Arguments;
typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) return scope.Close(val)
#define SWIGV8_RETURN_INFO(val, info) return scope.Close(val)
#else
typedef void SwigV8ReturnValue;
typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
#endif
/* ---------------------------------------------------------------------------
* Basic Proxy object
*
@ -76,20 +152,29 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
class SWIGV8_Proxy {
public:
SWIGV8_Proxy(): swigCMemOwn(false), swigCObject(0), info(0) {
v8::V8::AdjustAmountOfExternalAllocatedMemory(SWIGV8_AVG_OBJ_SIZE);
SWIGV8_ADJUST_MEMORY(SWIGV8_AVG_OBJ_SIZE);
};
~SWIGV8_Proxy() {
#if (SWIG_V8_VERSION < 0x031900 || SWIG_V8_VERSION >= 0x032100)
#if (SWIG_V8_VERSION < 0x031710)
handle.ClearWeak();
handle.Dispose();
#else
#elif (SWIG_V8_VERSION < 0x032100)
handle.ClearWeak(v8::Isolate::GetCurrent());
handle.Dispose(v8::Isolate::GetCurrent());
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
handle.ClearWeak();
handle.Dispose();
#else
handle.ClearWeak();
handle.Reset();
#endif
#if (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
handle.Clear();
v8::V8::AdjustAmountOfExternalAllocatedMemory(-SWIGV8_AVG_OBJ_SIZE);
#endif
SWIGV8_ADJUST_MEMORY(-SWIGV8_AVG_OBJ_SIZE);
}
bool swigCMemOwn;
@ -102,21 +187,25 @@ class SWIGV8_ClientData {
public:
v8::Persistent<v8::FunctionTemplate> class_templ;
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
void (*dtor) (v8::Persistent< v8::Value> object, void *parameter);
#else
#elif (SWIG_V8_VERSION < 0x031900)
void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Value> object, void *parameter);
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy);
#else
void (*dtor) (const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data);
#endif
};
v8::Persistent<v8::FunctionTemplate> SWIGV8_SWIGTYPE_Proxy_class_templ;
static v8::Persistent<v8::FunctionTemplate> SWIGV8_SWIGTYPE_Proxy_class_templ;
int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void** ptr, swig_type_info *info, int flags) {
v8::HandleScope scope;
static int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void **ptr, swig_type_info *info, int flags) {
SWIGV8_HANDLESCOPE();
if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031511)
v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
#else
@ -143,20 +232,24 @@ int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void** ptr, swig_t
return SWIG_OK;
}
#if (SWIG_V8_VERSION < 0x031900)
void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter)
#else
void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy)
#endif
{
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
static void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter) {
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
#elif (SWIG_V8_VERSION < 0x031900)
static void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Value > object, void *parameter) {
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
static void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy) {
#else
static void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
SWIGV8_Proxy *proxy = data.GetParameter();
#endif
delete proxy;
}
int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {
static int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void **ptr) {
if(!valRef->IsObject()) {
return SWIG_TypeError;
}
@ -164,7 +257,7 @@ int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {
if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031511)
v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
#else
@ -180,46 +273,66 @@ int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {
return SWIG_OK;
}
void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void* ptr, swig_type_info *info, int flags) {
SWIGV8_Proxy* cdata = new SWIGV8_Proxy();
static void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void *ptr, swig_type_info *info, int flags) {
SWIGV8_Proxy *cdata = new SWIGV8_Proxy();
cdata->swigCObject = ptr;
cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
cdata->info = info;
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031511)
obj->SetPointerInInternalField(0, cdata);
cdata->handle = v8::Persistent<v8::Object>::New(obj);
#else
obj->SetAlignedPointerInInternalField(0, cdata);
#endif
#if (SWIG_V8_VERSION < 0x031710)
cdata->handle = v8::Persistent<v8::Object>::New(obj);
#elif (SWIG_V8_VERSION < 0x031900)
cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
#else
cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
#endif
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
// clientdata must be set for owned data as we need to register the dtor
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
} else {
cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
}
cdata->handle.MarkIndependent();
#else
#elif (SWIG_V8_VERSION < 0x031918)
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
} else {
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, SWIGV8_Proxy_DefaultDtor);
}
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
} else {
cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
}
#else
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
cdata->handle.SetWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
} else {
cdata->handle.SetWeak(cdata, SWIGV8_Proxy_DefaultDtor);
}
#endif
#if (SWIG_V8_VERSION < 0x032100)
#if (SWIG_V8_VERSION < 0x031710)
cdata->handle.MarkIndependent();
#elif (SWIG_V8_VERSION < 0x032100)
cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
#else
cdata->handle.MarkIndependent();
#endif
#endif
}
int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void** ptr, swig_type_info *info, int flags) {
v8::HandleScope scope;
static int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void **ptr, swig_type_info *info, int flags) {
SWIGV8_HANDLESCOPE();
/* special case: JavaScript null => C NULL pointer */
if(valRef->IsNull()) {
*ptr=0;
@ -232,34 +345,41 @@ int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void** ptr, swig_type_info
return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags);
}
v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
v8::HandleScope scope;
static v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
SWIGV8_HANDLESCOPE_ESC();
v8::Handle<v8::FunctionTemplate> class_templ;
if (ptr == NULL) {
return scope.Close(v8::Null());
#if (SWIG_V8_VERSION < 0x031903)
SWIGV8_ESCAPE(SWIGV8_NULL());
#else
v8::Local<v8::Primitive> result = SWIGV8_NULL();
SWIGV8_ESCAPE(result);
#endif
}
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031903)
if(info->clientdata != 0) {
class_templ = ((SWIGV8_ClientData*) info->clientdata)->class_templ;
} else {
class_templ = SWIGV8_SWIGTYPE_Proxy_class_templ;
}
#else
v8::Isolate *iso = v8::Isolate::GetCurrent();
v8::Isolate *isolate = v8::Isolate::GetCurrent();
if(info->clientdata != 0) {
class_templ = v8::Handle<v8::FunctionTemplate>::New(iso, ((SWIGV8_ClientData*) info->clientdata)->class_templ);
class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, ((SWIGV8_ClientData*) info->clientdata)->class_templ);
} else {
class_templ = v8::Handle<v8::FunctionTemplate>::New(iso, SWIGV8_SWIGTYPE_Proxy_class_templ);
class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, SWIGV8_SWIGTYPE_Proxy_class_templ);
}
#endif
v8::Handle<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
// v8::Handle<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
v8::Local<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
SWIGV8_SetPrivateData(result, ptr, info, flags);
return scope.Close(result);
SWIGV8_ESCAPE(result);
}
#define SWIG_ConvertPtr(obj, ptr, info, flags) SWIG_V8_ConvertPtr(obj, ptr, info, flags)
@ -273,12 +393,9 @@ v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int
#define SWIG_GetInstancePtr(obj, ptr) SWIG_V8_GetInstancePtr(obj, ptr)
#if (SWIG_V8_VERSION < 0x031900)
v8::Handle<v8::Value> _SWIGV8_wrap_equals(const v8::Arguments &args) {
#else
void _SWIGV8_wrap_equals(const v8::FunctionCallbackInfo<v8::Value>& args) {
#endif
v8::HandleScope scope;
static SwigV8ReturnValue _SWIGV8_wrap_equals(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult;
void *arg1 = (void *) 0 ;
void *arg2 = (void *) 0 ;
@ -298,20 +415,17 @@ void _SWIGV8_wrap_equals(const v8::FunctionCallbackInfo<v8::Value>& args) {
}
result = (bool)(arg1 == arg2);
jsresult = v8::Boolean::New(result);
jsresult = SWIGV8_BOOLEAN_NEW(result);
SWIGV8_RETURN(jsresult);
goto fail;
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
#if (SWIG_V8_VERSION < 0x031900)
v8::Handle<v8::Value> _wrap_getCPtr(const v8::Arguments &args) {
#else
void _wrap_getCPtr(const v8::FunctionCallbackInfo<v8::Value>& args) {
#endif
v8::HandleScope scope;
static SwigV8ReturnValue _wrap_getCPtr(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult;
void *arg1 = (void *) 0 ;
long result;
@ -323,12 +437,12 @@ void _wrap_getCPtr(const v8::FunctionCallbackInfo<v8::Value>& args) {
}
result = (long)arg1;
jsresult = v8::Number::New(result);
jsresult = SWIGV8_NUMBER_NEW(result);
SWIGV8_RETURN(jsresult);
goto fail;
fail:
SWIGV8_RETURN(v8::Undefined());
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
/* ---------------------------------------------------------------------------
@ -343,7 +457,7 @@ public:
~SwigV8PackedData() {
};
void* data;
void *data;
size_t size;
swig_type_info *type;
@ -352,22 +466,24 @@ public:
SWIGRUNTIMEINLINE
int SwigV8Packed_Check(v8::Handle<v8::Value> valRef) {
v8::HandleScope scope;
SWIGV8_HANDLESCOPE();
v8::Handle<v8::Object> objRef = valRef->ToObject();
if(objRef->InternalFieldCount() < 1) return false;
v8::Handle<v8::Value> flag = objRef->GetHiddenValue(v8::String::New("__swig__packed_data__"));
v8::Handle<v8::Value> flag = objRef->GetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"));
return (flag->IsBoolean() && flag->BooleanValue());
}
SWIGRUNTIME
swig_type_info* SwigV8Packed_UnpackData(v8::Handle<v8::Value> valRef, void *ptr, size_t size) {
swig_type_info *SwigV8Packed_UnpackData(v8::Handle<v8::Value> valRef, void *ptr, size_t size) {
if (SwigV8Packed_Check(valRef)) {
v8::HandleScope scope;
SWIGV8_HANDLESCOPE();
SwigV8PackedData *sobj;
v8::Handle<v8::Object> objRef = valRef->ToObject();
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031511)
v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
sobj = static_cast<SwigV8PackedData*>(v8::External::Unwrap(cdataRef));
#else
@ -395,57 +511,82 @@ int SWIGV8_ConvertPacked(v8::Handle<v8::Value> valRef, void *ptr, size_t sz, swi
return SWIG_OK;
}
#if (SWIG_V8_VERSION < 0x031900)
void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter)
{
#if (SWIG_V8_VERSION < 0x031710)
static void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) {
SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
#elif (SWIG_V8_VERSION < 0x031900)
static void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
static void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SwigV8PackedData *cdata) {
#else
void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SwigV8PackedData *cdata)
{
static void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Object, SwigV8PackedData> &data) {
v8::Local<v8::Object> object = data.GetValue();
SwigV8PackedData *cdata = data.GetParameter();
#endif
delete cdata;
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
object.Clear();
object.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
object.Clear();
object.Dispose(isolate);
#elif (SWIG_V8_VERSION < 0x032100)
object->Dispose(isolate);
#else
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
object->Dispose();
#else
object.Clear();
#endif
}
SWIGRUNTIME
v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_info *type) {
v8::HandleScope scope;
SWIGV8_HANDLESCOPE_ESC();
SwigV8PackedData* cdata = new SwigV8PackedData(data, size, type);
v8::Handle<v8::Object> obj = v8::Object::New();
SwigV8PackedData *cdata = new SwigV8PackedData(data, size, type);
// v8::Handle<v8::Object> obj = SWIGV8_OBJECT_NEW();
v8::Local<v8::Object> obj = SWIGV8_OBJECT_NEW();
obj->SetHiddenValue(v8::String::New("__swig__packed_data__"), v8::Boolean::New(true));
obj->SetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"), SWIGV8_BOOLEAN_NEW(true));
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031511)
obj->SetPointerInInternalField(0, cdata);
cdata->handle = v8::Persistent<v8::Object>::New(obj);
#else
obj->SetAlignedPointerInInternalField(0, cdata);
#endif
#if (SWIG_V8_VERSION < 0x031710)
cdata->handle = v8::Persistent<v8::Object>::New(obj);
#elif (SWIG_V8_VERSION < 0x031900)
cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
#else
cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
#endif
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
cdata->handle.MarkIndependent();
#else
#elif (SWIG_V8_VERSION < 0x031918)
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete);
# if (SWIG_V8_VERSION < 0x032100)
cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
# else
cdata->handle.MarkIndependent();
# endif
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
#else
cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete);
// v8::V8::SetWeak(&cdata->handle, cdata, _wrap_SwigV8PackedData_delete);
#endif
return scope.Close(obj);
#if (SWIG_V8_VERSION < 0x031710)
cdata->handle.MarkIndependent();
#elif (SWIG_V8_VERSION < 0x032100)
cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
#else
cdata->handle.MarkIndependent();
#endif
SWIGV8_ESCAPE(obj);
}
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIGV8_ConvertPacked(obj, ptr, sz, ty)
@ -458,13 +599,23 @@ v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_inf
* ---------------------------------------------------------------------------*/
SWIGRUNTIME
#if (SWIG_V8_VERSION < 0x031903)
v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Handle<v8::Value> result, v8::Handle<v8::Value> obj) {
v8::HandleScope scope;
#else
v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Local<v8::Value> result, v8::Handle<v8::Value> obj) {
#endif
SWIGV8_HANDLESCOPE_ESC();
if (result->IsUndefined()) {
result = v8::Array::New();
result = SWIGV8_ARRAY_NEW();
}
#if (SWIG_V8_VERSION < 0x031903)
v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(result);
#else
v8::Local<v8::Array> arr = v8::Local<v8::Array>::Cast(result);
#endif
arr->Set(arr->Length(), obj);
return scope.Close(arr);
SWIGV8_ESCAPE(arr);
}

6
Lib/javascript/v8/javascriptstrings.swg
View file

@ -47,13 +47,13 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
if (carray) {
if (size > INT_MAX) {
// TODO: handle extra long strings
return v8::Undefined();
return SWIGV8_UNDEFINED();
} else {
v8::Handle<v8::String> js_str = v8::String::New(carray, size);
v8::Handle<v8::String> js_str = SWIGV8_STRING_NEW2(carray, size);
return js_str;
}
} else {
return v8::Undefined();
return SWIGV8_UNDEFINED();
}
}
}

2
Lib/javascript/v8/javascripttypemaps.swg
View file

@ -26,7 +26,7 @@
/* Javascript types */
#define SWIG_Object v8::Handle<v8::Value>
#define VOID_Object v8::Undefined()
#define VOID_Object SWIGV8_UNDEFINED()
/* Overload of the output/constant/exception/dirout handling */

9
Tools/javascript/Makefile.in
View file

@ -35,6 +35,13 @@ JSCENABLED = @JSCENABLED@
srcdir = @srcdir@
ifneq (, $(V8_VERSION))
JSV8_VERSION=$(V8_VERSION)
else
JSV8_VERSION=0x031110
endif
# Regenerate Makefile if Makefile.in or config.status have changed.
Makefile: $(srcdir)/Makefile.in ../../config.status
cd ../.. && $(SHELL) ./config.status Tools/javascript/Makefile
@ -42,7 +49,7 @@ Makefile: $(srcdir)/Makefile.in ../../config.status
# These settings are provided by 'configure' (see '/configure.in')
ifeq (1, $(JSV8ENABLED))
JS_INTERPRETER_SRC_V8 = v8_shell.cxx
JS_INTERPRETER_ENABLE_V8 = -DENABLE_V8
JS_INTERPRETER_ENABLE_V8 = -DENABLE_V8 -DSWIG_V8_VERSION=$(JSV8_VERSION) -DV8_DEPRECATION_WARNINGS
endif
ifeq (1, $(JSCENABLED))

257
Tools/javascript/v8_shell.cxx
View file

@ -11,6 +11,60 @@
typedef int (*V8ExtensionInitializer) (v8::Handle<v8::Object> module);
// Note: these typedefs and defines are used to deal with v8 API changes since version 3.19.00
#if (SWIG_V8_VERSION < 0x031903)
typedef v8::Handle<v8::Value> SwigV8ReturnValue;
typedef v8::Arguments SwigV8Arguments;
typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) return scope.Close(val)
#define SWIGV8_RETURN_INFO(val, info) return scope.Close(val)
#else
typedef void SwigV8ReturnValue;
typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
#endif
#if (SWIG_V8_VERSION < 0x032117)
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope
#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope
#define SWIGV8_ESCAPE(val) return scope.Close(val)
#elif (SWIG_V8_VERSION < 0x032318)
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_ESCAPE(val) return scope.Close(val)
#else
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_ESCAPE(val) return scope.Escape(val)
#endif
#if (SWIG_V8_VERSION < 0x032318)
#define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
#define SWIGV8_STRING_NEW(str) v8::String::New(str)
#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(func)
#define SWIGV8_OBJECT_NEW() v8::Object::New()
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
#define SWIGV8_UNDEFINED() v8::Undefined()
#else
#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
#define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
#define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
#endif
#if (SWIG_V8_VERSION < 0x031900)
typedef v8::Persistent<v8::Context> SwigV8Context;
#else
typedef v8::Local<v8::Context> SwigV8Context;
#endif
class V8Shell: public JSShell {
public:
@ -18,7 +72,7 @@ public:
virtual ~V8Shell();
virtual bool RunScript(const std::string& scriptPath);
virtual bool RunScript(const std::string &scriptPath);
virtual bool RunShell();
@ -27,33 +81,28 @@ protected:
virtual bool InitializeEngine();
virtual bool ExecuteScript(const std::string& source, const std::string& scriptPath);
virtual bool ExecuteScript(const std::string &source, const std::string &scriptPath);
virtual bool DisposeEngine();
private:
v8::Handle<v8::Value> Import(const std::string& moduleName);
v8::Handle<v8::Value> Import(const std::string &moduleName);
v8::Persistent<v8::Context> CreateShellContext();
SwigV8Context CreateShellContext();
void ReportException(v8::TryCatch* handler);
void ReportException(v8::TryCatch *handler);
static v8::Handle<v8::Value> Print(const v8::Arguments& args);
static SwigV8ReturnValue Print(const SwigV8Arguments &args);
static v8::Handle<v8::Value> Require(const v8::Arguments& args);
static SwigV8ReturnValue Require(const SwigV8Arguments &args);
static v8::Handle<v8::Value> Quit(const v8::Arguments& args);
static SwigV8ReturnValue Quit(const SwigV8Arguments &args);
static v8::Handle<v8::Value> Version(const v8::Arguments& args);
static SwigV8ReturnValue Version(const SwigV8Arguments &args);
static const char* ToCString(const v8::String::Utf8Value& value);
static const char* ToCString(const v8::String::Utf8Value &value);
virtual bool _ExecuteScript(const std::string& source, const std::string& scriptPath);
protected:
v8::Persistent<v8::Context> context;
};
#ifdef __GNUC__
@ -63,59 +112,61 @@ protected:
#error "implement dll loading"
#endif
V8Shell::V8Shell(){}
V8Shell::V8Shell() {}
V8Shell::~V8Shell() {}
bool V8Shell::RunScript(const std::string& scriptPath) {
bool V8Shell::RunScript(const std::string &scriptPath) {
std::string source = ReadFile(scriptPath);
if (!context.IsEmpty()) {
context.Dispose();
}
v8::Isolate *isolate = v8::Isolate::New();
v8::Isolate::Scope isolate_scope(isolate);
SWIGV8_HANDLESCOPE();
SwigV8Context context = CreateShellContext();
std::string source = ReadFile(scriptPath);
context = CreateShellContext();
if (context.IsEmpty()) {
printf("Could not create context.\n");
return false;
}
context->Enter();
bool success = _ExecuteScript(source, scriptPath);
context->Exit();
context.Dispose();
v8::V8::Dispose();
return true;
}
bool V8Shell::_ExecuteScript(const std::string& source, const std::string& scriptPath) {
v8::HandleScope scope;
context->Enter();
// Store a pointer to this shell for later use
v8::Handle<v8::Object> global = context->Global();
v8::Local<v8::External> __shell__ = v8::External::New((void*) (long) this);
global->SetHiddenValue(v8::String::New("__shell__"), __shell__);
v8::Local<v8::External> __shell__ = SWIGV8_EXTERNAL_NEW((void*) (long) this);
global->SetHiddenValue(SWIGV8_STRING_NEW("__shell__"), __shell__);
// Node.js compatibility: make `print` available as `console.log()`
ExecuteScript("var console = {}; console.log = print;", "<console>");
if(!ExecuteScript(source, scriptPath)) {
return false;
}
bool success = ExecuteScript(source, scriptPath);
return true;
}
// Cleanup
bool V8Shell::RunShell() {
context->Exit();
if (!context.IsEmpty()) {
context.Dispose();
}
#if (SWIG_V8_VERSION < 0x031710)
context.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
context.Dispose(v8::Isolate::GetCurrent());
#else
// context.Dispose();
#endif
// v8::V8::Dispose();
return success;
}
bool V8Shell::RunShell() {
SWIGV8_HANDLESCOPE();
SwigV8Context context = CreateShellContext();
context = CreateShellContext();
if (context.IsEmpty()) {
printf("Could not create context.\n");
return false;
@ -131,16 +182,26 @@ bool V8Shell::RunShell() {
while (true) {
char buffer[kBufferSize];
printf("> ");
char* str = fgets(buffer, kBufferSize, stdin);
char *str = fgets(buffer, kBufferSize, stdin);
if (str == NULL) break;
std::string source(str);
ExecuteScript(source, "(shell)");
}
printf("\n");
// Cleanup
context->Exit();
context.Dispose();
v8::V8::Dispose();
#if (SWIG_V8_VERSION < 0x031710)
context.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
context.Dispose(v8::Isolate::GetCurrent());
#else
// context.Dispose();
#endif
// v8::V8::Dispose();
return true;
}
@ -150,10 +211,11 @@ bool V8Shell::InitializeEngine() {
return true;
}
bool V8Shell::ExecuteScript(const std::string& source, const std::string& name) {
v8::HandleScope handle_scope;
bool V8Shell::ExecuteScript(const std::string &source, const std::string &name) {
SWIGV8_HANDLESCOPE();
v8::TryCatch try_catch;
v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(source.c_str()), v8::String::New(name.c_str()));
v8::Handle<v8::Script> script = v8::Script::Compile(SWIGV8_STRING_NEW(source.c_str()), SWIGV8_STRING_NEW(name.c_str()));
// Stop if script is empty
if (script.IsEmpty()) {
@ -177,26 +239,28 @@ bool V8Shell::DisposeEngine() {
return true;
}
v8::Persistent<v8::Context> V8Shell::CreateShellContext() {
v8::HandleScope scope;
SwigV8Context V8Shell::CreateShellContext() {
// Create a template for the global object.
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
// Bind global functions
global->Set(v8::String::New("print"), v8::FunctionTemplate::New(V8Shell::Print));
global->Set(v8::String::New("quit"), v8::FunctionTemplate::New(V8Shell::Quit));
global->Set(v8::String::New("require"), v8::FunctionTemplate::New(V8Shell::Require));
global->Set(v8::String::New("version"), v8::FunctionTemplate::New(V8Shell::Version));
global->Set(SWIGV8_STRING_NEW("print"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Print));
global->Set(SWIGV8_STRING_NEW("quit"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Quit));
global->Set(SWIGV8_STRING_NEW("require"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Require));
global->Set(SWIGV8_STRING_NEW("version"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Version));
v8::Persistent<v8::Context> _context = v8::Context::New(NULL, global);
return _context;
#if (SWIG_V8_VERSION < 0x031900)
SwigV8Context context = v8::Context::New(NULL, global);
return context;
#else
SwigV8Context context = v8::Context::New(v8::Isolate::GetCurrent(), NULL, global);
return context;
#endif
}
v8::Handle<v8::Value> V8Shell::Import(const std::string& module_path)
v8::Handle<v8::Value> V8Shell::Import(const std::string &module_path)
{
v8::HandleScope scope;
SWIGV8_HANDLESCOPE_ESC();
HANDLE library;
std::string module_name = LoadModule(module_path, &library);
@ -207,69 +271,80 @@ v8::Handle<v8::Value> V8Shell::Import(const std::string& module_path)
if(init_function == 0) {
printf("Could not find initializer function.");
return v8::Undefined();
return SWIGV8_UNDEFINED();
}
v8::Local<v8::Object> module = v8::Object::New();
v8::Local<v8::Object> module = SWIGV8_OBJECT_NEW();
init_function(module);
return scope.Close(module);
SWIGV8_ESCAPE(module);
}
v8::Handle<v8::Value> V8Shell::Print(const v8::Arguments& args) {
SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
bool first = true;
for (int i = 0; i < args.Length(); i++) {
v8::HandleScope handle_scope;
if (first) {
first = false;
} else {
printf(" ");
}
v8::String::Utf8Value str(args[i]);
const char* cstr = V8Shell::ToCString(str);
const char *cstr = V8Shell::ToCString(str);
printf("%s", cstr);
}
printf("\n");
fflush(stdout);
return v8::Undefined();
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
v8::Handle<v8::Value> V8Shell::Require(const v8::Arguments& args) {
v8::HandleScope scope;
SwigV8ReturnValue V8Shell::Require(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
if (args.Length() != 1) {
printf("Illegal arguments for `require`");
};
v8::String::Utf8Value str(args[0]);
const char* cstr = V8Shell::ToCString(str);
const char *cstr = V8Shell::ToCString(str);
std::string moduleName(cstr);
v8::Local<v8::Object> global = v8::Context::GetCurrent()->Global();
v8::Local<v8::Value> hidden = global->GetHiddenValue(v8::String::New("__shell__"));
v8::Local<v8::Object> global = SWIGV8_CURRENT_CONTEXT()->Global();
v8::Local<v8::Value> hidden = global->GetHiddenValue(SWIGV8_STRING_NEW("__shell__"));
v8::Local<v8::External> __shell__ = v8::Local<v8::External>::Cast(hidden);
V8Shell* _this = (V8Shell*) (long) __shell__->Value();
V8Shell *_this = (V8Shell *) (long) __shell__->Value();
v8::Handle<v8::Value> module = _this->Import(moduleName);
return scope.Close(module);
SWIGV8_RETURN(module);
}
v8::Handle<v8::Value> V8Shell::Quit(const v8::Arguments& args) {
SwigV8ReturnValue V8Shell::Quit(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
int exit_code = args[0]->Int32Value();
fflush(stdout);
fflush(stderr);
exit(exit_code);
return v8::Undefined();
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
v8::Handle<v8::Value> V8Shell::Version(const v8::Arguments& args) {
return v8::String::New(v8::V8::GetVersion());
SwigV8ReturnValue V8Shell::Version(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
SWIGV8_RETURN(SWIGV8_STRING_NEW(v8::V8::GetVersion()));
}
void V8Shell::ReportException(v8::TryCatch* try_catch) {
v8::HandleScope handle_scope;
void V8Shell::ReportException(v8::TryCatch *try_catch) {
SWIGV8_HANDLESCOPE();
v8::String::Utf8Value exception(try_catch->Exception());
const char* exception_string = V8Shell::ToCString(exception);
const char *exception_string = V8Shell::ToCString(exception);
v8::Handle<v8::Message> message = try_catch->Message();
if (message.IsEmpty()) {
// V8 didn't provide any extra information about this error; just
@ -278,12 +353,12 @@ void V8Shell::ReportException(v8::TryCatch* try_catch) {
} else {
// Print (filename):(line number): (message).
v8::String::Utf8Value filename(message->GetScriptResourceName());
const char* filename_string = V8Shell::ToCString(filename);
const char *filename_string = V8Shell::ToCString(filename);
int linenum = message->GetLineNumber();
printf("%s:%i: %s\n", filename_string, linenum, exception_string);
// Print line of source code.
v8::String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceline_string = V8Shell::ToCString(sourceline);
const char *sourceline_string = V8Shell::ToCString(sourceline);
printf("%s\n", sourceline_string);
// Print wavy underline (GetUnderline is deprecated).
int start = message->GetStartColumn();
@ -297,17 +372,17 @@ void V8Shell::ReportException(v8::TryCatch* try_catch) {
printf("\n");
v8::String::Utf8Value stack_trace(try_catch->StackTrace());
if (stack_trace.length() > 0) {
const char* stack_trace_string = V8Shell::ToCString(stack_trace);
const char *stack_trace_string = V8Shell::ToCString(stack_trace);
printf("%s\n", stack_trace_string);
}
}
}
// Extracts a C string from a V8 Utf8Value.
const char* V8Shell::ToCString(const v8::String::Utf8Value& value) {
const char *V8Shell::ToCString(const v8::String::Utf8Value &value) {
return *value ? *value : "<string conversion failed>";
}
JSShell* V8Shell_Create() {
JSShell *V8Shell_Create() {
return new V8Shell();
}

8
configure.ac
View file

@ -1224,7 +1224,7 @@ else
# check for include files
AC_MSG_CHECKING(for V8 Javascript v8.h)
AC_ARG_WITH(jsv8inc, [ --with-v8inc=path Set location of Javascript v8 include directory], [JSV8INCDIR="$withval"])
AC_ARG_WITH(jsv8inc, [ --with-jsv8inc=path Set location of Javascript v8 include directory], [JSV8INCDIR="$withval"])
# if not include dir is specified we try to find
if test -z "$JSV8INCDIR"; then
@ -1257,11 +1257,11 @@ else
# check for V8 library
AC_MSG_CHECKING(for V8 Javascript library)
AC_ARG_WITH(jsv8lib,[ --with-v8lib=path Set location of V8 Javascript library directory],[JSV8LIBDIR="$withval"], [JSV8LIB=])
AC_ARG_WITH(jsv8lib,[ --with-jsv8lib=path Set location of V8 Javascript library directory],[JSV8LIBDIR="$withval"], [JSV8LIB=])
v8libdirs="$JSV8LIBDIR /usr/lib64/ /usr/local/lib64/ /usr/lib/ /usr/local/lib/"
for d in $v8libdirs ; do
if test -r $d/libv8.so; then
if test -r $d/libv8$JSSO; then
JSV8LIBDIR=$d
JSV8LIB="-L$d -lv8"
break
@ -1280,7 +1280,7 @@ else
# linking options
case $host in
*-*-darwin*)
JSV8DYNAMICLINKING="" # TODO: add osx configuration
JSV8DYNAMICLINKING="$JSV8LIB"
;;
*-*-linux*)
JSV8DYNAMICLINKING="$JSV8LIB"