Merge pull request #1402 from imvu/embind-updates-pull-request

Embind updates pull request

5 files changed, 78 insertions, 62 deletions

diff --git a/src/embind/embind.js b/src/embind/embind.js
index 91386c69..f0cd0c74 100644
--- a/src/embind/embind.js
+++ b/src/embind/embind.js
@@ -5,9 +5,9 @@
 /*global __emval_register, _emval_handle_array, __emval_decref*/
 /*global ___getTypeName*/
 /*jslint sub:true*/ /* The symbols 'fromWireType' and 'toWireType' must be accessed via array notation to be closure-safe since craftInvokerFunction crafts functions as strings that can't be closured. */
-var InternalError = Module.InternalError = extendError(Error, 'InternalError');
-var BindingError = Module.BindingError = extendError(Error, 'BindingError');
-var UnboundTypeError = Module.UnboundTypeError = extendError(BindingError, 'UnboundTypeError');
+var InternalError = Module['InternalError'] = extendError(Error, 'InternalError');
+var BindingError = Module['BindingError'] = extendError(Error, 'BindingError');
+var UnboundTypeError = Module['UnboundTypeError'] = extendError(BindingError, 'UnboundTypeError');
 
 function throwInternalError(message) {
     throw new InternalError(message);
@@ -638,7 +638,7 @@ function __embind_register_function(name, argCount, rawArgTypesAddr, rawInvoker,
 
 var tupleRegistrations = {};
 
-function __embind_register_tuple(rawType, name, rawConstructor, rawDestructor) {
+function __embind_register_value_array(rawType, name, rawConstructor, rawDestructor) {
     tupleRegistrations[rawType] = {
         name: readLatin1String(name),
         rawConstructor: FUNCTION_TABLE[rawConstructor],
@@ -647,7 +647,7 @@ function __embind_register_tuple(rawType, name, rawConstructor, rawDestructor) {
     };
 }
 
-function __embind_register_tuple_element(
+function __embind_register_value_array_element(
     rawTupleType,
     getterReturnType,
     getter,
@@ -666,7 +666,7 @@ function __embind_register_tuple_element(
     });
 }
 
-function __embind_finalize_tuple(rawTupleType) {
+function __embind_finalize_value_array(rawTupleType) {
     var reg = tupleRegistrations[rawTupleType];
     delete tupleRegistrations[rawTupleType];
     var elements = reg.elements;
@@ -725,7 +725,7 @@ function __embind_finalize_tuple(rawTupleType) {
 
 var structRegistrations = {};
 
-function __embind_register_struct(
+function __embind_register_value_object(
     rawType,
     name,
     rawConstructor,
@@ -739,7 +739,7 @@ function __embind_register_struct(
     };
 }
 
-function __embind_register_struct_field(
+function __embind_register_value_object_field(
     structType,
     fieldName,
     getterReturnType,
@@ -760,7 +760,7 @@ function __embind_register_struct_field(
     });
 }
 
-function __embind_finalize_struct(structType) {
+function __embind_finalize_value_object(structType) {
     var reg = structRegistrations[structType];
     delete structRegistrations[structType];
 
@@ -879,11 +879,11 @@ var genericPointerToWireType = function(destructors, handle) {
                 if (handle.$$.smartPtrType === this) {
                     ptr = handle.$$.smartPtr;
                 } else {
-                    var clonedHandle = handle.clone();
+                    var clonedHandle = handle['clone']();
                     ptr = this.rawShare(
                         ptr,
                         __emval_register(function() {
-                            clonedHandle.delete();
+                            clonedHandle['delete']();
                         })
                     );
                     if (destructors !== null) {
@@ -1088,7 +1088,7 @@ function getInstanceTypeName(handle) {
     return handle.$$.ptrType.registeredClass.name;
 }
 
-ClassHandle.prototype.isAliasOf = function(other) {
+ClassHandle.prototype['isAliasOf'] = function(other) {
     if (!(this instanceof ClassHandle)) {
         return false;
     }
@@ -1118,7 +1118,7 @@ function throwInstanceAlreadyDeleted(obj) {
     throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
 }
 
-ClassHandle.prototype.clone = function() {
+ClassHandle.prototype['clone'] = function() {
     if (!this.$$.ptr) {
         throwInstanceAlreadyDeleted(this);
     }
diff --git a/src/embind/emval.js b/src/embind/emval.js
index 77270597..0d075188 100644
--- a/src/embind/emval.js
+++ b/src/embind/emval.js
@@ -4,6 +4,7 @@
 /*global createNamedFunction*/
 /*global readLatin1String, writeStringToMemory*/
 /*global requireRegisteredType, throwBindingError*/
+/*jslint sub:true*/ /* The symbols 'fromWireType' and 'toWireType' must be accessed via array notation to be closure-safe since craftInvokerFunction crafts functions as strings that can't be closured. */
 
 var Module = Module || {};
 
@@ -100,7 +101,7 @@ function __emval_new_cstring(v) {
 
 function __emval_take_value(type, v) {
     type = requireRegisteredType(type, '_emval_take_value');
-    v = type.fromWireType(v);
+    v = type['fromWireType'](v);
     return __emval_register(v);
 }
 
@@ -203,7 +204,7 @@ function __emval_as(handle, returnType) {
     returnType = requireRegisteredType(returnType, 'emval::as');
     var destructors = [];
     // caller owns destructing
-    return returnType.toWireType(destructors, _emval_handle_array[handle].value);
+    return returnType['toWireType'](destructors, _emval_handle_array[handle].value);
 }
 
 function parseParameters(argCount, argTypes, argWireTypes) {
@@ -212,7 +213,7 @@ function parseParameters(argCount, argTypes, argWireTypes) {
         var argType = requireRegisteredType(
             HEAP32[(argTypes >> 2) + i],
             "parameter " + i);
-        a[i] = argType.fromWireType(argWireTypes[i]);
+        a[i] = argType['fromWireType'](argWireTypes[i]);
     }
     return a;
 }
@@ -223,7 +224,7 @@ function __emval_call(handle, argCount, argTypes) {
 
     var args = new Array(argCount);
     for (var i = 0; i < argCount; ++i) {
-        args[i] = types[i].fromWireType(arguments[3 + i]);
+        args[i] = types[i]['fromWireType'](arguments[3 + i]);
     }
 
     var fn = _emval_handle_array[handle].value;
@@ -247,8 +248,8 @@ function __emval_get_method_caller(argCount, argTypes) {
     var retType = types[0];
     var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$";
 
-    var args1 = ["Runtime", "createNamedFunction", "requireHandle", "getStringOrSymbol", "_emval_handle_array", "retType"];
-    var args2 = [Runtime, createNamedFunction, requireHandle, getStringOrSymbol, _emval_handle_array, retType];
+    var args1 = ["addFunction", "createNamedFunction", "requireHandle", "getStringOrSymbol", "_emval_handle_array", "retType"];
+    var args2 = [Runtime.addFunction, createNamedFunction, requireHandle, getStringOrSymbol, _emval_handle_array, retType];
 
     var argsList = ""; // 'arg0, arg1, arg2, ... , argN'
     var argsListWired = ""; // 'arg0Wired, ..., argNWired'
@@ -260,7 +261,7 @@ function __emval_get_method_caller(argCount, argTypes) {
     }
 
     var invokerFnBody =
-        "return Runtime.addFunction(createNamedFunction('" + signatureName + "', function (handle, name" + argsListWired + ") {\n" +
+        "return addFunction(createNamedFunction('" + signatureName + "', function (handle, name" + argsListWired + ") {\n" +
         "requireHandle(handle);\n" +
         "name = getStringOrSymbol(name);\n";
 
diff --git a/system/include/emscripten/bind.h b/system/include/emscripten/bind.h
index cd465e45..403d8084 100644
--- a/system/include/emscripten/bind.h
+++ b/system/include/emscripten/bind.h
@@ -70,13 +70,13 @@ namespace emscripten {
                 GenericFunction invoker,
                 GenericFunction function);
 
-            void _embind_register_tuple(
+            void _embind_register_value_array(
                 TYPEID tupleType,
                 const char* name,
                 GenericFunction constructor,
                 GenericFunction destructor);
             
-            void _embind_register_tuple_element(
+            void _embind_register_value_array_element(
                 TYPEID tupleType,
                 TYPEID getterReturnType,
                 GenericFunction getter,
@@ -85,15 +85,15 @@ namespace emscripten {
                 GenericFunction setter,
                 void* setterContext);
 
-            void _embind_finalize_tuple(TYPEID tupleType);
+            void _embind_finalize_value_array(TYPEID tupleType);
 
-            void _embind_register_struct(
+            void _embind_register_value_object(
                 TYPEID structType,
                 const char* fieldName,
                 GenericFunction constructor,
                 GenericFunction destructor);
             
-            void _embind_register_struct_field(
+            void _embind_register_value_object_field(
                 TYPEID structType,
                 const char* fieldName,
                 TYPEID getterReturnType,
@@ -103,7 +103,7 @@ namespace emscripten {
                 GenericFunction setter,
                 void* setterContext);
 
-            void _embind_finalize_struct(TYPEID structType);
+            void _embind_finalize_value_object(TYPEID structType);
 
             void _embind_register_smart_ptr(
                 TYPEID pointerType,
@@ -531,26 +531,26 @@ namespace emscripten {
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ClassType>
-    class value_tuple : public internal::noncopyable {
+    class value_array : public internal::noncopyable {
     public:
-        value_tuple(const char* name) {
+        value_array(const char* name) {
             using namespace internal;
-            _embind_register_tuple(
+            _embind_register_value_array(
                 TypeID<ClassType>::get(),
                 name,
                 reinterpret_cast<GenericFunction>(&raw_constructor<ClassType>),
                 reinterpret_cast<GenericFunction>(&raw_destructor<ClassType>));
         }
 
-        ~value_tuple() {
+        ~value_array() {
             using namespace internal;
-            _embind_finalize_tuple(TypeID<ClassType>::get());
+            _embind_finalize_value_array(TypeID<ClassType>::get());
         }
 
         template<typename InstanceType, typename ElementType>
-        value_tuple& element(ElementType InstanceType::*field) {
+        value_array& element(ElementType InstanceType::*field) {
             using namespace internal;
-            _embind_register_tuple_element(
+            _embind_register_value_array_element(
                 TypeID<ClassType>::get(),
                 TypeID<ElementType>::get(),
                 reinterpret_cast<GenericFunction>(
@@ -566,11 +566,11 @@ namespace emscripten {
         }
 
         template<typename Getter, typename Setter>
-        value_tuple& element(Getter getter, Setter setter) {
+        value_array& element(Getter getter, Setter setter) {
             using namespace internal;
             typedef GetterPolicy<Getter> GP;
             typedef SetterPolicy<Setter> SP;
-            _embind_register_tuple_element(
+            _embind_register_value_array_element(
                 TypeID<ClassType>::get(),
                 TypeID<typename GP::ReturnType>::get(),
                 reinterpret_cast<GenericFunction>(&GP::template get<ClassType>),
@@ -582,11 +582,11 @@ namespace emscripten {
         }
 
         template<int Index>
-        value_tuple& element(index<Index>) {
+        value_array& element(index<Index>) {
             using namespace internal;
             ClassType* null = 0;
             typedef typename std::remove_reference<decltype((*null)[Index])>::type ElementType;
-            _embind_register_tuple_element(
+            _embind_register_value_array_element(
                 TypeID<ClassType>::get(),
                 TypeID<ElementType>::get(),
                 reinterpret_cast<GenericFunction>(&internal::get_by_index<ClassType, ElementType>),
@@ -603,25 +603,25 @@ namespace emscripten {
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ClassType>
-    class value_struct : public internal::noncopyable {
+    class value_object : public internal::noncopyable {
     public:
-        value_struct(const char* name) {
+        value_object(const char* name) {
             using namespace internal;
-            _embind_register_struct(
+            _embind_register_value_object(
                 TypeID<ClassType>::get(),
                 name,
                 reinterpret_cast<GenericFunction>(&raw_constructor<ClassType>),
                 reinterpret_cast<GenericFunction>(&raw_destructor<ClassType>));
         }
 
-        ~value_struct() {
-            _embind_finalize_struct(internal::TypeID<ClassType>::get());
+        ~value_object() {
+            _embind_finalize_value_object(internal::TypeID<ClassType>::get());
         }
 
         template<typename InstanceType, typename FieldType>
-        value_struct& field(const char* fieldName, FieldType InstanceType::*field) {
+        value_object& field(const char* fieldName, FieldType InstanceType::*field) {
             using namespace internal;
-            _embind_register_struct_field(
+            _embind_register_value_object_field(
                 TypeID<ClassType>::get(),
                 fieldName,
                 TypeID<FieldType>::get(),
@@ -638,7 +638,7 @@ namespace emscripten {
         }
     
         template<typename Getter, typename Setter>
-        value_struct& field(
+        value_object& field(
             const char* fieldName,
             Getter getter,
             Setter setter
@@ -646,7 +646,7 @@ namespace emscripten {
             using namespace internal;
             typedef GetterPolicy<Getter> GP;
             typedef SetterPolicy<Setter> SP;
-            _embind_register_struct_field(
+            _embind_register_value_object_field(
                 TypeID<ClassType>::get(),
                 fieldName,
                 TypeID<typename GP::ReturnType>::get(),
@@ -659,11 +659,11 @@ namespace emscripten {
         }
 
         template<int Index>
-        value_struct& field(const char* fieldName, index<Index>) {
+        value_object& field(const char* fieldName, index<Index>) {
             using namespace internal;
             ClassType* null = 0;
             typedef typename std::remove_reference<decltype((*null)[Index])>::type ElementType;
-            _embind_register_struct_field(
+            _embind_register_value_object_field(
                 TypeID<ClassType>::get(),
                 fieldName,
                 TypeID<ElementType>::get(),
diff --git a/tests/embind/embind.test.js b/tests/embind/embind.test.js
index e60e1ab3..da81a81e 100644
--- a/tests/embind/embind.test.js
+++ b/tests/embind/embind.test.js
@@ -898,10 +898,7 @@ module({
 
         test("can clone handles", function() {
             var a = cm.emval_test_get_function_ptr();
-            assert.equal(1, a.$$.count.value);
             var b = a.clone();
-            assert.equal(2, a.$$.count.value);
-            assert.equal(2, b.$$.count.value);
             a.delete();
 
             assert.throws(cm.BindingError, function() {
@@ -1149,7 +1146,7 @@ module({
             a.set(b);
             var c = a.get();
 
-            assert.equal(b.$$.ptr, c.$$.ptr);
+            assert.true(b.isAliasOf(c));
             b.delete();
             c.delete();
             a.delete();
@@ -1747,8 +1744,8 @@ module({
     BaseFixture.extend("constants", function() {
         assert.equal(10, cm.INT_CONSTANT);
         assert.equal("some string", cm.STRING_CONSTANT);
-        assert.deepEqual([1, 2, 3, 4], cm.VALUE_TUPLE_CONSTANT);
-        assert.deepEqual({x:1,y:2,z:3,w:4}, cm.VALUE_STRUCT_CONSTANT);
+        assert.deepEqual([1, 2, 3, 4], cm.VALUE_ARRAY_CONSTANT);
+        assert.deepEqual({x:1,y:2,z:3,w:4}, cm.VALUE_OBJECT_CONSTANT);
     });
 
     BaseFixture.extend("object handle comparison", function() {
@@ -1881,6 +1878,16 @@ module({
         //     setTimeout(fn, 0);
         // });
     });
+
+    BaseFixture.extend("references", function() {
+        test("JS object handles can be passed through to C++ by reference", function() {
+            var sh = new cm.StringHolder("Hello world");
+            assert.equal("Hello world", sh.get());
+            cm.clear_StringHolder(sh);
+            assert.equal("", sh.get());
+            sh.delete();
+        });
+    });
 });
 
 /* global run_all_tests */
diff --git a/tests/embind/embind_test.cpp b/tests/embind/embind_test.cpp
index 3561b8a1..d6b27bce 100644
--- a/tests/embind/embind_test.cpp
+++ b/tests/embind/embind_test.cpp
@@ -1445,7 +1445,7 @@ EMSCRIPTEN_BINDINGS(tests) {
 
     //function("emval_test_take_and_return_CustomStruct", &emval_test_take_and_return_CustomStruct);
 
-    value_tuple<TupleVector>("TupleVector")
+    value_array<TupleVector>("TupleVector")
         .element(&TupleVector::x)
         .element(&Vector::getY, &Vector::setY)
         .element(&readVectorZ, &writeVectorZ)
@@ -1455,13 +1455,13 @@ EMSCRIPTEN_BINDINGS(tests) {
     function("emval_test_return_TupleVector", &emval_test_return_TupleVector);
     function("emval_test_take_and_return_TupleVector", &emval_test_take_and_return_TupleVector);
 
-    value_tuple<TupleVectorTuple>("TupleVectorTuple")
+    value_array<TupleVectorTuple>("TupleVectorTuple")
         .element(&TupleVectorTuple::v)
         ;
 
     function("emval_test_return_TupleVectorTuple", &emval_test_return_TupleVectorTuple);
 
-    value_struct<StructVector>("StructVector")
+    value_object<StructVector>("StructVector")
         .field("x", &StructVector::x)
         .field("y", &Vector::getY, &Vector::setY)
         .field("z", &readVectorZ, &writeVectorZ)
@@ -1471,7 +1471,7 @@ EMSCRIPTEN_BINDINGS(tests) {
     function("emval_test_return_StructVector", &emval_test_return_StructVector);
     function("emval_test_take_and_return_StructVector", &emval_test_take_and_return_StructVector);
 
-    value_struct<TupleInStruct>("TupleInStruct")
+    value_object<TupleInStruct>("TupleInStruct")
         .field("field", &TupleInStruct::field)
         ;
 
@@ -2077,12 +2077,12 @@ OrderedStruct getOrderedStruct() {
 }
 
 EMSCRIPTEN_BINDINGS(order) {
-    value_tuple<OrderedTuple>("OrderedTuple")
+    value_array<OrderedTuple>("OrderedTuple")
         .element(&OrderedTuple::first)
         .element(&OrderedTuple::second)
         ;
 
-    value_struct<OrderedStruct>("OrderedStruct")
+    value_object<OrderedStruct>("OrderedStruct")
         .field("first", &OrderedStruct::first)
         .field("second", &OrderedStruct::second)
         ;
@@ -2215,10 +2215,10 @@ EMSCRIPTEN_BINDINGS(constants) {
     constant("STRING_CONSTANT", std::string("some string"));
 
     TupleVector tv(1, 2, 3, 4);
-    constant("VALUE_TUPLE_CONSTANT", tv);
+    constant("VALUE_ARRAY_CONSTANT", tv);
 
     StructVector sv(1, 2, 3, 4);
-    constant("VALUE_STRUCT_CONSTANT", sv);
+    constant("VALUE_OBJECT_CONSTANT", sv);
 }
 
 class DerivedWithOffset : public DummyDataToTestPointerAdjustment, public Base {    
@@ -2235,3 +2235,11 @@ EMSCRIPTEN_BINDINGS(with_adjustment) {
 
     function("return_Base_from_DerivedWithOffset", &return_Base_from_DerivedWithOffset);
 }
+
+void clear_StringHolder(StringHolder& sh) {
+    sh.set("");
+}
+
+EMSCRIPTEN_BINDINGS(references) {
+    function("clear_StringHolder", &clear_StringHolder);
+}