Several adaptations and fixes on the way to get V8 emitter running.

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/oliverb-javascript-v8@13788 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Lib/javascript/v8/javascriptcode.swg

@@ -1,101 +1,131 @@
-%fragment("v8_initializer", "templates") %{
-void ${MODULE}_Initialize(v8::Handle<v8::Context> context)
+%fragment("JS_ctordefn", "templates") %{
+v8::Handle<v8::Value> $jsmangledname_new(const v8::Arguments& args) {
+  v8::HandleScope scope;
+  v8::Handle<v8::Object> self = args.Holder();
+  $jslocals
+  $jscode
+  self->SetInternalField(0, v8::External::New(result));
+  return scope.Close(self);
+  goto fail;
+fail:
+  return scope.Close(v8::Undefined);
+}%}
+
+%fragment("JS_getproperty", "templates") %{
+v8::Handle<v8::Value> $jsgetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+  v8::HandleScope scope;
+  v8::Handle<v8::Object> jsresult;
+  $jslocals
+  $jscode
+  return scope.Close(jsresult);
+  goto fail;
+fail:
+  return scope.Close(v8::Undefined());
+}%}
+
+%fragment("JS_setproperty", "templates") %{
+void $jssetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+  v8::HandleScope scope;
+  $jslocals
+  $jscode
+  goto fail;
+fail:
+  return;
+}%}
+
+%fragment("JS_functionwrapper", "templates") %{
+v8::Handle<v8::Value> $jswrapper(const v8::Arguments &args) {
+  v8::HandleScope scope;
+  v8::Handle<v8::Object> jsresult;
+  $jslocals
+  $jscode
+  return scope.Close(jsresult);
+  goto fail;
+fail:
+  return scope.Close(v8::Undefined());
+}%}
+
+// TODO: implement ctor overloading properly!
+%fragment ("JS_mainctordefn", "templates")
+%{
+  // TODO: implement JS_mainctordefn
+%}
+
+%fragment ("JS_ctor_dispatch_case", "templates")
+%{
+  // TODO: implement JS_ctor_dispatch_case
+%}
+
+%fragment ("JS_destructordefn", "templates")
+%{
+  // TODO: implement JS_destructordefn
+%}
+
+%fragment("jsv8_declare_class_template", "templates") %{
+v8::Persistent<v8::FunctionTemplate> SWIGV8_$jsmangledname;%}
+
+%fragment("jsv8_define_class_template", "templates") %{
+SWIGV8_$jsmangledname = SWIGV8_CreateClassTemplate("$jsname" , $jsmangledname_new);%}
+
+%fragment("jsv8_create_class_instance", "templates") %{
+v8::Handle<v8::Object> class_$jsmangledname = SWIGV8_$jsmangledname->GetFunction();%}
+
+%fragment("jsv8_inherit", "templates") %{
+SWIGV8_$jsmangledname->Inherit(SWIGV8_$jsbaseclass);%}
+
+%fragment("jsv8_register_class", "templates") %{
+$jsparent->Set(v8::String::NewSymbol("$jsname"), class_$jsmangledname);%}
+
+%fragment("jsv8_create_namespace", "templates") %{
+v8::Handle<v8::ObjectTemplate> $jsmangledname = v8::ObjectTemplate::New();%}
+
+%fragment("jsv8_register_member_function", "templates") %{
+SWIGV8_AddMemberFunction(SWIGV8_$jsmangledname, "$jsname", $jswrapper);%}
+
+%fragment("jsv8_register_static_function", "templates") %{
+SWIGV8_AddGlobalFunction($jsparent, "$jsname", $jswrapper);%}
+
+%fragment("jsv8_register_member_variable", "templates") %{
+SWIGV8_AddMemberVariable(SWIGV8_$jsmangledname, "$jsname", $jsgetter, $jssetter);%}
+
+%fragment("jsv8_register_static_variable", "templates") %{
+SWIGV8_AddGlobalVariable($jsparent, "$jsname", $jsgetter, $jssetter);%}
+
+%fragment("jsv8_register_namespace", "templates") %{
+$jsparent->Set(v8::String::NewSymbol("$jsname", $jsmangledname->NewInstance()));%}
+
+%fragment("JS_initializer", "templates") %{
+
+extern "C" {
+
+void $jsname_initialize(v8::Handle<v8::Context> context)
 {
     v8::HandleScope scope;
     v8::Local<v8::Object> global = context->Global();
 
     /* create object templates for namespaces */
-    ${PART_NAMESPACES}
+    $jsv8nspaces
     
     /* create class templates */
-    ${PART_CLASS_TEMPLATES}
+    $jsv8classtemplates
     
     /* register wrapper functions */
-    ${PART_WRAPPERS}
+    $jsv8wrappers
     
     /* setup inheritances */
-    ${PART_INHERITANCE}
+    $jsv8inheritance
     
     /* class instances */
-    ${PART_CLASS_INSTANCES}
+    $jsv8classinstances
 
     /* add static class functions and variables */
-    ${PART_STATIC_WRAPPERS}
+    $jsv8staticwrappers
     
     /* register classes */
-    ${PART_REGISTER_CLASSES}
+    $jsv8registerclasses
     
     /* create and register namespace objects */
-    ${PART_REGISTER_NS}
+    $jsv8registernspaces
+}
+
 }%}
