/*global LibraryManager, mergeInto*/

/*global Module, asm*/

/*global _malloc, _free, _memcpy*/

/*global FUNCTION_TABLE, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64*/

/*global readLatin1String*/

/*global __emval_register, emval_handle_array, __emval_decref*/

/*global ___getTypeName*/

/*global requireHandle*/

/*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. */

// -- jshint doesn't understand library syntax, so we need to specifically tell it about the symbols we define

/*global typeDependencies, flushPendingDeletes, getTypeName, getBasestPointer, throwBindingError, UnboundTypeError, _embind_repr, registeredInstances, registeredTypes, getShiftFromSize*/

/*global ensureOverloadTable, requireFunction, awaitingDependencies, makeLegalFunctionName, embind_charCodes:true, registerType, createNamedFunction, RegisteredPointer, throwInternalError*/

/*global simpleReadValueFromPointer, floatReadValueFromPointer, integerReadValueFromPointer, enumReadValueFromPointer, replacePublicSymbol, craftInvokerFunction, tupleRegistrations*/

/*global ClassHandle, makeClassHandle, structRegistrations, whenDependentTypesAreResolved, BindingError, deletionQueue, delayFunction:true, upcastPointer*/

/*global exposePublicSymbol, heap32VectorToArray, new_, RegisteredPointer_getPointee, RegisteredPointer_destructor, RegisteredPointer_deleteObject, char_0, char_9*/

/*global getInheritedInstanceCount, getLiveInheritedInstances, setDelayFunction, InternalError, runDestructors*/

/*global requireRegisteredType, unregisterInheritedInstance, registerInheritedInstance, PureVirtualError, throwUnboundTypeError*/

/*global assert, validateThis, downcastPointer, registeredPointers, RegisteredClass, getInheritedInstance, ClassHandle_isAliasOf, ClassHandle_clone, ClassHandle_isDeleted, ClassHandle_deleteLater*/

/*global throwInstanceAlreadyDeleted, runDestructor, shallowCopyInternalPointer*/

/*global RegisteredPointer_fromWireType, constNoSmartPtrRawPointerToWireType, nonConstNoSmartPtrRawPointerToWireType, genericPointerToWireType*/

