~ubuntu-branches/ubuntu/vivid/emscripten/vivid

    name = makeLegalFunctionName(name);

        'toWireType': function(destructors, o) {

            // TODO: assert if anything else is given?

            return undefined;

        },

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

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

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

function __embind_register_memory_view(rawType, name) {

    var typeMapping = [

        Int8Array,

        Uint8Array,

        Int16Array,

        Uint16Array,

        Int32Array,

        Uint32Array,

        Float32Array,

        Float64Array,        

    ];

 

    name = readLatin1String(name);

    registerType(rawType, {

        name: name,

        'fromWireType': function(handle) {

            var type = HEAPU32[handle >> 2];

            var size = HEAPU32[(handle >> 2) + 1]; // in elements

            var data = HEAPU32[(handle >> 2) + 2]; // byte offset into emscripten heap

            var TA = typeMapping[type];

            return new TA(HEAP8.buffer, data, size);

        },

    });

}

 

                    throw new TypeError("Incorrect number of tuple elements for " + reg.name + ": expected=" + elementsLength + ", actual=" + o.length);

                }

            if (destructors !== null) {

                destructors.push(this.rawDestructor, ptr);

            }

                    if (destructors !== null) {

                        destructors.push(this.rawDestructor, ptr);

                    }

ClassHandle.prototype.isAliasOf = function(other) {

    if (!(this instanceof ClassHandle)) {

        return false;

    }

    if (!(other instanceof ClassHandle)) {

        return false;

    }

 

    var leftClass = this.$$.ptrType.registeredClass;

    var left = this.$$.ptr;

    var rightClass = other.$$.ptrType.registeredClass;

    var right = other.$$.ptr;

 

    while (leftClass.baseClass) {

        left = leftClass.upcast(left);

        leftClass = leftClass.baseClass;

    }

 

    while (rightClass.baseClass) {

        right = rightClass.upcast(right);

        rightClass = rightClass.baseClass;

    }

    

    return leftClass === rightClass && left === right;

};

 

function throwInstanceAlreadyDeleted(obj) {

    throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');

}

 

        throwInstanceAlreadyDeleted(this);

ClassHandle.prototype['delete'] = function ClassHandle_delete() {

        throwInstanceAlreadyDeleted(this);

    }

    if (this.$$.deleteScheduled) {

        throwBindingError('Object already scheduled for deletion');

 

var deletionQueue = [];

 

ClassHandle.prototype['isDeleted'] = function isDeleted() {

    return !this.$$.ptr;

};

 

ClassHandle.prototype['deleteLater'] = function deleteLater() {

    if (!this.$$.ptr) {

        throwInstanceAlreadyDeleted(this);

    }

    if (this.$$.deleteScheduled) {

        throwBindingError('Object already scheduled for deletion');

    }

    deletionQueue.push(this);

    if (deletionQueue.length === 1 && delayFunction) {

        delayFunction(flushPendingDeletes);

    }

    this.$$.deleteScheduled = true;

    return this;

};

 

function flushPendingDeletes() {

    while (deletionQueue.length) {

        var obj = deletionQueue.pop();

        obj.$$.deleteScheduled = false;

        obj['delete']();

    }

}

Module['flushPendingDeletes'] = flushPendingDeletes;

 

var delayFunction;

Module['setDelayFunction'] = function setDelayFunction(fn) {

    delayFunction = fn;

    if (deletionQueue.length && delayFunction) {

        delayFunction(flushPendingDeletes);

    }

};