-
-%fragment("v8_declare_class_template", "templates") %{
-v8::Persistent<v8::FunctionTemplate> SWIGV8_${NAME_MANGLED};%}
-
-%fragment("v8_define_class_template", "templates") %{
-SWIGV8_${NAME_MANGLED} = SWIGV8_CreateClassTemplate("${NAME_UNQUALIFIED}" , ${NAME_MANGLED}_new);%}
-
-%fragment("v8_create_class_instance", "templates") %{
-v8::Handle<v8::Object> class_${NAME_MANGLED} = SWIGV8_${NAME_MANGLED}->GetFunction();%}
-
-%fragment("v8_inherit", "templates") %{
-SWIGV8_${NAME_MANGLED}->Inherit(SWIGV8_${BASE_CLASS});%}
-
-%fragment("v8_register_class", "templates") %{
-${CONTEXT}->Set(v8::String::NewSymbol("${NAME_UNQUALIFIED}"), class_${NAME_MANGLED});%}
-
-%fragment("v8_ctor_wrapper", "templates") %{
-v8::Handle<v8::Value> ${NAME_MANGLED}_new(const v8::Arguments& args) {
-    v8::HandleScope scope;
-    v8::Handle<v8::Object> self = args.Holder();
-    ${LOCALS}
-    ${CODE}
-    self->SetInternalField(0, v8::External::New(result));
-    return self;        
-}%}
-
-%fragment("v8_getter", "templates") %{
-v8::Handle<v8::Value> ${NAME_MANGLED}_get(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
-    v8::HandleScope scope;
-    v8::Handle<v8::Object> jsresult;
-    ${LOCALS}
-    ${CODE}
-    return scope.Close(jsresult);
-}%}
-
-%fragment("v8_setter", "templates") %{
-void ${NAME_MANGLED}_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
-    ${LOCALS}
-    ${CODE}
-}%}
-
-%fragment("v8_function", "templates") %{
-v8::Handle<v8::Value> wrap_${NAME_MANGLED}(const Arguments &args) {
-    v8::HandleScope scope;
-    v8::Handle<v8::Object> jsresult;
-    ${LOCALS}
-    ${CODE}
-    return scope.Close(jsresult);
-}%}
-
-%fragment("v8_create_namespace", "templates") %{
-v8::Handle<v8::ObjectTemplate> ${NAME_MANGLED} = v8::ObjectTemplate::New();%}
-
-%fragment("v8_register_member_function", "templates") %{
-SWIGV8_AddMemberFunction(SWIGV8_${CLASSNAME_MANGLED}, "${NAME_UNQUALIFIED}", wrap_${NAME_MANGLED});%}
-
-%fragment("v8_register_global_function", "templates") %{
-SWIGV8_AddGlobalFunction(${CONTEXT}, "${NAME_UNQUALIFIED}", wrap_${NAME_MANGLED});%}
-
-%fragment("v8_register_member_variable", "templates") %{
-SWIGV8_AddMemberVariable(SWIGV8_${CLASSNAME_MANGLED}, "${NAME_UNQUALIFIED}", ${GETTER}, ${SETTER});%}
-
-%fragment("v8_register_global_variable", "templates") %{
-SWIGV8_AddGlobalVariable(${CONTEXT}, "${NAME_UNQUALIFIED}", ${GETTER}, ${SETTER});%}
-
-%fragment("v8_register_namespace", "templates") %{
-${CONTEXT}->Set(v8::String::NewSymbol("${NAME_UNQUALIFIED}", ${NAME_MANGLED}->NewInstance()));%}
-
-%fragment("v8_this_ptr", "templates") %{
-arg1 = SWIGV8_UnwrapThisPointer<${TYPE}>(${ARG}.Holder());
-%}