var LibraryEmbind = {

$InternalError__postset: "InternalError = Module['InternalError'] = extendError(Error, 'InternalError');",

$InternalError__deps: ['$extendError'],

$InternalError: undefined,

$BindingError__postset: "BindingError = Module['BindingError'] = extendError(Error, 'BindingError');",

$BindingError__deps: ['$extendError'],

$BindingError: undefined,

$UnboundTypeError__postset: "UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');",

$UnboundTypeError__deps: ['$extendError'],

$UnboundTypeError: undefined,

$PureVirtualError__postset: "PureVirtualError = Module['PureVirtualError'] = extendError(Error, 'PureVirtualError');",

$PureVirtualError__deps: ['$extendError'],

$PureVirtualError: undefined,

$init_embind__deps: [

'$getInheritedInstanceCount', '$getLiveInheritedInstances',

'$flushPendingDeletes', '$setDelayFunction'],

$init_embind__postset: 'init_embind();',

$init_embind: function() {

Module['getInheritedInstanceCount'] = getInheritedInstanceCount;

Module['getLiveInheritedInstances'] = getLiveInheritedInstances;

Module['flushPendingDeletes'] = flushPendingDeletes;

Module['setDelayFunction'] = setDelayFunction;

},

$throwInternalError__deps: ['$InternalError'],

$throwInternalError: function(message) {

throw new InternalError(message);

},

$throwBindingError__deps: ['$BindingError'],

$throwBindingError: function(message) {

throw new BindingError(message);

},

$throwUnboundTypeError__deps: ['$registeredTypes', '$typeDependencies', '$UnboundTypeError', '$getTypeName'],

$throwUnboundTypeError: function(message, types) {

var unboundTypes = [];

var seen = {};

function visit(type) {

if (seen[type]) {

return;

}

if (registeredTypes[type]) {

return;

}

if (typeDependencies[type]) {

typeDependencies[type].forEach(visit);

return;

}

unboundTypes.push(type);

seen[type] = true;

}

types.forEach(visit);

throw new UnboundTypeError(message + ': ' + unboundTypes.map(getTypeName).join([', ']));

},

// Creates a function overload resolution table to the given method 'methodName' in the given prototype,

// if the overload table doesn't yet exist.

$ensureOverloadTable__deps: ['$throwBindingError'],

$ensureOverloadTable: function(proto, methodName, humanName) {

if (undefined === proto[methodName].overloadTable) {

var prevFunc = proto[methodName];

// Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.

proto[methodName] = function() {

// TODO This check can be removed in -O3 level "unsafe" optimizations.

if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {

throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");

}

return proto[methodName].overloadTable[arguments.length].apply(this, arguments);

};

// Move the previous function into the overload table.

proto[methodName].overloadTable = [];

proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;

}

},

/*

Registers a symbol (function, class, enum, ...) as part of the Module JS object so that

hand-written code is able to access that symbol via 'Module.name'.

name: The name of the symbol that's being exposed.

value: The object itself to expose (function, class, ...)

numArguments: For functions, specifies the number of arguments the function takes in. For other types, unused and undefined.

To implement support for multiple overloads of a function, an 'overload selector' function is used. That selector function chooses

the appropriate overload to call from an function overload table. This selector function is only used if multiple overloads are

actually registered, since it carries a slight performance penalty. */

$exposePublicSymbol__deps: ['$ensureOverloadTable', '$throwBindingError'],

$exposePublicSymbol: function(name, value, numArguments) {

if (Module.hasOwnProperty(name)) {

if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) {

throwBindingError("Cannot register public name '" + name + "' twice");

}

// We are exposing a function with the same name as an existing function. Create an overload table and a function selector

// that routes between the two.

ensureOverloadTable(Module, name, name);

if (Module.hasOwnProperty(numArguments)) {

throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");

}

// Add the new function into the overload table.

Module[name].overloadTable[numArguments] = value;

}

else {

Module[name] = value;

if (undefined !== numArguments) {

Module[name].numArguments = numArguments;

}

}

},

$replacePublicSymbol__deps: ['$throwInternalError'],

$replacePublicSymbol: function(name, value, numArguments) {

if (!Module.hasOwnProperty(name)) {

throwInternalError('Replacing nonexistant public symbol');

}

// If there's an overload table for this symbol, replace the symbol in the overload table instead.

if (undefined !== Module[name].overloadTable && undefined !== numArguments) {

Module[name].overloadTable[numArguments] = value;

}

else {

Module[name] = value;

}

},

// from https://github.com/imvu/imvujs/blob/master/src/error.js

$extendError__deps: ['$createNamedFunction'],

$extendError: function(baseErrorType, errorName) {

var errorClass = createNamedFunction(errorName, function(message) {

this.name = errorName;

this.message = message;

var stack = (new Error(message)).stack;

if (stack !== undefined) {

this.stack = this.toString() + '\n' +

stack.replace(/^Error(:[^\n]*)?\n/, '');

}

});

errorClass.prototype = Object.create(baseErrorType.prototype);

errorClass.prototype.constructor = errorClass;

errorClass.prototype.toString = function() {

if (this.message === undefined) {

return this.name;

} else {

return this.name + ': ' + this.message;

}

};

return errorClass;

},

// from https://github.com/imvu/imvujs/blob/master/src/function.js

$createNamedFunction__deps: ['$makeLegalFunctionName'],

$createNamedFunction: function(name, body) {

name = makeLegalFunctionName(name);

/*jshint evil:true*/

return new Function(

"body",

"return function " + name + "() {\n" +

" \"use strict\";" +

" return body.apply(this, arguments);\n" +

"};\n"

)(body);

},

embind_repr: function(v) {

if (v === null) {

return 'null';

}

var t = typeof v;

if (t === 'object' || t === 'array' || t === 'function') {

return v.toString();

} else {

return '' + v;

}

},

// raw pointer -> instance

