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 Issue an error for unknown SWIG preprocessor directives, rather
than quietly ignoring them. Reported by jrhelsey in issue#217. 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 2014-08-15: talby
[Perl] Include guard fix for nested modules from Anthony Heading (SF Patch #350). [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> <pre>
$ swig -c++ -javascript -jsc example.i</pre> $ swig -c++ -javascript -jsc example.i</pre>
</div> </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>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> <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"> <div class="code">
@ -129,6 +135,11 @@ $ make check-javascript-examples ENGINE=jsc</pre>
<pre> <pre>
$ make check-javascript-test-suite ENGINE=jsc</pre> $ make check-javascript-test-suite ENGINE=jsc</pre>
</div> </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> <H3><a name="Javascript_known_issues"></a>26.2.3 Known Issues</H3>
@ -446,7 +457,7 @@ var x = 42;
var y = 105; var y = 105;
var g = example.gcd(x,y); var g = example.gcd(x,y);
// Accessing the globak variable // Accessing the global variable
var f = example.Foo; var f = example.Foo;
example.Foo = 3.1415926;</pre> example.Foo = 3.1415926;</pre>
</div> </div>

8
Examples/javascript/example.mk
View file

@ -7,12 +7,18 @@ else
JSENGINE=node JSENGINE=node
endif endif
ifneq (, $(V8_VERSION))
JSV8_VERSION=$(V8_VERSION)
else
JSV8_VERSION=0x031110
endif
EXAMPLES_TOP=../.. EXAMPLES_TOP=../..
SWIG_TOP=../../.. SWIG_TOP=../../..
SWIG = $(SWIG_TOP)/preinst-swig SWIG = $(SWIG_TOP)/preinst-swig
TARGET = example TARGET = example
INTERFACE = example.i INTERFACE = example.i
SWIGOPT=-$(JSENGINE) SWIGOPT=-$(JSENGINE) -DV8_VERSION=$(JSV8_VERSION)
check: build check: build
$(MAKE) -f $(EXAMPLES_TOP)/Makefile SRCDIR='$(SRCDIR)' JSENGINE='$(JSENGINE)' TARGET='$(TARGET)' javascript_run $(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); iv = new example.vecint(100);
dv = new example.vecdouble(1000); dv = new example.vecdouble(1000);
for(i=0;i<=100;i++) for(i=0;i<100;i++)
iv.setitem(i,2*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)); dv.setitem(i, 1.0/(i+1));
sum = 0; sum = 0;
for(i=0;i<=100;i++) for(i=0;i<100;i++)
sum = sum + iv.getitem(i); sum = sum + iv.getitem(i);
console.log(sum); console.log(sum);
sum = 0.0; sum = 0.0;
for(i=0;i<=1000;i++) for(i=0;i<1000;i++)
sum = sum + dv.getitem(i); sum = sum + dv.getitem(i);
console.log(sum); console.log(sum);

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

