path: root/src/embind/embind.js

/*global Module*/
/*global Module*/
/*global _malloc, _free, _memcpy*/
/*global FUNCTION_TABLE, HEAP32, HEAPU8*/
/*global Pointer_stringify*/
/*global __emval_register, _emval_handle_array, __emval_decref*/
/*global ___getDynamicPointerType: false*/
/*global ___typeName:false*/
/*global ___staticPointerCast: false*/

function exposePublicSymbol(name, value) {
    if (Module.hasOwnProperty(name)) {
        throw new BindingError("Cannot register public name '" + name + "' twice");
    }
    Module[name] = value;
}

function createNamedFunction(name, body) {
    /*jshint evil:true*/
    return new Function(
        "body",
        "return function " + name + "() {\n" +
        "    return body.apply(this, arguments);\n" +
        "};\n"
    )(body);
}

function _embind_repr(v) {
    var t = typeof v;
    if (t === 'object' || t === 'array' || t === 'function') {
        return v.toString();
    } else {
        return '' + v;
    }
}

var typeRegistry = {};
var deferredRegistrations = [];

function requestDeferredRegistration(registrationFunction) {
    deferredRegistrations.push(registrationFunction);
}

function performDeferredRegistrations(){
    while(deferredRegistrations.length > 0) {
        var registrationFunction = deferredRegistrations.shift();
        registrationFunction();
    }
}

function createInheritedFunctionOrProperty(name, type, nameInBaseClass, baseClassType) {
    function upcastingWrapper(method) {
        return function() {
            var baseClassPtr = ___staticPointerCast(this.$$.ptr, type.rawType, baseClassType.rawType);
            if (baseClassPtr === this.$$.ptr) {
                return method.apply(this, arguments);
            } else {
                var handle = this.clone();
                try {
                    handle.$$.ptr = baseClassPtr;
                    return method.apply(handle, arguments);
                } finally {
                    handle.delete();
                }
            }
        };
    }
    var baseClassPrototype = baseClassType.Handle.prototype;
    if (baseClassPrototype.constructor.memberType[nameInBaseClass] === 'field') {
        var baseClassDescriptor = Object.getOwnPropertyDescriptor(baseClassPrototype, nameInBaseClass);
        Object.defineProperty(type.Handle.prototype, name, {
            enumerable: true,
            get: upcastingWrapper(baseClassDescriptor.get),
            set: upcastingWrapper(baseClassDescriptor.set)
        });
        type.Handle.memberType[name] = 'field';
    } else if (baseClassPrototype.constructor.memberType[nameInBaseClass] === 'method') {
        var baseClassMethod = baseClassPrototype[nameInBaseClass];
        type.Handle.prototype[name] = createNamedFunction(name, upcastingWrapper(baseClassMethod));
        type.Handle.memberType[name] = 'method';
    }
}

function collectRegisteredBaseClasses(rawType) {
    var rawBaseTypes = Module.__getBaseClasses(rawType);
    var baseTypes = [];
    for (var i = 0; i < rawBaseTypes.size(); i++) {
        var baseType = typeRegistry[rawBaseTypes.get(i)];
        if (baseType) {
            baseTypes.push(baseType);
        } else {
            baseTypes = baseTypes.concat(collectRegisteredBaseClasses(rawBaseTypes.get(i)));
        }
    }
    return baseTypes;
}

function resolveType(type) {
    if (!type.resolved) {
        var baseClassType, name, baseProto;
        var inheritedNames = {};
        var baseTypes = collectRegisteredBaseClasses(type.rawType);
        for (var i = 0; i < baseTypes.length; i++) {
            var baseType = baseTypes[i];
            resolveType(baseType);
            baseProto = baseType.Handle.prototype;
            for (name in baseProto) {
                if (baseProto.hasOwnProperty(name) && baseType.Handle.memberType[name]) {
                    if (!(name