$registeredInstances__deps: ['$init_embind'],

$registeredInstances: {},

$getBasestPointer__deps: ['$throwBindingError'],

$getBasestPointer: function(class_, ptr) {

if (ptr === undefined) {

throwBindingError('ptr should not be undefined');

}

while (class_.baseClass) {

ptr = class_.upcast(ptr);

class_ = class_.baseClass;

}

return ptr;

},

$registerInheritedInstance__deps: ['$registeredInstances', '$getBasestPointer', '$throwBindingError'],

$registerInheritedInstance: function(class_, ptr, instance) {

ptr = getBasestPointer(class_, ptr);

if (registeredInstances.hasOwnProperty(ptr)) {

throwBindingError('Tried to register registered instance: ' + ptr);

} else {

registeredInstances[ptr] = instance;

}

},

$unregisterInheritedInstance__deps: ['$registeredInstances', '$getBasestPointer', '$throwBindingError'],

$unregisterInheritedInstance: function(class_, ptr) {

ptr = getBasestPointer(class_, ptr);

if (registeredInstances.hasOwnProperty(ptr)) {

delete registeredInstances[ptr];

} else {

throwBindingError('Tried to unregister unregistered instance: ' + ptr);

}

},

$getInheritedInstance__deps: ['$registeredInstances', '$getBasestPointer'],

$getInheritedInstance: function(class_, ptr) {

ptr = getBasestPointer(class_, ptr);

return registeredInstances[ptr];

},

$getInheritedInstanceCount__deps: ['$registeredInstances'],

$getInheritedInstanceCount: function() {

return Object.keys(registeredInstances).length;

},

$getLiveInheritedInstances__deps: ['$registeredInstances'],

$getLiveInheritedInstances: function() {

var rv = [];

for (var k in registeredInstances) {

if (registeredInstances.hasOwnProperty(k)) {

rv.push(registeredInstances[k]);

}

}

return rv;

},

// typeID -> { toWireType: ..., fromWireType: ... }

$registeredTypes: {},

// typeID -> [callback]

$awaitingDependencies: {},

// typeID -> [dependentTypes]

$typeDependencies: {},

// class typeID -> {pointerType: ..., constPointerType: ...}

$registeredPointers: {},

$registerType__deps: [

'$awaitingDependencies', '$registeredTypes',

'$typeDependencies', '$throwBindingError',

'$whenDependentTypesAreResolved'],

$registerType: function(rawType, registeredInstance, options) {

options = options || {};

if (!('argPackAdvance' in registeredInstance)) {

throw new TypeError('registerType registeredInstance requires argPackAdvance');

}

var name = registeredInstance.name;

if (!rawType) {

throwBindingError('type "' + name + '" must have a positive integer typeid pointer');

}

if (registeredTypes.hasOwnProperty(rawType)) {

if (options.ignoreDuplicateRegistrations) {

return;

} else {

throwBindingError("Cannot register type '" + name + "' twice");

}

}

registeredTypes[rawType] = registeredInstance;

delete typeDependencies[rawType];

if (awaitingDependencies.hasOwnProperty(rawType)) {

var callbacks = awaitingDependencies[rawType];

delete awaitingDependencies[rawType];

callbacks.forEach(function(cb) {

cb();

});

}

},

$whenDependentTypesAreResolved__deps: [

'$awaitingDependencies', '$registeredTypes',

'$typeDependencies', '$throwInternalError'],

$whenDependentTypesAreResolved: function(myTypes, dependentTypes, getTypeConverters) {

myTypes.forEach(function(type) {

typeDependencies[type] = dependentTypes;

});

function onComplete(typeConverters) {

var myTypeConverters = getTypeConverters(typeConverters);

if (myTypeConverters.length !== myTypes.length) {

throwInternalError('Mismatched type converter count');

}

for (var i = 0; i < myTypes.length; ++i) {

registerType(myTypes[i], myTypeConverters[i]);

}

}

var typeConverters = new Array(dependentTypes.length);

var unregisteredTypes = [];

var registered = 0;

dependentTypes.forEach(function(dt, i) {

if (registeredTypes.hasOwnProperty(dt)) {

typeConverters[i] = registeredTypes[dt];

} else {

unregisteredTypes.push(dt);

if (!awaitingDependencies.hasOwnProperty(dt)) {

awaitingDependencies[dt] = [];

}

awaitingDependencies[dt].push(function() {

typeConverters[i] = registeredTypes[dt];

++registered;

if (registered === unregisteredTypes.length) {

onComplete(typeConverters);

}

});

}

});

if (0 === unregisteredTypes.length) {

onComplete(typeConverters);

}

},

