aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rwxr-xr-xsrc/embind/embind.js155
-rwxr-xr-xsystem/include/emscripten/bind.h62
-rwxr-xr-xsystem/lib/embind/bind.cpp20
3 files changed, 104 insertions, 133 deletions
diff --git a/src/embind/embind.js b/src/embind/embind.js
index d8a4a440..7210dbc1 100755
--- a/src/embind/embind.js
+++ b/src/embind/embind.js
@@ -5,7 +5,6 @@
/*global Pointer_stringify, writeStringToMemory*/
/*global __emval_register, _emval_handle_array, __emval_decref*/
/*global ___getDynamicPointerType: false*/
-/*global ___dynamicPointerCast: false*/
/*global ___typeName:false*/
/*global ___staticPointerCast: false*/
@@ -308,6 +307,12 @@ function runDestructors(destructors) {
}
}
+function refreshSmartPointee(handle) {
+ if (handle && handle.smartPointer) {
+ handle.ptr = handle.type.smartPointerType.getPointee(handle.smartPointer);
+ }
+}
+
function makeInvoker(name, argCount, argTypes, invoker, fn) {
if (!FUNCTION_TABLE[fn]) {
throw new BindingError('function '+name+' is not defined');
@@ -329,6 +334,9 @@ function makeInvoker(name, argCount, argTypes, invoker, fn) {
rv = argTypes[0].fromWireType(rv);
}
runDestructors(destructors);
+ for (i = 1; i < argCount; i++) {
+ refreshSmartPointee(arguments[i-1]);
+ }
return rv;
};
}
@@ -537,21 +545,21 @@ RegisteredPointer.prototype.toWireType = function(destructors, handle) {
if (!handle) {
return null;
}
- if (handle.pointeeType.isPolymorphic) {
- fromRawType = handle.pointeeType.getDynamicRawPointerType(handle.ptr);
+ if (handle.type.isPolymorphic) {
+ fromRawType = handle.type.getDynamicRawPointerType(handle.ptr);
} else {
- fromRawType = handle.pointeeType.rawType;
+ fromRawType = handle.type.rawType;
}
- if (fromRawType === this.pointeeType.rawType) {
+ if (fromRawType === this.type.rawType) {
return this.isSmartPointer ? handle.smartPointer : handle.ptr;
}
- var ptr = staticPointerCast(handle.ptr, fromRawType, this.pointeeType.rawType);
+ var ptr = staticPointerCast(handle.ptr, fromRawType, this.type.rawType);
if (this.isSmartPointer) {
// todo: if ptr == handle.ptr, there's no need to allocate a new smartPtr!
- var smartPtr = _malloc(16);
- handle.pointeeType.smartPointerType.rawConstructor(smartPtr, ptr, handle.smartPointer);
+ var smartPtr = _malloc(16); // todo: can we get C++ to tell us the size of the pointer?
+ handle.type.smartPointerType.rawConstructor(smartPtr, ptr, handle.smartPointer);
ptr = smartPtr;
- destructors.push(handle.pointeeType.smartPointerType.rawDestructor);
+ destructors.push(handle.type.smartPointerType.rawDestructor);
destructors.push(ptr);
}
return ptr;
@@ -582,7 +590,7 @@ RegisteredPointer.prototype.fromWireType = function(ptr) {
RegisteredPointer.prototype.getDynamicRawPointerType = function(ptr) {
var type = null;
if (this.isPolymorphic) {
- if (this.rawGetPointee) {
+ if (this.rawGetPointee) { // todo: did you mean isSmartPtr?
type = ___getDynamicPointerType(this.rawGetPointee(ptr));
} else {
type = ___getDynamicPointerType(ptr);
@@ -594,8 +602,8 @@ RegisteredPointer.prototype.getDynamicRawPointerType = function(ptr) {
RegisteredPointer.prototype.getDynamicDowncastType = function(ptr) {
var downcastType = null;
var type = this.getDynamicRawPointerType(ptr);
- if (type && type !== this.pointeeType.rawType) {
- var derivation = Module.__getDerivationPath(type, this.pointeeType.rawType);
+ if (type && type !== this.type.rawType) {
+ var derivation = Module.__getDerivationPath(type, this.type.rawType);
for (var i = 0; i < derivation.size(); i++) {
downcastType = typeRegistry[derivation.at(i)];
if (downcastType) {
@@ -615,7 +623,7 @@ RegisteredPointer.prototype.fromWireTypeAutoDowncast = function(ptr) { // ptr is
}
var toType = this.getDynamicDowncastType(ptr);
if (toType) {
- var fromType = this.pointeeType;
+ var fromType = this.type;
if (this.isSmartPointer) {
handle = toType.smartPointerType.fromWireType(ptr);
} else {
@@ -641,12 +649,16 @@ function __embind_register_smart_ptr(
rawConstructor = FUNCTION_TABLE[rawConstructor];
rawDestructor = FUNCTION_TABLE[rawDestructor];
rawGetPointee = FUNCTION_TABLE[rawGetPointee];
-
+
+ if (name == "") {
+ name = pointeeType.name + "Ptr";
+ }
+
var Handle = createNamedFunction(name, function(ptr) {
this.count = {value: 1};
this.smartPointer = ptr; // std::shared_ptr<T>*
this.ptr = rawGetPointee(ptr); // T*
- this.pointeeType = pointeeType;
+ this.type = pointeeType;
});
// TODO: test for SmartPtr.prototype.constructor property?
@@ -680,7 +692,7 @@ function __embind_register_smart_ptr(
this.ptr = undefined;
};
var registeredPointer = new RegisteredPointer(Handle, pointeeType.isPolymorphic, true, rawGetPointee, rawConstructor, rawDestructor);
- registeredPointer.pointeeType = pointeeType;
+ registeredPointer.type = pointeeType;
pointeeType.smartPointerType = registerType(rawType, name, registeredPointer);
}
@@ -828,11 +840,13 @@ function __embind_register_class(
h.count = {value: 1, ptr: ptr };
h.ptr = ptr;
- h.pointeeType = type; // set below
+ h.type = type; // set below
for(var prop in Handle.prototype) {
- var dp = Object.getOwnPropertyDescriptor(Handle.prototype, prop);
- Object.defineProperty(h, prop, dp);
+ if (Handle.prototype.hasOwnProperty(prop)) {
+ var dp = Object.getOwnPropertyDescriptor(Handle.prototype, prop);
+ Object.defineProperty(h, prop, dp);
+ }
}
return h;
@@ -875,15 +889,15 @@ function __embind_register_class(
// todo: clean this up!
var registeredClass = new RegisteredPointer(Handle, isPolymorphic, false);
var type = registerType(rawType, name, registeredClass);
- registeredClass.pointeeType = type;
+ registeredClass.type = type;
- var registeredClass = new RegisteredPointer(Handle, isPolymorphic, false);
+ registeredClass = new RegisteredPointer(Handle, isPolymorphic, false);
registerType(rawPointerType, name + '*', registeredClass);
- registeredClass.pointeeType = type;
+ registeredClass.type = type;
// todo: implement const pointers (no modification Javascript side)
- var registeredClass = new RegisteredPointer(Handle, isPolymorphic, false);
+ registeredClass = new RegisteredPointer(Handle, isPolymorphic, false);
registerType(rawConstPointerType, name + ' const*', registeredClass);
- registeredClass.pointeeType = type;
+ registeredClass.type = type;
type.constructor = createNamedFunction(type.name, function() {
var body = type.constructor.body;
@@ -965,26 +979,32 @@ function __embind_register_class_method(
rv = argTypes[0].fromWireType(rv);
}
runDestructors(destructors);
+ for (i = 1; i < argCount; i++) {
+ refreshSmartPointee(arguments[i-1]);
+ }
return rv;
};
classType.Handle.memberType[methodName] = "method";
});
}
-// todo: cast methods should require binding of their target types
-function __embind_register_raw_cast_method(
+function __embind_register_cast_method(
rawClassType,
isPolymorphic,
methodName,
- rawReturnType,
- rawInvoker
+ rawRawReturnType,
+ rawSharedReturnType,
+ rawRawCaster,
+ rawSharedCaster
) {
requestDeferredRegistration(function() {
var classType = requireRegisteredType(rawClassType, 'class');
methodName = Pointer_stringify(methodName);
var humanName = classType.name + '.' + methodName;
- var returnType = requireRegisteredType(rawReturnType, 'method ' + humanName + ' return value');
- rawInvoker = FUNCTION_TABLE[rawInvoker];
+ var rawReturnType = requireRegisteredType(rawRawReturnType, 'method ' + humanName + ' return value');
+ var sharedReturnType = requireRegisteredType(rawSharedReturnType, 'method ' + humanName + ' shared pointer return value');
+ var rawCaster = FUNCTION_TABLE[rawRawCaster];
+ var sharedCaster = FUNCTION_TABLE[rawSharedCaster];
classType.Handle.prototype[methodName] = function() {
if (!this.ptr) {
throw new BindingError('cannot call emscripten binding method ' + humanName + ' on deleted object');
@@ -995,11 +1015,11 @@ function __embind_register_raw_cast_method(
if (isPolymorphic) {
// todo: this is all only to validate the cast -- cache the result
var runtimeType = ___getDynamicPointerType(this.ptr);
- var derivation = Module.__getDerivationPath(rawReturnType, runtimeType); // downcast is valid
+ var derivation = Module.__getDerivationPath(rawRawReturnType, runtimeType); // downcast is valid
var size = derivation.size();
derivation.delete();
if (size === 0) {
- derivation = Module.__getDerivationPath(runtimeType, rawReturnType); // upcast is valid
+ derivation = Module.__getDerivationPath(runtimeType, rawRawReturnType); // upcast is valid
size = derivation.size();
derivation.delete();
if (size === 0) {
@@ -1007,60 +1027,25 @@ function __embind_register_raw_cast_method(
}
}
}
- var args = new Array(1);
- args[0] = this.ptr;
- var ptr = rawInvoker.apply(null, args);
- var rv = returnType.fromWireType(ptr);
- rv.count = this.count;
- this.count.value ++;
- return rv;
- };
- });
-}
-
-// todo: cast methods should not be passed from the smart ptr to the contained object!!
-function __embind_register_smart_cast_method(
- rawPointerType,
- rawReturnType,
- returnPointeeType,
- isPolymorphic,
- methodName,
- rawInvoker
-) {
- requestDeferredRegistration(function() {
- var pointerType = requireRegisteredType(rawPointerType, 'smart pointer class');
- methodName = Pointer_stringify(methodName);
- var humanName = pointerType.name + '.' + methodName;
- var returnType = requireRegisteredType(rawReturnType, 'method ' + humanName + ' return value');
- rawInvoker = FUNCTION_TABLE[rawInvoker];
- pointerType.Handle.prototype[methodName] = function() {
- if (!this.ptr) {
- throw new BindingError('cannot call emscripten binding method ' + humanName + ' on deleted object');
- }
- if (arguments.length !== 0) {
- throw new BindingError('emscripten binding method ' + humanName + ' called with arguments, none expected');
- }
- if (isPolymorphic) {
- // todo: just validating the cast -- cache the result
- var runtimeType = ___getDynamicPointerType(this.ptr);
- var derivation = Module.__getDerivationPath(returnPointeeType, runtimeType); // downcast is valid
- var size = derivation.size();
- derivation.delete();
- if (size === 0) {
- derivation = Module.__getDerivationPath(runtimeType, returnPointeeType); // upcast is valid
- size = derivation.size();
- derivation.delete();
- if (size === 0) {
- throw new CastError("Pointer conversion is not available");
- }
- }
+ var args;
+ var ptr;
+ var rv;
+ if (this.smartPointer) {
+ args = new Array(2);
+ ptr = _malloc(8);
+ args[0] = ptr;
+ args[1] = this.smartPointer;
+ sharedCaster.apply(null,args); // need a smart pointer raw invoker
+ rv = sharedReturnType.fromWireType(ptr);
+ } else {
+ args = new Array(1);
+ args[0] = this.ptr;
+ ptr = rawCaster.apply(null, args);
+ rv = rawReturnType.fromWireType(ptr);
+ rv.count = this.count;
+ this.count.value ++;
}
- var args = new Array(2);
- var ptr = _malloc(8);
- args[0] = ptr;
- args[1] = this.smartPointer;
- rawInvoker.apply(null,args);
- return returnType.fromWireType(ptr);
+ return rv;
};
});
}
diff --git a/system/include/emscripten/bind.h b/system/include/emscripten/bind.h
index ce9053f2..a3789cab 100755
--- a/system/include/emscripten/bind.h
+++ b/system/include/emscripten/bind.h
@@ -124,20 +124,14 @@ namespace emscripten {
size_t memberFunctionSize,
void* memberFunction);
- void _embind_register_raw_cast_method(
+ void _embind_register_cast_method(
TYPEID classType,
bool isPolymorphic,
const char* methodName,
TYPEID returnType,
- GenericFunction invoker);
-
- void _embind_register_smart_cast_method(
- TYPEID pointerType,
- TYPEID returnType,
- TYPEID returnPointeeType,
- bool isPolymorphic,
- const char* methodName,
- GenericFunction invoker);
+ TYPEID sharedReturnType,
+ GenericFunction rawInvoker,
+ GenericFunction sharedInvoker);
void _embind_register_class_field(
TYPEID classType,
@@ -274,7 +268,6 @@ namespace emscripten {
extern "C" {
int __getDynamicPointerType(int p);
- int __dynamicPointerCast(int p, int to);
}
template<typename FromType, typename ToType>
@@ -283,14 +276,14 @@ namespace emscripten {
};
template<typename FromRawType, typename ToRawType, bool isPolymorphic>
- struct performShared {
+ struct performSharedCast {
static std::shared_ptr<ToRawType> cast(std::shared_ptr<FromRawType> from) {
return std::dynamic_pointer_cast<ToRawType>(from);
};
};
template<typename FromRawType, typename ToRawType>
- struct performShared<FromRawType, ToRawType, false> {
+ struct performSharedCast<FromRawType, ToRawType, false> {
static std::shared_ptr<ToRawType> cast(std::shared_ptr<FromRawType> from) {
return std::shared_ptr<ToRawType>(from, static_cast<ToRawType*>(from.get()));
};
@@ -300,7 +293,7 @@ namespace emscripten {
void function(const char* name, ReturnType (fn)(Args...), Policies...) {
using namespace internal;
- registerStandardTypes();
+ registerStandardTypes(); // todo: remove all
typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, Args...> args;
_embind_register_function(
@@ -625,21 +618,12 @@ namespace emscripten {
reinterpret_cast<GenericFunction>(&get_pointee<PointerType>));
}
+ };
- template<typename ReturnType>
- register_smart_ptr& cast(const char* methodName) {
- using namespace internal;
- typedef typename ReturnType::element_type ReturnPointeeType;
- typedef typename PointerType::element_type PointeeType;
- _embind_register_smart_cast_method(
- TypeID<PointerType>::get(),
- TypeID<ReturnType>::get(),
- TypeID<ReturnPointeeType>::get(),
- std::is_polymorphic<PointeeType>::value,
- methodName,
- reinterpret_cast<GenericFunction>(&performShared<PointeeType, ReturnPointeeType, std::is_polymorphic<PointeeType>::value>::cast));
- return *this;
- }
+ template<typename PointeeType>
+ class shared_ptr: public register_smart_ptr<std::shared_ptr<PointeeType>> {
+ public:
+ shared_ptr(const char* name): register_smart_ptr<std::shared_ptr<PointeeType>>(name) {};
};
////////////////////////////////////////////////////////////////////////////////
@@ -777,13 +761,31 @@ namespace emscripten {
template<typename ReturnType>
class_& cast(const char* methodName) {
using namespace internal;
+ //typedef typename std::shared_ptr<ClassType> PointerType;
+ typedef typename std::shared_ptr<ReturnType> SharedReturnType;
- _embind_register_raw_cast_method(
+ _embind_register_cast_method(
TypeID<ClassType>::get(),
std::is_polymorphic<ClassType>::value,
methodName,
TypeID<ReturnType>::get(),
- reinterpret_cast<GenericFunction>(&performRawStaticCast<ClassType,ReturnType>));
+ TypeID<SharedReturnType>::get(),
+ reinterpret_cast<GenericFunction>(&performRawStaticCast<ClassType, ReturnType>),
+ reinterpret_cast<GenericFunction>(&performSharedCast<ClassType, ReturnType, std::is_polymorphic<ClassType>::value>::cast));
+ return *this;
+ }
+
+ class_& shared_ptr(const char* ptrName = "") {
+ using namespace internal;
+ typedef typename std::shared_ptr<ClassType> PointerType;
+
+ _embind_register_smart_ptr(
+ TypeID<PointerType>::get(),
+ TypeID<ClassType>::get(),
+ ptrName,
+ reinterpret_cast<GenericFunction>(&raw_smart_pointer_constructor<ClassType*>),
+ reinterpret_cast<GenericFunction>(&raw_destructor<PointerType>),
+ reinterpret_cast<GenericFunction>(&get_pointee<PointerType>));
return *this;
}
};
diff --git a/system/lib/embind/bind.cpp b/system/lib/embind/bind.cpp
index 5e82bb7e..bc79876f 100755
--- a/system/lib/embind/bind.cpp
+++ b/system/lib/embind/bind.cpp
@@ -101,7 +101,7 @@ namespace emscripten {
// __getDerivationPath returns an array of type_info pointers describing the derivation chain starting with
// the derived type and proceeding toward (and ending with) the base type. Types are only included if they
// appear on all possible derivation paths.
- std::vector<int> __getDerivationPath(int dv, const int bs) {
+ std::vector<int> __getDerivationPath(int dv, const int bs) { // todo: use emval array to pass return value??
std::vector<std::vector<const __cxxabiv1::__class_type_info*>> paths;
const std::type_info* dv1 = (std::type_info*)dv;
@@ -176,27 +176,11 @@ namespace emscripten {
// __getDynamicPointerType returns (for polymorphic types only!) the type of the instance actually
// pointed to.
- int EMSCRIPTEN_KEEPALIVE __getDynamicPointerType(int p) {
+ int EMSCRIPTEN_KEEPALIVE __getDynamicPointerType(int p) { // use size_t
void** vtable = *(void***)p;
return (int)static_cast<const std::type_info*>(vtable[-1]);
}
- // Calls to __dynamic_cast are generated by the compiler to implement dynamic_cast<>() -- its prototype is
- // not available through any header file. It is called directly here because it allows run-time
- // specification of the target pointer type (which can only be specified at compile time when using
- // dynamic_cast<>().
- void* __dynamic_cast(void*, const std::type_info*, const std::type_info*, int);
-
- // __dynamicPointerCast performs a C++ dynamic_cast<>() operation, but allowing run-time specification of
- // the from and to pointer types.
- int EMSCRIPTEN_KEEPALIVE __dynamicPointerCast(int p, int to) {
- int ret = (int)__staticPointerCast((void *)p, __getDynamicPointerType(p), to);
- if (ret < 0) {
- return 0;
- }
- return ret;
- }
-
const char* EMSCRIPTEN_KEEPALIVE __typeName(int p) {
const std::type_info* ti = (const std::type_info*)p;
size_t nameLen = std::min(strlen(ti->name()), (unsigned int)1024);
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-07-27 16:34:38 +0000