Lib/javascript/v8/javascripthelpers.swg

@@ -13,10 +13,6 @@ v8::Persistent<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const char* symb
     return v8::Persistent<v8::FunctionTemplate>::New(class_templ);
 }
 
-v8::Handle<v8::ObjectTemplate> SWIGV8_CreateNamespace(const char* name, v8::Handle<v8::Context> parentContext) {
-    Handle<ObjectTemplate> namespace = ObjectTemplate::New();
-}
-
 /**
  * Registers a class method with given name for a given class template. 
  */
@@ -29,7 +25,7 @@ void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class_templ, cons
  * Registers a class method with given name for a given class template. 
  */
 void SWIGV8_AddGlobalFunction(v8::Handle<v8::ObjectTemplate> obj_templ, const char* symbol, v8::InvocationCallback _func) {
-    obj_templ->Set(String::NewSymbol(symbol), v8::FunctionTemplate::New(_func)->GetFunction());
+    obj_templ->Set(v8::String::NewSymbol(symbol), v8::FunctionTemplate::New(_func)->GetFunction());
 }
 
 /**
@@ -44,6 +40,6 @@ void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class_templ, cons
  * Registers a class method with given name for a given class template. 
  */
 void SWIGV8_AddGlobalVariable(v8::Handle<v8::ObjectTemplate> obj_templ, const char* symbol, v8::AccessorGetter getter, v8::AccessorSetter setter) {
-    obj_templ->SetAccessor(String::NewSymbol(symbol), getter, setter);
+    obj_templ->SetAccessor(v8::String::NewSymbol(symbol), getter, setter);
 }
 %} // v8_helper_functions

Lib/javascript/v8/javascriptprimitives.swg

@@ -42,7 +42,7 @@ v8::Handle<v8::Value> SWIG_From_dec(long)(long value)
 SWIGINTERN 
 int SWIG_AsVal_dec(long)(v8::Handle<v8::Value> obj, long* val)
 {
-  if (!obj->IsInteger()) {
+  if (!obj->IsNumber()) {
     return SWIG_TypeError;
   }
   if(val) *val = (long) obj->IntegerValue();

Lib/javascript/v8/javascriptruntime.swg

@@ -6,6 +6,8 @@
 
 %insert(runtime) %{
 #include <v8.h>
+#include <errno.h>
+#include <limits.h>
 %}
 
 %insert(runtime) "swigrun.swg";         /* SWIG API */
@@ -39,12 +41,12 @@ void SWIG_V8_exception(int code, const char* msg) {
 
 
 %insert(runtime) %{
-int SWIG_JSC_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void** ptr, swig_type_info *info, int flags) {
+int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void** ptr, swig_type_info *info, int flags) {
   
   if(objRef->InternalFieldCount() < 1) {
     return SWIG_ERROR;
   }
-  Handle<Value> cdataRef = objRef->GetInternalField(0);
+  v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
   
   SWIG_PRV_DATA *cdata = (SWIG_PRV_DATA *) v8::External::Unwrap(cdataRef);
   if(cdata == NULL) {
@@ -80,14 +82,14 @@ int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void** ptr, swig_type_info
     return SWIG_TypeError;
   }
   
-  v8::Handle<v8::object> objRef = valRef->ToObject();
+  v8::Handle<v8::Object> objRef = valRef->ToObject();
     
-  return SWIG_V8_ConvertInstancePtr(context, objRef, ptr, info, flags);
+  return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags);
 }
 
 v8::Handle<v8::Object> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
   // TODO: wrap ptr into an v8 object
-  return 0;
+  return v8::Undefined();
 }
 
 #define SWIG_ConvertPtr(obj, ptr, info, flags)    SWIG_V8_ConvertPtr(obj, ptr, info, flags)