$embind_charCodes__deps: ['$embind_init_charCodes'],

$embind_charCodes__postset: "embind_init_charCodes()",

$embind_charCodes: undefined,

$embind_init_charCodes: function() {

var codes = new Array(256);

for (var i = 0; i < 256; ++i) {

codes[i] = String.fromCharCode(i);

}

embind_charCodes = codes;

},

$readLatin1String__deps: ['$embind_charCodes'],

$readLatin1String: function(ptr) {

var ret = "";

var c = ptr;

while (HEAPU8[c]) {

ret += embind_charCodes[HEAPU8[c++]];

}

return ret;

},

$getTypeName__deps: ['free', '$readLatin1String'],

$getTypeName: function(type) {

var ptr = ___getTypeName(type);

var rv = readLatin1String(ptr);

_free(ptr);

return rv;

},

$heap32VectorToArray: function(count, firstElement) {

var array = [];

for (var i = 0; i < count; i++) {

array.push(HEAP32[(firstElement >> 2) + i]);

}

return array;

},

$requireRegisteredType__deps: [

'$registeredTypes', '$getTypeName', '$throwBindingError'],

$requireRegisteredType: function(rawType, humanName) {

var impl = registeredTypes[rawType];

if (undefined === impl) {

throwBindingError(humanName + " has unknown type " + getTypeName(rawType));

}

return impl;

},

_embind_register_void__deps: ['$readLatin1String', '$registerType'],

_embind_register_void: function(rawType, name) {

name = readLatin1String(name);

registerType(rawType, {

isVoid: true, // void return values can be optimized out sometimes

name: name,

'argPackAdvance': 0,

'fromWireType': function() {

return undefined;

},

'toWireType': function(destructors, o) {

// TODO: assert if anything else is given?

return undefined;

},

});

},

_embind_register_bool__deps: [

'$getShiftFromSize', '$readLatin1String', '$registerType'],

_embind_register_bool: function(rawType, name, size, trueValue, falseValue) {

var shift = getShiftFromSize(size);

name = readLatin1String(name);

registerType(rawType, {

name: name,

'fromWireType': function(wt) {

// ambiguous emscripten ABI: sometimes return values are

// true or false, and sometimes integers (0 or 1)

return !!wt;

},

'toWireType': function(destructors, o) {

return o ? trueValue : falseValue;

},

'argPackAdvance': 8,

'readValueFromPointer': function(pointer) {

// TODO: if heap is fixed (like in asm.js) this could be executed outside

var heap;

if (size === 1) {

heap = HEAP8;

} else if (size === 2) {

heap = HEAP16;

} else if (size === 4) {

heap = HEAP32;

} else {

throw new TypeError("Unknown boolean type size: " + name);

}

return this['fromWireType'](heap[pointer >> shift]);

},

destructorFunction: null, // This type does not need a destructor

});

},

$getShiftFromSize__deps: [],

$getShiftFromSize: function(size) {

switch (size) {

case 1: return 0;

case 2: return 1;

case 4: return 2;

case 8: return 3;

default:

throw new TypeError('Unknown type size: ' + size);

}

},

$integerReadValueFromPointer__deps: [],

$integerReadValueFromPointer: function(name, shift, signed) {

// integers are quite common, so generate very specialized functions

switch (shift) {

case 0: return signed ?

function readS8FromPointer(pointer) { return HEAP8[pointer]; } :

function readU8FromPointer(pointer) { return HEAPU8[pointer]; };

case 1: return signed ?

function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } :

function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; };

