diff options
Diffstat (limited to 'examples/scala-js/tools/scalajsenv.js')
| -rw-r--r-- | examples/scala-js/tools/scalajsenv.js | 772 |
1 files changed, 772 insertions, 0 deletions
diff --git a/examples/scala-js/tools/scalajsenv.js b/examples/scala-js/tools/scalajsenv.js new file mode 100644 index 0000000..01a84ba --- /dev/null +++ b/examples/scala-js/tools/scalajsenv.js @@ -0,0 +1,772 @@ +/* Scala.js runtime support + * Copyright 2013 LAMP/EPFL + * Author: Sébastien Doeraene + */ + +/* ---------------------------------- * + * The top-level Scala.js environment * + * ---------------------------------- */ + +var ScalaJS = {}; + +// Get the environment info +ScalaJS.env = (typeof __ScalaJSEnv === "object" && __ScalaJSEnv) ? __ScalaJSEnv : {}; + +// Global scope +ScalaJS.g = + (typeof ScalaJS.env["global"] === "object" && ScalaJS.env["global"]) + ? ScalaJS.env["global"] + : ((typeof global === "object" && global && global["Object"] === Object) ? global : this); +ScalaJS.env["global"] = ScalaJS.g; + +// Where to send exports +ScalaJS.e = + (typeof ScalaJS.env["exportsNamespace"] === "object" && ScalaJS.env["exportsNamespace"]) + ? ScalaJS.env["exportsNamespace"] : ScalaJS.g; +ScalaJS.env["exportsNamespace"] = ScalaJS.e; + +// Freeze the environment info +ScalaJS.g["Object"]["freeze"](ScalaJS.env); + +// Other fields +ScalaJS.d = {}; // Data for types +ScalaJS.c = {}; // Scala.js constructors +ScalaJS.h = {}; // Inheritable constructors (without initialization code) +ScalaJS.i = {}; // Implementation class modules +ScalaJS.n = {}; // Module instances +ScalaJS.m = {}; // Module accessors +ScalaJS.is = {}; // isInstanceOf methods +ScalaJS.isArrayOf = {}; // isInstanceOfArrayOf methods +//!if asInstanceOfs != Unchecked +ScalaJS.as = {}; // asInstanceOf methods +ScalaJS.asArrayOf = {}; // asInstanceOfArrayOf methods +//!endif +ScalaJS.lastIDHash = 0; // last value attributed to an id hash code + +// Core mechanism + +ScalaJS.makeIsArrayOfPrimitive = function(primitiveData) { + return function(obj, depth) { + return !!(obj && obj.$classData && + (obj.$classData.arrayDepth === depth) && + (obj.$classData.arrayBase === primitiveData)); + } +}; + +//!if asInstanceOfs != Unchecked +ScalaJS.makeAsArrayOfPrimitive = function(isInstanceOfFunction, arrayEncodedName) { + return function(obj, depth) { + if (isInstanceOfFunction(obj, depth) || (obj === null)) + return obj; + else + ScalaJS.throwArrayCastException(obj, arrayEncodedName, depth); + } +}; +//!endif + +/** Encode a property name for runtime manipulation + * Usage: + * env.propertyName({someProp:0}) + * Returns: + * "someProp" + * Useful when the property is renamed by a global optimizer (like Closure) + * but we must still get hold of a string of that name for runtime + * reflection. + */ +ScalaJS.propertyName = function(obj) { + var result; + for (var prop in obj) + result = prop; + return result; +}; + +// Runtime functions + +ScalaJS.isScalaJSObject = function(obj) { + return !!(obj && obj.$classData); +}; + +//!if asInstanceOfs != Unchecked +ScalaJS.throwClassCastException = function(instance, classFullName) { +//!if asInstanceOfs == Compliant + throw new ScalaJS.c.jl_ClassCastException().init___T( + instance + " is not an instance of " + classFullName); +//!else + throw new ScalaJS.c.sjsr_UndefinedBehaviorError().init___jl_Throwable( + new ScalaJS.c.jl_ClassCastException().init___T( + instance + " is not an instance of " + classFullName)); +//!endif +}; + +ScalaJS.throwArrayCastException = function(instance, classArrayEncodedName, depth) { + for (; depth; --depth) + classArrayEncodedName = "[" + classArrayEncodedName; + ScalaJS.throwClassCastException(instance, classArrayEncodedName); +}; +//!endif + +ScalaJS.makeNativeArrayWrapper = function(arrayClassData, nativeArray) { + return new arrayClassData.constr(nativeArray); +}; + +ScalaJS.newArrayObject = function(arrayClassData, lengths) { + return ScalaJS.newArrayObjectInternal(arrayClassData, lengths, 0); +}; + +ScalaJS.newArrayObjectInternal = function(arrayClassData, lengths, lengthIndex) { + var result = new arrayClassData.constr(lengths[lengthIndex]); + + if (lengthIndex < lengths.length-1) { + var subArrayClassData = arrayClassData.componentData; + var subLengthIndex = lengthIndex+1; + var underlying = result.u; + for (var i = 0; i < underlying.length; i++) { + underlying[i] = ScalaJS.newArrayObjectInternal( + subArrayClassData, lengths, subLengthIndex); + } + } + + return result; +}; + +ScalaJS.checkNonNull = function(obj) { + return obj !== null ? obj : ScalaJS.throwNullPointerException(); +}; + +ScalaJS.throwNullPointerException = function() { + throw new ScalaJS.c.jl_NullPointerException().init___(); +}; + +ScalaJS.objectToString = function(instance) { + if (instance === void 0) + return "undefined"; + else + return instance.toString(); +}; + +ScalaJS.objectGetClass = function(instance) { + switch (typeof instance) { + case "string": + return ScalaJS.d.T.getClassOf(); + case "number": + var v = instance | 0; + if (v === instance) { // is the value integral? + if (ScalaJS.isByte(v)) + return ScalaJS.d.jl_Byte.getClassOf(); + else if (ScalaJS.isShort(v)) + return ScalaJS.d.jl_Short.getClassOf(); + else + return ScalaJS.d.jl_Integer.getClassOf(); + } else { + if (ScalaJS.isFloat(instance)) + return ScalaJS.d.jl_Float.getClassOf(); + else + return ScalaJS.d.jl_Double.getClassOf(); + } + case "boolean": + return ScalaJS.d.jl_Boolean.getClassOf(); + case "undefined": + return ScalaJS.d.sr_BoxedUnit.getClassOf(); + default: + if (instance === null) + ScalaJS.throwNullPointerException(); + else if (ScalaJS.is.sjsr_RuntimeLong(instance)) + return ScalaJS.d.jl_Long.getClassOf(); + else if (ScalaJS.isScalaJSObject(instance)) + return instance.$classData.getClassOf(); + else + return null; // Exception? + } +}; + +ScalaJS.objectClone = function(instance) { + if (ScalaJS.isScalaJSObject(instance) || (instance === null)) + return instance.clone__O(); + else + throw new ScalaJS.c.jl_CloneNotSupportedException().init___(); +}; + +ScalaJS.objectNotify = function(instance) { + // final and no-op in java.lang.Object + if (instance === null) + instance.notify__V(); +}; + +ScalaJS.objectNotifyAll = function(instance) { + // final and no-op in java.lang.Object + if (instance === null) + instance.notifyAll__V(); +}; + +ScalaJS.objectFinalize = function(instance) { + if (ScalaJS.isScalaJSObject(instance) || (instance === null)) + instance.finalize__V(); + // else no-op +}; + +ScalaJS.objectEquals = function(instance, rhs) { + if (ScalaJS.isScalaJSObject(instance) || (instance === null)) + return instance.equals__O__Z(rhs); + else if (typeof instance === "number") + return typeof rhs === "number" && ScalaJS.numberEquals(instance, rhs); + else + return instance === rhs; +}; + +ScalaJS.numberEquals = function(lhs, rhs) { + return ( + lhs === rhs // 0.0 === -0.0 to prioritize the Int case over the Double case + ) || ( + // are they both NaN? + (lhs !== lhs) && (rhs !== rhs) + ); +}; + +ScalaJS.objectHashCode = function(instance) { + switch (typeof instance) { + case "string": + return ScalaJS.m.sjsr_RuntimeString().hashCode__T__I(instance); + case "number": + return ScalaJS.m.sjsr_Bits().numberHashCode__D__I(instance); + case "boolean": + return instance ? 1231 : 1237; + case "undefined": + return 0; + default: + if (ScalaJS.isScalaJSObject(instance) || instance === null) + return instance.hashCode__I(); + else + return 42; // TODO? + } +}; + +ScalaJS.comparableCompareTo = function(instance, rhs) { + switch (typeof instance) { + case "string": +//!if asInstanceOfs != Unchecked + ScalaJS.as.T(rhs); +//!endif + return instance === rhs ? 0 : (instance < rhs ? -1 : 1); + case "number": +//!if asInstanceOfs != Unchecked + ScalaJS.as.jl_Number(rhs); +//!endif + return ScalaJS.numberEquals(instance, rhs) ? 0 : (instance < rhs ? -1 : 1); + case "boolean": +//!if asInstanceOfs != Unchecked + ScalaJS.asBoolean(rhs); +//!endif + return instance - rhs; // yes, this gives the right result + default: + return instance.compareTo__O__I(rhs); + } +}; + +ScalaJS.charSequenceLength = function(instance) { + if (typeof(instance) === "string") +//!if asInstanceOfs != Unchecked + return ScalaJS.uI(instance["length"]); +//!else + return instance["length"] | 0; +//!endif + else + return instance.length__I(); +}; + +ScalaJS.charSequenceCharAt = function(instance, index) { + if (typeof(instance) === "string") +//!if asInstanceOfs != Unchecked + return ScalaJS.uI(instance["charCodeAt"](index)) & 0xffff; +//!else + return instance["charCodeAt"](index) & 0xffff; +//!endif + else + return instance.charAt__I__C(index); +}; + +ScalaJS.charSequenceSubSequence = function(instance, start, end) { + if (typeof(instance) === "string") +//!if asInstanceOfs != Unchecked + return ScalaJS.as.T(instance["substring"](start, end)); +//!else + return instance["substring"](start, end); +//!endif + else + return instance.subSequence__I__I__jl_CharSequence(start, end); +}; + +ScalaJS.booleanBooleanValue = function(instance) { + if (typeof instance === "boolean") return instance; + else return instance.booleanValue__Z(); +}; + +ScalaJS.numberByteValue = function(instance) { + if (typeof instance === "number") return (instance << 24) >> 24; + else return instance.byteValue__B(); +}; +ScalaJS.numberShortValue = function(instance) { + if (typeof instance === "number") return (instance << 16) >> 16; + else return instance.shortValue__S(); +}; +ScalaJS.numberIntValue = function(instance) { + if (typeof instance === "number") return instance | 0; + else return instance.intValue__I(); +}; +ScalaJS.numberLongValue = function(instance) { + if (typeof instance === "number") + return ScalaJS.m.sjsr_RuntimeLong().fromDouble__D__sjsr_RuntimeLong(instance); + else + return instance.longValue__J(); +}; +ScalaJS.numberFloatValue = function(instance) { + if (typeof instance === "number") return ScalaJS.fround(instance); + else return instance.floatValue__F(); +}; +ScalaJS.numberDoubleValue = function(instance) { + if (typeof instance === "number") return instance; + else return instance.doubleValue__D(); +}; + +ScalaJS.isNaN = function(instance) { + return instance !== instance; +}; + +ScalaJS.isInfinite = function(instance) { + return !ScalaJS.g["isFinite"](instance) && !ScalaJS.isNaN(instance); +}; + +ScalaJS.propertiesOf = function(obj) { + var result = []; + for (var prop in obj) + result["push"](prop); + return result; +}; + +ScalaJS.systemArraycopy = function(src, srcPos, dest, destPos, length) { + var srcu = src.u; + var destu = dest.u; + if (srcu !== destu || destPos < srcPos || srcPos + length < destPos) { + for (var i = 0; i < length; i++) + destu[destPos+i] = srcu[srcPos+i]; + } else { + for (var i = length-1; i >= 0; i--) + destu[destPos+i] = srcu[srcPos+i]; + } +}; + +ScalaJS.systemIdentityHashCode = function(obj) { + if (ScalaJS.isScalaJSObject(obj)) { + var hash = obj["$idHashCode$0"]; + if (hash !== void 0) { + return hash; + } else { + hash = (ScalaJS.lastIDHash + 1) | 0; + ScalaJS.lastIDHash = hash; + obj["$idHashCode$0"] = hash; + return hash; + } + } else if (obj === null) { + return 0; + } else { + return ScalaJS.objectHashCode(obj); + } +}; + +// is/as for hijacked boxed classes (the non-trivial ones) + +ScalaJS.isByte = function(v) { + return (v << 24 >> 24) === v; +}; + +ScalaJS.isShort = function(v) { + return (v << 16 >> 16) === v; +}; + +ScalaJS.isInt = function(v) { + return (v | 0) === v; +}; + +ScalaJS.isFloat = function(v) { + return v !== v || ScalaJS.fround(v) === v; +}; + +//!if asInstanceOfs != Unchecked +ScalaJS.asUnit = function(v) { + if (v === void 0) + return v; + else + ScalaJS.throwClassCastException(v, "scala.runtime.BoxedUnit"); +}; + +ScalaJS.asBoolean = function(v) { + if (typeof v === "boolean" || v === null) + return v; + else + ScalaJS.throwClassCastException(v, "java.lang.Boolean"); +}; + +ScalaJS.asByte = function(v) { + if (ScalaJS.isByte(v) || v === null) + return v; + else + ScalaJS.throwClassCastException(v, "java.lang.Byte"); +}; + +ScalaJS.asShort = function(v) { + if (ScalaJS.isShort(v) || v === null) + return v; + else + ScalaJS.throwClassCastException(v, "java.lang.Short"); +}; + +ScalaJS.asInt = function(v) { + if (ScalaJS.isInt(v) || v === null) + return v; + else + ScalaJS.throwClassCastException(v, "java.lang.Integer"); +}; + +ScalaJS.asFloat = function(v) { + if (ScalaJS.isFloat(v) || v === null) + return v; + else + ScalaJS.throwClassCastException(v, "java.lang.Float"); +}; + +ScalaJS.asDouble = function(v) { + if (typeof v === "number" || v === null) + return v; + else + ScalaJS.throwClassCastException(v, "java.lang.Double"); +}; +//!endif + +// Unboxes + +//!if asInstanceOfs != Unchecked +ScalaJS.uZ = function(value) { + return !!ScalaJS.asBoolean(value); +}; +ScalaJS.uB = function(value) { + return ScalaJS.asByte(value) | 0; +}; +ScalaJS.uS = function(value) { + return ScalaJS.asShort(value) | 0; +}; +ScalaJS.uI = function(value) { + return ScalaJS.asInt(value) | 0; +}; +ScalaJS.uJ = function(value) { + return null === value ? ScalaJS.m.sjsr_RuntimeLong().Zero$1 + : ScalaJS.as.sjsr_RuntimeLong(value); +}; +ScalaJS.uF = function(value) { + /* Here, it is fine to use + instead of fround, because asFloat already + * ensures that the result is either null or a float. + */ + return +ScalaJS.asFloat(value); +}; +ScalaJS.uD = function(value) { + return +ScalaJS.asDouble(value); +}; +//!else +ScalaJS.uJ = function(value) { + return null === value ? ScalaJS.m.sjsr_RuntimeLong().Zero$1 : value; +}; +//!endif + +// TypeArray conversions + +ScalaJS.byteArray2TypedArray = function(value) { return new Int8Array(value.u); }; +ScalaJS.shortArray2TypedArray = function(value) { return new Int16Array(value.u); }; +ScalaJS.charArray2TypedArray = function(value) { return new Uint16Array(value.u); }; +ScalaJS.intArray2TypedArray = function(value) { return new Int32Array(value.u); }; +ScalaJS.floatArray2TypedArray = function(value) { return new Float32Array(value.u); }; +ScalaJS.doubleArray2TypedArray = function(value) { return new Float64Array(value.u); }; + +ScalaJS.typedArray2ByteArray = function(value) { + var arrayClassData = ScalaJS.d.B.getArrayOf(); + return new arrayClassData.constr(new Int8Array(value)); +}; +ScalaJS.typedArray2ShortArray = function(value) { + var arrayClassData = ScalaJS.d.S.getArrayOf(); + return new arrayClassData.constr(new Int16Array(value)); +}; +ScalaJS.typedArray2CharArray = function(value) { + var arrayClassData = ScalaJS.d.C.getArrayOf(); + return new arrayClassData.constr(new Uint16Array(value)); +}; +ScalaJS.typedArray2IntArray = function(value) { + var arrayClassData = ScalaJS.d.I.getArrayOf(); + return new arrayClassData.constr(new Int32Array(value)); +}; +ScalaJS.typedArray2FloatArray = function(value) { + var arrayClassData = ScalaJS.d.F.getArrayOf(); + return new arrayClassData.constr(new Float32Array(value)); +}; +ScalaJS.typedArray2DoubleArray = function(value) { + var arrayClassData = ScalaJS.d.D.getArrayOf(); + return new arrayClassData.constr(new Float64Array(value)); +}; + +/* We have to force a non-elidable *read* of ScalaJS.e, otherwise Closure will + * eliminate it altogether, along with all the exports, which is ... er ... + * plain wrong. + */ +this["__ScalaJSExportsNamespace"] = ScalaJS.e; + +// Type data constructors + +/** @constructor */ +ScalaJS.PrimitiveTypeData = function(zero, arrayEncodedName, displayName) { + // Runtime support + this.constr = undefined; + this.parentData = undefined; + this.ancestors = {}; + this.componentData = null; + this.zero = zero; + this.arrayEncodedName = arrayEncodedName; + this._classOf = undefined; + this._arrayOf = undefined; + this.isArrayOf = function(obj, depth) { return false; }; + + // java.lang.Class support + this["name"] = displayName; + this["isPrimitive"] = true; + this["isInterface"] = false; + this["isArrayClass"] = false; + this["isInstance"] = function(obj) { return false; }; +}; + +/** @constructor */ +ScalaJS.ClassTypeData = function(internalNameObj, isInterface, fullName, + parentData, ancestors, isInstance, isArrayOf) { + var internalName = ScalaJS.propertyName(internalNameObj); + + isInstance = isInstance || function(obj) { + return !!(obj && obj.$classData && obj.$classData.ancestors[internalName]); + }; + + isArrayOf = isArrayOf || function(obj, depth) { + return !!(obj && obj.$classData && (obj.$classData.arrayDepth === depth) + && obj.$classData.arrayBase.ancestors[internalName]) + }; + + // Runtime support + this.constr = undefined; + this.parentData = parentData; + this.ancestors = ancestors; + this.componentData = null; + this.zero = null; + this.arrayEncodedName = "L"+fullName+";"; + this._classOf = undefined; + this._arrayOf = undefined; + this.isArrayOf = isArrayOf; + + // java.lang.Class support + this["name"] = fullName; + this["isPrimitive"] = false; + this["isInterface"] = isInterface; + this["isArrayClass"] = false; + this["isInstance"] = isInstance; +}; + +/** @constructor */ +ScalaJS.ArrayTypeData = function(componentData) { + // The constructor + + var componentZero = componentData.zero; + + // The zero for the Long runtime representation + // is a special case here, since the class has not + // been defined yet, when this file is read + if (componentZero == "longZero") + componentZero = ScalaJS.m.sjsr_RuntimeLong().Zero$1; + + /** @constructor */ + var ArrayClass = function(arg) { + if (typeof(arg) === "number") { + // arg is the length of the array + this.u = new Array(arg); + for (var i = 0; i < arg; i++) + this.u[i] = componentZero; + } else { + // arg is a native array that we wrap + this.u = arg; + } + } + ArrayClass.prototype = new ScalaJS.h.O; + ArrayClass.prototype.constructor = ArrayClass; + ArrayClass.prototype.$classData = this; + + ArrayClass.prototype.clone__O = function() { + if (this.u instanceof Array) + return new ArrayClass(this.u["slice"](0)); + else + // The underlying Array is a TypedArray + return new ArrayClass(this.u.constructor(this.u)); + }; + + // Don't generate reflective call proxies. The compiler special cases + // reflective calls to methods on scala.Array + + // The data + + var encodedName = "[" + componentData.arrayEncodedName; + var componentBase = componentData.arrayBase || componentData; + var componentDepth = componentData.arrayDepth || 0; + var arrayDepth = componentDepth + 1; + + var isInstance = function(obj) { + return componentBase.isArrayOf(obj, arrayDepth); + } + + // Runtime support + this.constr = ArrayClass; + this.parentData = ScalaJS.d.O; + this.ancestors = {O: 1}; + this.componentData = componentData; + this.arrayBase = componentBase; + this.arrayDepth = arrayDepth; + this.zero = null; + this.arrayEncodedName = encodedName; + this._classOf = undefined; + this._arrayOf = undefined; + this.isArrayOf = undefined; + + // java.lang.Class support + this["name"] = encodedName; + this["isPrimitive"] = false; + this["isInterface"] = false; + this["isArrayClass"] = true; + this["isInstance"] = isInstance; +}; + +ScalaJS.ClassTypeData.prototype.getClassOf = function() { + if (!this._classOf) + this._classOf = new ScalaJS.c.jl_Class().init___jl_ScalaJSClassData(this); + return this._classOf; +}; + +ScalaJS.ClassTypeData.prototype.getArrayOf = function() { + if (!this._arrayOf) + this._arrayOf = new ScalaJS.ArrayTypeData(this); + return this._arrayOf; +}; + +// java.lang.Class support + +ScalaJS.ClassTypeData.prototype["getFakeInstance"] = function() { + if (this === ScalaJS.d.T) + return "some string"; + else if (this === ScalaJS.d.jl_Boolean) + return false; + else if (this === ScalaJS.d.jl_Byte || + this === ScalaJS.d.jl_Short || + this === ScalaJS.d.jl_Integer || + this === ScalaJS.d.jl_Float || + this === ScalaJS.d.jl_Double) + return 0; + else if (this === ScalaJS.d.jl_Long) + return ScalaJS.m.sjsr_RuntimeLong().Zero$1; + else if (this === ScalaJS.d.sr_BoxedUnit) + return void 0; + else + return {$classData: this}; +}; + +ScalaJS.ClassTypeData.prototype["getSuperclass"] = function() { + return this.parentData ? this.parentData.getClassOf() : null; +}; + +ScalaJS.ClassTypeData.prototype["getComponentType"] = function() { + return this.componentData ? this.componentData.getClassOf() : null; +}; + +ScalaJS.ClassTypeData.prototype["newArrayOfThisClass"] = function(lengths) { + var arrayClassData = this; + for (var i = 0; i < lengths.length; i++) + arrayClassData = arrayClassData.getArrayOf(); + return ScalaJS.newArrayObject(arrayClassData, lengths); +}; + +ScalaJS.PrimitiveTypeData.prototype = ScalaJS.ClassTypeData.prototype; +ScalaJS.ArrayTypeData.prototype = ScalaJS.ClassTypeData.prototype; + +// Create primitive types + +ScalaJS.d.V = new ScalaJS.PrimitiveTypeData(undefined, "V", "void"); +ScalaJS.d.Z = new ScalaJS.PrimitiveTypeData(false, "Z", "boolean"); +ScalaJS.d.C = new ScalaJS.PrimitiveTypeData(0, "C", "char"); +ScalaJS.d.B = new ScalaJS.PrimitiveTypeData(0, "B", "byte"); +ScalaJS.d.S = new ScalaJS.PrimitiveTypeData(0, "S", "short"); +ScalaJS.d.I = new ScalaJS.PrimitiveTypeData(0, "I", "int"); +ScalaJS.d.J = new ScalaJS.PrimitiveTypeData("longZero", "J", "long"); +ScalaJS.d.F = new ScalaJS.PrimitiveTypeData(0.0, "F", "float"); +ScalaJS.d.D = new ScalaJS.PrimitiveTypeData(0.0, "D", "double"); + +// Instance tests for array of primitives + +ScalaJS.isArrayOf.Z = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.Z); +ScalaJS.d.Z.isArrayOf = ScalaJS.isArrayOf.Z; + +ScalaJS.isArrayOf.C = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.C); +ScalaJS.d.C.isArrayOf = ScalaJS.isArrayOf.C; + +ScalaJS.isArrayOf.B = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.B); +ScalaJS.d.B.isArrayOf = ScalaJS.isArrayOf.B; + +ScalaJS.isArrayOf.S = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.S); +ScalaJS.d.S.isArrayOf = ScalaJS.isArrayOf.S; + +ScalaJS.isArrayOf.I = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.I); +ScalaJS.d.I.isArrayOf = ScalaJS.isArrayOf.I; + +ScalaJS.isArrayOf.J = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.J); +ScalaJS.d.J.isArrayOf = ScalaJS.isArrayOf.J; + +ScalaJS.isArrayOf.F = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.F); +ScalaJS.d.F.isArrayOf = ScalaJS.isArrayOf.F; + +ScalaJS.isArrayOf.D = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.D); +ScalaJS.d.D.isArrayOf = ScalaJS.isArrayOf.D; + +//!if asInstanceOfs != Unchecked +// asInstanceOfs for array of primitives +ScalaJS.asArrayOf.Z = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.Z, "Z"); +ScalaJS.asArrayOf.C = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.C, "C"); +ScalaJS.asArrayOf.B = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.B, "B"); +ScalaJS.asArrayOf.S = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.S, "S"); +ScalaJS.asArrayOf.I = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.I, "I"); +ScalaJS.asArrayOf.J = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.J, "J"); +ScalaJS.asArrayOf.F = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.F, "F"); +ScalaJS.asArrayOf.D = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.D, "D"); +//!endif + +// Polyfills + +ScalaJS.imul = ScalaJS.g["Math"]["imul"] || (function(a, b) { + // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + var ah = (a >>> 16) & 0xffff; + var al = a & 0xffff; + var bh = (b >>> 16) & 0xffff; + var bl = b & 0xffff; + // the shift by 0 fixes the sign on the high part + // the final |0 converts the unsigned value into a signed value + return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) | 0); +}); + +ScalaJS.fround = ScalaJS.g["Math"]["fround"] || +//!if floats == Strict + (ScalaJS.g["Float32Array"] ? (function(v) { + var array = new ScalaJS.g["Float32Array"](1); + array[0] = v; + return array[0]; + }) : (function(v) { + return ScalaJS.m.sjsr_package().froundPolyfill__D__D(+v); + })); +//!else + (function(v) { + return +v; + }); +//!endif |