path: root/src/embind/embind.js

/*global Module*/
/*global _malloc, _free, _memcpy*/
/*global FUNCTION_TABLE, HEAP32*/
/*global Pointer_stringify, writeStringToMemory*/
/*global __emval_register, _emval_handle_array, __emval_decref*/

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 = {};

function registerType(type, name, info) {
    if (!type) {
        throw new BindingError('type "' + name + '" must have a positive integer typeid pointer');
    }
    if (typeRegistry.hasOwnProperty(type)) {
        throw new BindingError("Cannot register type '" + name + "' twice");
    }
    typeRegistry[type] = info;
}

function __embind_register_void(voidType, name) {
    name = Pointer_stringify(name);
    registerType(voidType, name, {
        name: name,
        fromWireType: function() {
            return undefined;
        }
    });
}

function __embind_register_bool(boolType, name, trueValue, falseValue) {
    name = Pointer_stringify(name);
    registerType(boolType, name, {
        name: name,
        toWireType: function(destructors, o) {
            return o ? trueValue : falseValue;
        },
        fromWireType: function(wt) {
            // ambiguous emscripten ABI: sometimes return values are
            // true or false, and sometimes integers (0 or 1)
            return !!wt;
        },
    });
}

function __embind_register_integer(primitiveType, name) {
    name = Pointer_stringify(name);
    registerType(primitiveType, name, {
        name: name,
        toWireType: function(destructors, value) {
            if (typeof value !== "number") {
                throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + name);
            }
            return value | 0;
        },
        fromWireType: function(value) {
            return value;
        }
    });
}

function __embind_register_float(primitiveType, name) {
    name = Pointer_stringify(name);
    registerType(primitiveType, name, {
        name: name,
        toWireType: function(destructors, value) {
            if (typeof value !== "number") {
                throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + name);
            }
            return value;
        },
        fromWireType: function(value) {
            return value;
        }
    });
}

function __embind_register_cstring(stringType, name) {
    name = Pointer_stringify(name);
    registerType(stringType, name, {
        name: name,
        toWireType: function(destructors, value) {
            var ptr = _malloc(value.length + 1);
            writeStringToMemory(value, ptr);
            destructors.push(_free);
            destructors.push(ptr);
            return ptr;
        },
        fromWireType: function(value) {
            var rv = Pointer_stringify(value);
            _free(value);
            return rv;
        }
    });
}

function __embind_register_emval(emvalType, name) {
    name = Pointer_stringify(name);
    registerType(emvalType, name, {
        name: name,
        toWireType: function(destructors, value) {
            return __emval_register(value);
        },
        fromWireType: function(handle) {
            var rv = _emval_handle_array[handle].value;
            __emval_decref(handle);
            return rv;
        }
    });
}

var BindingError = Error;
/** @expose */
Module.BindingError = BindingError;

function typeName(typeID) {
    // could use our carnal knowledge of RTTI but for now just return the pointer...
    return typeID;
}

function requireRegisteredType(type, humanName) {
    var impl = typeRegistry[type];
    if (undefined === impl) {
        throw new BindingError(humanName + " has unknown type: " + typeName(type));
    }
    return impl;
}

function requireArgumentTypes(argCount, argTypes, name)