case 2: return signed ?

function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } :

function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; };

default:

throw new TypeError("Unknown integer type: " + name);

}

},

$enumReadValueFromPointer__deps: [],

$enumReadValueFromPointer: function(name, shift, signed) {

switch (shift) {

case 0: return function(pointer) {

var heap = signed ? HEAP8 : HEAPU8;

return this['fromWireType'](heap[pointer]);

};

case 1: return function(pointer) {

var heap = signed ? HEAP16 : HEAPU16;

return this['fromWireType'](heap[pointer >> 1]);

};

case 2: return function(pointer) {

var heap = signed ? HEAP32 : HEAPU32;

return this['fromWireType'](heap[pointer >> 2]);

};

default:

throw new TypeError("Unknown integer type: " + name);

}

},

$floatReadValueFromPointer__deps: [],

$floatReadValueFromPointer: function(name, shift) {

switch (shift) {

case 2: return function(pointer) {

return this['fromWireType'](HEAPF32[pointer >> 2]);

};

case 3: return function(pointer) {

return this['fromWireType'](HEAPF64[pointer >> 3]);

};

default:

throw new TypeError("Unknown float type: " + name);

}

},

// When converting a number from JS to C++ side, the valid range of the number is

// [minRange, maxRange], inclusive.

_embind_register_integer__deps: [

'embind_repr', '$getShiftFromSize', '$integerReadValueFromPointer',

'$readLatin1String', '$registerType'],

_embind_register_integer: function(primitiveType, name, size, minRange, maxRange) {

name = readLatin1String(name);

if (maxRange === -1) { // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come out as 'i32 -1'. Always treat those as max u32.

maxRange = 4294967295;

}

var shift = getShiftFromSize(size);

var fromWireType = function(value) {

return value;

};

if (minRange === 0) {

var bitshift = 32 - 8*size;

fromWireType = function(value) {

return (value << bitshift) >>> bitshift;

};

}

registerType(primitiveType, {

name: name,

'fromWireType': fromWireType,

'toWireType': function(destructors, value) {

// todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could

// avoid the following two if()s and assume value is of proper type.

if (typeof value !== "number" && typeof value !== "boolean") {

throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);

}

if (value < minRange || value > maxRange) {

throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ', ' + maxRange + ']!');

}

return value | 0;

},

'argPackAdvance': 8,

'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0),

destructorFunction: null, // This type does not need a destructor

});

},

_embind_register_float__deps: [

'embind_repr', '$floatReadValueFromPointer', '$getShiftFromSize',

'$readLatin1String', '$registerType'],

_embind_register_float: function(rawType, name, size) {

var shift = getShiftFromSize(size);

name = readLatin1String(name);

registerType(rawType, {

name: name,

'fromWireType': function(value) {

return value;

},

'toWireType': function(destructors, value) {

// todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could

// avoid the following if() and assume value is of proper type.

if (typeof value !== "number" && typeof value !== "boolean") {

throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);

}

return value;

},

'argPackAdvance': 8,

'readValueFromPointer': floatReadValueFromPointer(name, shift),

destructorFunction: null, // This type does not need a destructor

});

},

// For types whose wire types are 32-bit pointers.

$simpleReadValueFromPointer: function(pointer) {

return this['fromWireType'](HEAPU32[pointer >> 2]);

},

_embind_register_std_string__deps: [

'free', 'malloc', '$readLatin1String', '$registerType',

'$simpleReadValueFromPointer', '$throwBindingError'],