@ -19,8 +19,16 @@ else
JSENGINE=node JSENGINE=node
endif endif
ifneq (, $(V8_VERSION))
JSV8_VERSION=$(V8_VERSION)
else
JSV8_VERSION=0x031110
endif
include $(srcdir)/../common.mk include $(srcdir)/../common.mk
SWIGOPT += -DV8_VERSION=$(JSV8_VERSION)
_setup = \ _setup = \
if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
echo "$(ACTION)ing $(LANGUAGE) ($(JSENGINE)) testcase $* (with run test)" ; \ 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 // For Javascript V8 we can not use '0' for out typemaps
#if defined(SWIG_JAVASCRIPT_V8) #if defined(SWIG_JAVASCRIPT_V8)
%header %{ %header %{
#define OUT_NULL_VALUE v8::Null() #define OUT_NULL_VALUE SWIGV8_NULL()
%} %}
#else #else
%header %{ %header %{

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

@ -8,8 +8,9 @@
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("js_ctor", "templates") %{ %fragment("js_ctor", "templates") %{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) { static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
v8::Handle<v8::Object> self = args.Holder(); v8::Handle<v8::Object> self = args.Holder();
$jslocals $jslocals
if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper."); 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; goto fail;
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
%} %}
@ -31,10 +32,11 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment ("js_veto_ctor", "templates") %fragment ("js_veto_ctor", "templates")
%{ %{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) { static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated"); 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") %fragment ("js_ctor_dispatcher", "templates")
%{ %{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) { static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
OverloadErrorHandler errorHandler; OverloadErrorHandler errorHandler;
v8::Handle<v8::Value> self; 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"); SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of $jsmangledname");
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
%} %}
@ -71,8 +74,9 @@ fail:
* - $jsmangledtype: mangled type of class * - $jsmangledtype: mangled type of class
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("js_overloaded_ctor", "templates") %{ %fragment("js_overloaded_ctor", "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::Object> self = args.Holder(); v8::Handle<v8::Object> self = args.Holder();
$jslocals $jslocals
if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper."); 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; goto fail;
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
%} %}
@ -98,10 +102,10 @@ fail:
%{ %{
if(args.Length() == $jsargcount) { if(args.Length() == $jsargcount) {
errorHandler.err.Clear(); errorHandler.err.Clear();
#if SWIG_V8_VERSION < 0x031900 #if (SWIG_V8_VERSION < 0x031903)
self = $jswrapper(args, errorHandler); self = $jswrapper(args, errorHandler);
if(errorHandler.err.IsEmpty()) { if(errorHandler.err.IsEmpty()) {
return scope.Close(self); SWIGV8_ESCAPE(self);
} }
#else #else
$jswrapper(args, errorHandler); $jswrapper(args, errorHandler);
@ -120,13 +124,18 @@ fail:
%fragment ("js_dtor", "templates") %fragment ("js_dtor", "templates")
%{ %{
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031710)
void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) static void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) {
{
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(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 #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 #endif
if(proxy->swigCMemOwn && proxy->swigCObject) { if(proxy->swigCMemOwn && proxy->swigCObject) {
@ -138,8 +147,11 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
delete proxy; delete proxy;
object.Clear(); object.Clear();
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
object.Dispose(); object.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
object.Dispose(isolate);
#elif (SWIG_V8_VERSION < 0x032100) #elif (SWIG_V8_VERSION < 0x032100)
object->Dispose(isolate); object->Dispose(isolate);
#else #else
@ -156,26 +168,36 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment ("js_dtoroverride", "templates") %fragment ("js_dtoroverride", "templates")
%{ %{
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031710)
void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) static void $jswrapper(v8::Persistent<v8::Value> object, void *parameter) {
{
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(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 #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 #endif
if(proxy->swigCMemOwn && proxy->swigCObject) { if(proxy->swigCMemOwn && proxy->swigCObject) {
$jstype arg1 = ($jstype)proxy->swigCObject; $jstype arg1 = ($jstype)proxy->swigCObject;
${destructor_action} ${destructor_action}
} }
delete proxy; delete proxy;
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031710)
object.Dispose(); object.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
object.Dispose(isolate);
#elif (SWIG_V8_VERSION < 0x032100) #elif (SWIG_V8_VERSION < 0x032100)
object->Dispose(isolate); object->Dispose(isolate);
#else #elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
object->Dispose(); object->Dispose();
#else
object.Clear();
#endif #endif
} }
%} %}
@ -188,8 +210,9 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("js_getter", "templates") %fragment("js_getter", "templates")
%{ %{
SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo& info) { static SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult; v8::Handle<v8::Value> jsresult;
$jslocals $jslocals
$jscode $jscode
@ -197,7 +220,7 @@ SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8Propert
goto fail; goto fail;
fail: fail:
SWIGV8_RETURN_INFO(v8::Undefined(), info); SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
} }
%} %}
@ -209,9 +232,10 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("js_setter", "templates") %fragment("js_setter", "templates")
%{ %{
void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value, static void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value,
const SwigV8PropertyCallbackInfoVoid& info) { const SwigV8PropertyCallbackInfoVoid &info) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
$jslocals $jslocals
$jscode $jscode
goto fail; goto fail;
@ -228,8 +252,9 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("js_function", "templates") %fragment("js_function", "templates")
%{ %{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) { static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult; v8::Handle<v8::Value> jsresult;
$jslocals $jslocals
if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper."); 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; goto fail;
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
%} %}
@ -252,8 +277,9 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("js_function_dispatcher", "templates") %fragment("js_function_dispatcher", "templates")
%{ %{
SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) { static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
v8::Handle<v8::Value> jsresult; v8::Handle<v8::Value> jsresult;
OverloadErrorHandler errorHandler; OverloadErrorHandler errorHandler;
$jscode $jscode
@ -262,7 +288,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
goto fail; goto fail;
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
%} %}
@ -274,9 +300,10 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment ("js_overloaded_function", "templates") %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; v8::Handle<v8::Value> jsresult;
$jslocals $jslocals
$jscode $jscode
@ -284,7 +311,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8
goto fail; goto fail;
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
%} %}
@ -299,10 +326,10 @@ fail:
if(args.Length() == $jsargcount) { if(args.Length() == $jsargcount) {
errorHandler.err.Clear(); errorHandler.err.Clear();
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031903)
jsresult = $jswrapper(args, errorHandler); jsresult = $jswrapper(args, errorHandler);
if(errorHandler.err.IsEmpty()) { if(errorHandler.err.IsEmpty()) {
return scope.Close(jsresult); SWIGV8_ESCAPE(jsresult);
} }
#else #else
$jswrapper(args, errorHandler); $jswrapper(args, errorHandler);
@ -330,12 +357,9 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("jsv8_define_class_template", "templates") %fragment("jsv8_define_class_template", "templates")
%{ %{
/* Name: $jsmangledname, Type: $jsmangledtype, Dtor: $jsdtor */
v8::Handle<v8::FunctionTemplate> $jsmangledname_class = SWIGV8_CreateClassTemplate("$jsmangledname"); v8::Handle<v8::FunctionTemplate> $jsmangledname_class = SWIGV8_CreateClassTemplate("$jsmangledname");
#if (SWIG_V8_VERSION < 0x031900) SWIGV8_SET_CLASS_TEMPL($jsmangledname_clientData.class_templ, $jsmangledname_class);
$jsmangledname_clientData.class_templ = v8::Persistent<v8::FunctionTemplate>::New($jsmangledname_class);
#else
$jsmangledname_clientData.class_templ.Reset(v8::Isolate::GetCurrent(), $jsmangledname_class);
#endif
$jsmangledname_clientData.dtor = $jsdtor; $jsmangledname_clientData.dtor = $jsdtor;
if (SWIGTYPE_$jsmangledtype->clientdata == 0) { if (SWIGTYPE_$jsmangledtype->clientdata == 0) {
SWIGTYPE_$jsmangledtype->clientdata = &$jsmangledname_clientData; 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 (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); $jsmangledname_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ);
#else #else
$jsmangledname_class->Inherit( $jsmangledname_class->Inherit(
v8::Handle<v8::FunctionTemplate>::New( v8::Local<v8::FunctionTemplate>::New(
v8::Isolate::GetCurrent(), v8::Isolate::GetCurrent(),
static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ) static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ)
); );
@ -379,6 +403,7 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("jsv8_create_class_instance", "templates") %fragment("jsv8_create_class_instance", "templates")
%{ %{
/* Class: $jsname ($jsmangledname) */
v8::Handle<v8::FunctionTemplate> $jsmangledname_class_0 = SWIGV8_CreateClassTemplate("$jsname"); v8::Handle<v8::FunctionTemplate> $jsmangledname_class_0 = SWIGV8_CreateClassTemplate("$jsname");
$jsmangledname_class_0->SetCallHandler($jsctor); $jsmangledname_class_0->SetCallHandler($jsctor);
$jsmangledname_class_0->Inherit($jsmangledname_class); $jsmangledname_class_0->Inherit($jsmangledname_class);
@ -394,7 +419,7 @@ fail:
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
%fragment("jsv8_register_class", "templates") %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") %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") %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> SWIGINTERNINLINE v8::Handle<v8::Value>
SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c) SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
{ {
v8::HandleScope scope; SWIGV8_HANDLESCOPE_ESC();
v8::Local<v8::Array> vals = v8::Array::New(2);
v8::Local<v8::Array> vals = SWIGV8_ARRAY_NEW(2);
vals->Set(0, SWIG_From(double)(Real(c))); vals->Set(0, SWIG_From(double)(Real(c)));
vals->Set(1, SWIG_From(double)(Imag(c))); vals->Set(1, SWIG_From(double)(Imag(c)));
return scope.Close(vals); SWIGV8_ESCAPE(vals);
} }
} }
%enddef %enddef
@ -33,7 +34,7 @@ SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
SWIGINTERN int SWIGINTERN int
SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val) SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
{ {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
if (o->IsArray()) { if (o->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o); 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 SWIGINTERN int
SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val) SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
{ {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
if (o->IsArray()) { if (o->IsArray()) {
v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o); 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) %{ %insert(runtime) %{
// Note: since 3.19 there are new CallBack types, since 03.21.9 the old ones have been removed // 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::InvocationCallback SwigV8FunctionCallback;
typedef v8::AccessorGetter SwigV8AccessorGetterCallback; typedef v8::AccessorGetter SwigV8AccessorGetterCallback;
typedef v8::AccessorSetter SwigV8AccessorSetterCallback; typedef v8::AccessorSetter SwigV8AccessorSetterCallback;
@ -17,20 +17,21 @@ typedef v8::PropertyCallbackInfo<void> SwigV8PropertyCallbackInfoVoid;
* Creates a class template for a class with specified initialization function. * Creates a class template for a class with specified initialization function.
*/ */
SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const char* symbol) { SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const char* symbol) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE_ESC();
v8::Local<v8::FunctionTemplate> class_templ = v8::FunctionTemplate::New();
class_templ->SetClassName(v8::String::NewSymbol(symbol)); 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(); v8::Handle<v8::ObjectTemplate> inst_templ = class_templ->InstanceTemplate();
inst_templ->SetInternalFieldCount(1); inst_templ->SetInternalFieldCount(1);
v8::Handle<v8::ObjectTemplate> equals_templ = class_templ->PrototypeTemplate(); 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(); 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, SWIGRUNTIME void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
SwigV8FunctionCallback _func) { SwigV8FunctionCallback _func) {
v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->PrototypeTemplate(); 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, SWIGRUNTIME void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) { SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->InstanceTemplate(); 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, SWIGRUNTIME void SWIGV8_AddStaticFunction(v8::Handle<v8::Object> obj, const char* symbol,
const SwigV8FunctionCallback& _func) { 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, SWIGRUNTIME void SWIGV8_AddStaticVariable(v8::Handle<v8::Object> obj, const char* symbol,
SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) { 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, 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 SWIGRUNTIME void
SWIG_V8_SetModule(void *, swig_module_info *swig_module) { SWIG_V8_SetModule(void *, swig_module_info *swig_module) {
v8::Local<v8::Object> global_obj = v8::Context::GetCurrent()->Global(); v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
v8::Local<v8::External> mod = v8::External::New(swig_module); v8::Local<v8::External> mod = SWIGV8_EXTERNAL_NEW(swig_module);
assert(!mod.IsEmpty()); 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 * SWIGRUNTIME swig_module_info *
SWIG_V8_GetModule(void *) { SWIG_V8_GetModule(void *) {
v8::Local<v8::Object> global_obj = v8::Context::GetCurrent()->Global(); v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(v8::String::New("swig_module_info_data")); v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"));
if (moduleinfo.IsEmpty()) 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)); SWIG_InitializeModule(static_cast<void *>(&exports));
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
v8::Handle<v8::Object> exports_obj = exports; 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") %fragment("js_initializer", "templates")
%{ %{
// a class template for creating proxies of undefined types // a class template for creating proxies of undefined types
#if (SWIG_V8_VERSION < 0x031900) SWIGV8_SET_CLASS_TEMPL(SWIGV8_SWIGTYPE_Proxy_class_templ, SWIGV8_CreateClassTemplate("SwigProxy"));
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
/* create objects for namespaces */ /* create objects for namespaces */
$jsv8nspaces $jsv8nspaces

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

@ -9,7 +9,7 @@ SWIGINTERNINLINE
v8::Handle<v8::Value> v8::Handle<v8::Value>
SWIG_From_dec(bool)(bool 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 SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(int)(int value) 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 SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(long)(long value) 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) v8::Handle<v8::Value> SWIG_From_dec(unsigned long)(unsigned long value)
{ {
return (value > LONG_MAX) ? 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 SWIGINTERNINLINE
v8::Handle<v8::Value> SWIG_From_dec(long long)(long long value) 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) v8::Handle<v8::Value> SWIG_From_dec(unsigned long long)(unsigned long long value)
{ {
return (value > LONG_MAX) ? 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 SWIGINTERN
v8::Handle<v8::Value> SWIG_From_dec(double) (double val) v8::Handle<v8::Value> SWIG_From_dec(double) (double val)
{ {
return v8::Number::New(val); return SWIGV8_NUMBER_NEW(val);
} }
} }

373
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 * Error handling
* *
@ -8,8 +101,8 @@
#define SWIG_fail goto fail #define SWIG_fail goto fail
#define SWIGV8_OVERLOAD false #define SWIGV8_OVERLOAD false
void SWIG_V8_Raise(const char* msg) { static void SWIG_V8_Raise(const char *msg) {
v8::ThrowException(v8::Exception::Error(v8::String::New(msg))); SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
} }
/* /*
@ -28,42 +121,25 @@ void SWIG_V8_Raise(const char* msg) {
class V8ErrorHandler { class V8ErrorHandler {
public: public:
virtual ~V8ErrorHandler() {} virtual ~V8ErrorHandler() {}
virtual void error(int code, const char* msg) { virtual void error(int code, const char *msg) {
SWIG_V8_Raise(msg); SWIG_V8_Raise(msg);
} }
}; };
// this is used in usually // this is used in usually
V8ErrorHandler SWIGV8_ErrorHandler; static V8ErrorHandler SWIGV8_ErrorHandler;
// instances of this are used in overloaded functions // instances of this are used in overloaded functions
class OverloadErrorHandler: public V8ErrorHandler { class OverloadErrorHandler: public V8ErrorHandler {
public: public:
virtual void error(int code, const char* msg) { virtual void error(int code, const char *msg) {
err = v8::Exception::Error(v8::String::New(msg)); err = v8::Exception::Error(SWIGV8_STRING_NEW(msg));
if(code != SWIG_TypeError) { if(code != SWIG_TypeError) {
v8::ThrowException(err); SWIGV8_THROW_EXCEPTION(err);
} }
} }
v8::Handle<v8::Value> 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 * Basic Proxy object
* *
@ -76,20 +152,29 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
class SWIGV8_Proxy { class SWIGV8_Proxy {
public: public:
SWIGV8_Proxy(): swigCMemOwn(false), swigCObject(0), info(0) { SWIGV8_Proxy(): swigCMemOwn(false), swigCObject(0), info(0) {
v8::V8::AdjustAmountOfExternalAllocatedMemory(SWIGV8_AVG_OBJ_SIZE); SWIGV8_ADJUST_MEMORY(SWIGV8_AVG_OBJ_SIZE);
}; };
~SWIGV8_Proxy() { ~SWIGV8_Proxy() {
#if (SWIG_V8_VERSION < 0x031900 || SWIG_V8_VERSION >= 0x032100) #if (SWIG_V8_VERSION < 0x031710)
handle.ClearWeak();
handle.Dispose();
#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.ClearWeak();
handle.Dispose(); handle.Dispose();
#else #else
handle.ClearWeak(v8::Isolate::GetCurrent()); handle.ClearWeak();
handle.Dispose(v8::Isolate::GetCurrent()); handle.Reset();
#endif #endif
#if (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
handle.Clear(); handle.Clear();
v8::V8::AdjustAmountOfExternalAllocatedMemory(-SWIGV8_AVG_OBJ_SIZE); #endif
SWIGV8_ADJUST_MEMORY(-SWIGV8_AVG_OBJ_SIZE);
} }
bool swigCMemOwn; bool swigCMemOwn;
@ -102,21 +187,25 @@ class SWIGV8_ClientData {
public: public:
v8::Persistent<v8::FunctionTemplate> class_templ; 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); 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); 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 #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) { static int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void **ptr, swig_type_info *info, int flags) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
if(objRef->InternalFieldCount() < 1) return SWIG_ERROR; 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); v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef)); SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
#else #else
@ -143,20 +232,24 @@ int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void** ptr, swig_t
return SWIG_OK; return SWIG_OK;
} }
#if (SWIG_V8_VERSION < 0x031900)
void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter) #if (SWIG_V8_VERSION < 0x031710)
#else static void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter) {
void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy)
#endif
{
#if (SWIG_V8_VERSION < 0x031900)
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(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 #endif
delete proxy; 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()) { if(!valRef->IsObject()) {
return SWIG_TypeError; 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(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031511)
v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0); v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef)); SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
#else #else
@ -180,46 +273,66 @@ int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {
return SWIG_OK; return SWIG_OK;
} }
void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void* ptr, swig_type_info *info, int flags) { static void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void *ptr, swig_type_info *info, int flags) {
SWIGV8_Proxy* cdata = new SWIGV8_Proxy(); SWIGV8_Proxy *cdata = new SWIGV8_Proxy();
cdata->swigCObject = ptr; cdata->swigCObject = ptr;
cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0; cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
cdata->info = info; cdata->info = info;
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031511)
obj->SetPointerInInternalField(0, cdata); obj->SetPointerInInternalField(0, cdata);
cdata->handle = v8::Persistent<v8::Object>::New(obj);
#else #else
obj->SetAlignedPointerInInternalField(0, cdata); 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); cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
#endif #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 // clientdata must be set for owned data as we need to register the dtor
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) { if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor); cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
} else { } else {
cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor); cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
} }
cdata->handle.MarkIndependent(); #elif (SWIG_V8_VERSION < 0x031918)
#else
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) { if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor); cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
} else { } else {
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, SWIGV8_Proxy_DefaultDtor); 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()); cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
#else #else
cdata->handle.MarkIndependent(); cdata->handle.MarkIndependent();
#endif #endif
#endif
} }
int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void** ptr, swig_type_info *info, int flags) { static int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void **ptr, swig_type_info *info, int flags) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
/* special case: JavaScript null => C NULL pointer */ /* special case: JavaScript null => C NULL pointer */
if(valRef->IsNull()) { if(valRef->IsNull()) {
*ptr=0; *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); return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags);
} }
v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) { static v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE_ESC();
v8::Handle<v8::FunctionTemplate> class_templ; v8::Handle<v8::FunctionTemplate> class_templ;
if (ptr == NULL) { 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) { if(info->clientdata != 0) {
class_templ = ((SWIGV8_ClientData*) info->clientdata)->class_templ; class_templ = ((SWIGV8_ClientData*) info->clientdata)->class_templ;
} else { } else {
class_templ = SWIGV8_SWIGTYPE_Proxy_class_templ; class_templ = SWIGV8_SWIGTYPE_Proxy_class_templ;
} }
#else #else
v8::Isolate *iso = v8::Isolate::GetCurrent(); v8::Isolate *isolate = v8::Isolate::GetCurrent();
if(info->clientdata != 0) { 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 { } 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 #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); 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) #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) #define SWIG_GetInstancePtr(obj, ptr) SWIG_V8_GetInstancePtr(obj, ptr)
#if (SWIG_V8_VERSION < 0x031900) static SwigV8ReturnValue _SWIGV8_wrap_equals(const SwigV8Arguments &args) {
v8::Handle<v8::Value> _SWIGV8_wrap_equals(const v8::Arguments &args) { SWIGV8_HANDLESCOPE();
#else
void _SWIGV8_wrap_equals(const v8::FunctionCallbackInfo<v8::Value>& args) {
#endif
v8::HandleScope scope;
v8::Handle<v8::Value> jsresult; v8::Handle<v8::Value> jsresult;
void *arg1 = (void *) 0 ; void *arg1 = (void *) 0 ;
void *arg2 = (void *) 0 ; void *arg2 = (void *) 0 ;
@ -298,20 +415,17 @@ void _SWIGV8_wrap_equals(const v8::FunctionCallbackInfo<v8::Value>& args) {
} }
result = (bool)(arg1 == arg2); result = (bool)(arg1 == arg2);
jsresult = v8::Boolean::New(result); jsresult = SWIGV8_BOOLEAN_NEW(result);
SWIGV8_RETURN(jsresult); SWIGV8_RETURN(jsresult);
goto fail; goto fail;
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
#if (SWIG_V8_VERSION < 0x031900) static SwigV8ReturnValue _wrap_getCPtr(const SwigV8Arguments &args) {
v8::Handle<v8::Value> _wrap_getCPtr(const v8::Arguments &args) { SWIGV8_HANDLESCOPE();
#else
void _wrap_getCPtr(const v8::FunctionCallbackInfo<v8::Value>& args) {
#endif
v8::HandleScope scope;
v8::Handle<v8::Value> jsresult; v8::Handle<v8::Value> jsresult;
void *arg1 = (void *) 0 ; void *arg1 = (void *) 0 ;
long result; long result;
@ -323,12 +437,12 @@ void _wrap_getCPtr(const v8::FunctionCallbackInfo<v8::Value>& args) {
} }
result = (long)arg1; result = (long)arg1;
jsresult = v8::Number::New(result); jsresult = SWIGV8_NUMBER_NEW(result);
SWIGV8_RETURN(jsresult); SWIGV8_RETURN(jsresult);
goto fail; goto fail;
fail: fail:
SWIGV8_RETURN(v8::Undefined()); SWIGV8_RETURN(SWIGV8_UNDEFINED());
} }
/* --------------------------------------------------------------------------- /* ---------------------------------------------------------------------------
@ -343,7 +457,7 @@ public:
~SwigV8PackedData() { ~SwigV8PackedData() {
}; };
void* data; void *data;
size_t size; size_t size;
swig_type_info *type; swig_type_info *type;
@ -352,22 +466,24 @@ public:
SWIGRUNTIMEINLINE SWIGRUNTIMEINLINE
int SwigV8Packed_Check(v8::Handle<v8::Value> valRef) { int SwigV8Packed_Check(v8::Handle<v8::Value> valRef) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
v8::Handle<v8::Object> objRef = valRef->ToObject(); v8::Handle<v8::Object> objRef = valRef->ToObject();
if(objRef->InternalFieldCount() < 1) return false; 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()); return (flag->IsBoolean() && flag->BooleanValue());
} }
SWIGRUNTIME 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)) { if (SwigV8Packed_Check(valRef)) {
v8::HandleScope scope; SWIGV8_HANDLESCOPE();
SwigV8PackedData *sobj; SwigV8PackedData *sobj;
v8::Handle<v8::Object> objRef = valRef->ToObject(); 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); v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
sobj = static_cast<SwigV8PackedData*>(v8::External::Unwrap(cdataRef)); sobj = static_cast<SwigV8PackedData*>(v8::External::Unwrap(cdataRef));
#else #else
@ -395,57 +511,82 @@ int SWIGV8_ConvertPacked(v8::Handle<v8::Value> valRef, void *ptr, size_t sz, swi
return SWIG_OK; return SWIG_OK;
} }
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031710)
void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) static void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) {
{
SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(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 #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 #endif
delete cdata; delete cdata;
#if (SWIG_V8_VERSION < 0x031900) #if (SWIG_V8_VERSION < 0x031710)
object.Clear(); object.Clear();
object.Dispose(); object.Dispose();
#elif (SWIG_V8_VERSION < 0x031900)
object.Clear();
object.Dispose(isolate);
#elif (SWIG_V8_VERSION < 0x032100) #elif (SWIG_V8_VERSION < 0x032100)
object->Dispose(isolate); object->Dispose(isolate);
#else #elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
object->Dispose(); object->Dispose();
#else
object.Clear();
#endif #endif
} }
SWIGRUNTIME SWIGRUNTIME
v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_info *type) { 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); SwigV8PackedData *cdata = new SwigV8PackedData(data, size, type);
v8::Handle<v8::Object> obj = v8::Object::New(); // 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); obj->SetPointerInInternalField(0, cdata);
cdata->handle = v8::Persistent<v8::Object>::New(obj);
#else #else
obj->SetAlignedPointerInInternalField(0, cdata); 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); cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
#endif #endif
#if (SWIG_V8_VERSION < 0x031900)
#if (SWIG_V8_VERSION < 0x031710)
cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete); cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
cdata->handle.MarkIndependent(); #elif (SWIG_V8_VERSION < 0x031918)
#else
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete); cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete);
# if (SWIG_V8_VERSION < 0x032100) #elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
cdata->handle.MarkIndependent(v8::Isolate::GetCurrent()); cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
# else #else
cdata->handle.MarkIndependent(); cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete);
# endif // v8::V8::SetWeak(&cdata->handle, cdata, _wrap_SwigV8PackedData_delete);
#endif #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) #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 SWIGRUNTIME
#if (SWIG_V8_VERSION < 0x031903)
v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Handle<v8::Value> result, v8::Handle<v8::Value> obj) { 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()) { 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); 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); 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 (carray) {
if (size > INT_MAX) { if (size > INT_MAX) {
// TODO: handle extra long strings // TODO: handle extra long strings
return v8::Undefined(); return SWIGV8_UNDEFINED();
} else { } 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; return js_str;
} }
} else { } else {
return v8::Undefined(); return SWIGV8_UNDEFINED();
} }
} }
} }

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

@ -26,7 +26,7 @@
/* Javascript types */ /* Javascript types */
#define SWIG_Object v8::Handle<v8::Value> #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 */ /* Overload of the output/constant/exception/dirout handling */

9
Tools/javascript/Makefile.in
View file

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

253
Tools/javascript/v8_shell.cxx
View file

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

8
configure.ac
View file

@ -1224,7 +1224,7 @@ else
# check for include files # check for include files
AC_MSG_CHECKING(for V8 Javascript v8.h) 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 not include dir is specified we try to find
if test -z "$JSV8INCDIR"; then if test -z "$JSV8INCDIR"; then
@ -1257,11 +1257,11 @@ else
# check for V8 library # check for V8 library
AC_MSG_CHECKING(for V8 Javascript 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/" v8libdirs="$JSV8LIBDIR /usr/lib64/ /usr/local/lib64/ /usr/lib/ /usr/local/lib/"
for d in $v8libdirs ; do for d in $v8libdirs ; do
if test -r $d/libv8.so; then if test -r $d/libv8$JSSO; then
JSV8LIBDIR=$d JSV8LIBDIR=$d
JSV8LIB="-L$d -lv8" JSV8LIB="-L$d -lv8"
break break
@ -1280,7 +1280,7 @@ else
# linking options # linking options
case $host in case $host in
*-*-darwin*) *-*-darwin*)
JSV8DYNAMICLINKING="" # TODO: add osx configuration JSV8DYNAMICLINKING="$JSV8LIB"
;; ;;
*-*-linux*) *-*-linux*)
JSV8DYNAMICLINKING="$JSV8LIB" JSV8DYNAMICLINKING="$JSV8LIB"