_embind_register_std_string: function(rawType, name) {

name = readLatin1String(name);

registerType(rawType, {

name: name,

'fromWireType': function(value) {

var length = HEAPU32[value >> 2];

var a = new Array(length);

for (var i = 0; i < length; ++i) {

a[i] = String.fromCharCode(HEAPU8[value + 4 + i]);

}

_free(value);

return a.join('');

},

'toWireType': function(destructors, value) {

if (value instanceof ArrayBuffer) {

value = new Uint8Array(value);

}

function getTAElement(ta, index) {

return ta[index];

}

function getStringElement(string, index) {

return string.charCodeAt(index);

}

var getElement;

if (value instanceof Uint8Array) {

getElement = getTAElement;

} else if (value instanceof Int8Array) {

getElement = getTAElement;

} else if (typeof value === 'string') {

getElement = getStringElement;

} else {

throwBindingError('Cannot pass non-string to std::string');

}

// assumes 4-byte alignment

var length = value.length;

var ptr = _malloc(4 + length);

HEAPU32[ptr >> 2] = length;

for (var i = 0; i < length; ++i) {

var charCode = getElement(value, i);

if (charCode > 255) {

_free(ptr);

throwBindingError('String has UTF-16 code units that do not fit in 8 bits');

}

HEAPU8[ptr + 4 + i] = charCode;

}

if (destructors !== null) {

destructors.push(_free, ptr);

}

return ptr;

},

'argPackAdvance': 8,

'readValueFromPointer': simpleReadValueFromPointer,

destructorFunction: function(ptr) { _free(ptr); },

});

},

_embind_register_std_wstring__deps: [

'free', 'malloc', '$readLatin1String', '$registerType',

'$simpleReadValueFromPointer'],

_embind_register_std_wstring: function(rawType, charSize, name) {

// nb. do not cache HEAPU16 and HEAPU32, they may be destroyed by enlargeMemory().

name = readLatin1String(name);

var getHeap, shift;

if (charSize === 2) {

getHeap = function() { return HEAPU16; };

shift = 1;

} else if (charSize === 4) {

getHeap = function() { return HEAPU32; };

shift = 2;

}

registerType(rawType, {

name: name,

'fromWireType': function(value) {

var HEAP = getHeap();

var length = HEAPU32[value >> 2];

var a = new Array(length);

var start = (value + 4) >> shift;

for (var i = 0; i < length; ++i) {

a[i] = String.fromCharCode(HEAP[start + i]);

}

_free(value);

return a.join('');

},

'toWireType': function(destructors, value) {

// assumes 4-byte alignment

var HEAP = getHeap();

var length = value.length;

var ptr = _malloc(4 + length * charSize);

HEAPU32[ptr >> 2] = length;

var start = (ptr + 4) >> shift;

for (var i = 0; i < length; ++i) {

HEAP[start + i] = value.charCodeAt(i);

}

if (destructors !== null) {

destructors.push(_free, ptr);

}

return ptr;

},

'argPackAdvance': 8,

'readValueFromPointer': simpleReadValueFromPointer,

destructorFunction: function(ptr) { _free(ptr); },

});

},

_embind_register_emval__deps: [

'_emval_decref', '$emval_handle_array', '_emval_register',

'$readLatin1String', '$registerType', '$simpleReadValueFromPointer'],

_embind_register_emval: function(rawType, name) {

name = readLatin1String(name);

registerType(rawType, {

name: name,

'fromWireType': function(handle) {

var rv = emval_handle_array[handle].value;

__emval_decref(handle);

return rv;

},

'toWireType': function(destructors, value) {

return __emval_register(value);

},

'argPackAdvance': 8,

'readValueFromPointer': simpleReadValueFromPointer,

destructorFunction: null, // This type does not need a destructor

// TODO: do we need a deleteObject here? write a test where

// emval is passed into JS via an interface

});

},

_embind_register_memory_view__deps: ['$readLatin1String', '$registerType'],

_embind_register_memory_view: function(rawType, dataTypeIndex, name) {

var typeMapping = [

Int8Array,

Uint8Array,

Int16Array,

Uint16Array,

Int32Array,

Uint32Array,

Float32Array,

Float64Array,

];

var TA = typeMapping[dataTypeIndex];

function decodeMemoryView(handle) {

handle = handle >> 2;

var heap = HEAPU32;

var size = heap[handle]; // in elements

var data = heap[handle + 1]; // byte offset into emscripten heap

return new TA(heap['buffer'], data, size);

}

name = readLatin1String(name);

registerType(rawType, {

name: name,

'fromWireType': decodeMemoryView,

'argPackAdvance': 8,

'readValueFromPointer': decodeMemoryView,

}, {

ignoreDuplicateRegistrations: true,

});

},

$runDestructors: function(destructors) {

while (destructors.length) {

var ptr = destructors.pop();

var del = destructors.pop();

del(ptr);

}

},

// Function implementation of operator new, per

// http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf

// 13.2.2

// ES3

$new___deps: ['$createNamedFunction'],

$new_: function(constructor, argumentList) {

if (!(constructor instanceof Function)) {

throw new TypeError('new_ called with constructor type ' + typeof(constructor) + " which is not a function");

}

/*

* Previously, the following line was just:

function dummy() {};

* Unfortunately, Chrome was preserving 'dummy' as the object's name, even though at creation, the 'dummy' has the

* correct constructor name. Thus, objects created with IMVU.new would show up in the debugger as 'dummy', which

* isn't very helpful. Using IMVU.createNamedFunction addresses the issue. Doublely-unfortunately, there's no way

* to write a test for this behavior. -NRD 2013.02.22

*/

var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function(){});

dummy.prototype = constructor.prototype;

var obj = new dummy;

var r = constructor.apply(obj, argumentList);

return (r instanceof Object) ? r : obj;

},

// The path to interop from JS code to C++ code:

// (hand-written JS code) -> (autogenerated JS invoker) -> (template-generated C++ invoker) -> (target C++ function)

// craftInvokerFunction generates the JS invoker function for each function exposed to JS through embind.

$craftInvokerFunction__deps: [

'$makeLegalFunctionName', '$new_', '$runDestructors', '$throwBindingError'],

$craftInvokerFunction: function(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {

// humanName: a human-readable string name for the function to be generated.

// argTypes: An array that contains the embind type objects for all types in the function signature.

// argTypes[0] is the type object for the function return value.

// argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method.

// argTypes[2...] are the actual function parameters.

// classType: The embind type object for the class to be bound, or null if this is not a method of a class.

// cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code.

// cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling.

var argCount = argTypes.length;

if (argCount < 2) {

throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");

}

var isClassMethodFunc = (argTypes[1] !== null && classType !== null);

// Free functions with signature "void function()" do not need an invoker that marshalls between wire types.

// TODO: This omits argument count check - enable only at -O3 or similar.

// if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) {

// return FUNCTION_TABLE[fn];

// }

var argsList = "";

var argsListWired = "";

for(var i = 0; i < argCount - 2; ++i) {

argsList += (i!==0?", ":"")+"arg"+i;

argsListWired += (i!==0?", ":"")+"arg"+i+"Wired";

}

var invokerFnBody =

"return function "+makeLegalFunctionName(humanName)+"("+argsList+") {\n" +

"if (arguments.length !== "+(argCount - 2)+") {\n" +

"throwBindingError('function "+humanName+" called with ' + arguments.length + ' arguments, expected "+(argCount - 2)+" args!');\n" +

"}\n";

#if EMSCRIPTEN_TRACING

invokerFnBody += "Module.emscripten_trace_enter_context('embind::" + humanName + "');\n";

#endif

// Determine if we need to use a dynamic stack to store the destructors for the function parameters.

// TODO: Remove this completely once all function invokers are being dynamically generated.

var needsDestructorStack = false;

for(var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here.

if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack

needsDestructorStack = true;

break;

}

}

if (needsDestructorStack) {

invokerFnBody +=

"var destructors = [];\n";

}

var dtorStack = needsDestructorStack ? "destructors" : "null";

var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];

var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];

#if EMSCRIPTEN_TRACING

args1.push("Module");

args2.push(Module);

#endif

if (isClassMethodFunc) {

invokerFnBody += "var thisWired = classParam.toWireType("+dtorStack+", this);\n";

}

for(var i = 0; i < argCount - 2; ++i) {

invokerFnBody += "var arg"+i+"Wired = argType"+i+".toWireType("+dtorStack+", arg"+i+"); // "+argTypes[i+2].name+"\n";

args1.push("argType"+i);

args2.push(argTypes[i+2]);

}

if (isClassMethodFunc) {

argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;

}

var returns = (argTypes[0].name !== "void");

invokerFnBody +=

(returns?"var rv = ":"") + "invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";

if (needsDestructorStack) {

invokerFnBody += "runDestructors(destructors);\n";

} else {

for(var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.

var paramName = (i === 1 ? "thisWired" : ("arg"+(i - 2)+"Wired"));

if (argTypes[i].destructorFunction !== null) {

invokerFnBody += paramName+"_dtor("+paramName+"); // "+argTypes[i].name+"\n";

args1.push(paramName+"_dtor");

args2.push(argTypes[i].destructorFunction);

}

}

}

if (returns) {

invokerFnBody += "var ret = retType.fromWireType(rv);\n" +

#if EMSCRIPTEN_TRACING

"Module.emscripten_trace_exit_context();\n" +

#endif

"return ret;\n";

} else {

#if EMSCRIPTEN_TRACING

invokerFnBody += "Module.emscripten_trace_exit_context();\n";

#endif

}

invokerFnBody += "}\n";

args1.push(invokerFnBody);

var invokerFunction = new_(Function, args1).apply(null, args2);

return invokerFunction;

},

$requireFunction__deps: ['$readLatin1String', '$throwBindingError'],

$requireFunction: function(signature, rawFunction) {

signature = readLatin1String(signature);

function makeDynCaller(dynCall) {

var args = [];

for (var i = 1; i < signature.length; ++i) {

args.push('a' + i);

}

var name = 'dynCall_' + signature + '_' + rawFunction;

var body = 'return function ' + name + '(' + args.join(', ') + ') {\n';

body += ' return dynCall(rawFunction' + (args.length ? ', ' : '') + args.join(', ') + ');\n';

body += '};\n';

return (new Function('dynCall', 'rawFunction', body))(dynCall, rawFunction);

}

var fp;

if (Module['FUNCTION_TABLE_' + signature] !== undefined) {

fp = Module['FUNCTION_TABLE_' + signature][rawFunction];

} else if (typeof FUNCTION_TABLE !== "undefined") {

fp = FUNCTION_TABLE[rawFunction];

} else {

// asm.js does not give direct access to the function tables,

// and thus we must go through the dynCall interface which allows

// calling into a signature's function table by pointer value.

//

// https://github.com/dherman/asm.js/issues/83

//

// This has three main penalties:

// - dynCall is another function call in the path from JavaScript to C++.

// - JITs may not predict through the function table indirection at runtime.

var dc = asm['dynCall_' + signature];

if (dc === undefined) {

// We will always enter this branch if the signature

// contains 'f' and PRECISE_F32 is not enabled.

//

// Try again, replacing 'f' with 'd'.

dc = asm['dynCall_' + signature.replace(/f/g, 'd')];

if (dc === undefined) {

throwBindingError("No dynCall invoker for signature: " + signature);

}

}

fp = makeDynCaller(dc);

}

if (typeof fp !== "function") {

throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);

}

return fp;

},

_embind_register_function__deps: [

'$craftInvokerFunction', '$exposePublicSymbol', '$heap32VectorToArray',

'$readLatin1String', '$replacePublicSymbol', '$requireFunction',

'$throwUnboundTypeError', '$whenDependentTypesAreResolved'],

_embind_register_function: function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {

var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);

name = readLatin1String(name);

rawInvoker = requireFunction(signature, rawInvoker);

exposePublicSymbol(name, function() {

throwUnboundTypeError('Cannot call ' + name + ' due to unbound types', argTypes);

}, argCount - 1);

whenDependentTypesAreResolved([], argTypes, function(argTypes) {

var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */);

replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn), argCount - 1);

return [];

});

},

$tupleRegistrations: {},

_embind_register_value_array__deps: [

'$tupleRegistrations', '$readLatin1String', '$requireFunction'],

_embind_register_value_array: function(

rawType,

name,

constructorSignature,

rawConstructor,

destructorSignature,

rawDestructor

) {

tupleRegistrations[rawType] = {

name: readLatin1String(name),