363 lines
11 KiB
Haxe
363 lines
11 KiB
Haxe
/*
|
|
* Copyright (C)2005-2019 Haxe Foundation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
package haxe.io;
|
|
|
|
/**
|
|
Helper that converts between floating point and binary representation.
|
|
Always works in low-endian encoding.
|
|
**/
|
|
class FPHelper {
|
|
#if neko_v21
|
|
// stored in helper
|
|
#elseif neko
|
|
static var i64tmp = new sys.thread.Tls<Int64>();
|
|
#elseif !(java || cs || cpp)
|
|
static var i64tmp = Int64.ofInt(0);
|
|
|
|
static inline var LN2 = 0.6931471805599453; // Math.log(2)
|
|
|
|
static inline function _i32ToFloat(i:Int):Float {
|
|
var sign = 1 - ((i >>> 31) << 1);
|
|
var e = (i >> 23) & 0xff;
|
|
if (e == 255)
|
|
return i & 0x7fffff == 0 ? (sign > 0 ? Math.POSITIVE_INFINITY : Math.NEGATIVE_INFINITY) : Math.NaN;
|
|
var m = e == 0 ? (i & 0x7fffff) << 1 : (i & 0x7fffff) | 0x800000;
|
|
return sign * m * Math.pow(2, e - 150);
|
|
}
|
|
|
|
static inline function _i64ToDouble(lo:Int, hi:Int):Float {
|
|
var sign = 1 - ((hi >>> 31) << 1);
|
|
var e = (hi >> 20) & 0x7ff;
|
|
if (e == 2047)
|
|
return lo == 0 && (hi & 0xFFFFF) == 0 ? (sign > 0 ? Math.POSITIVE_INFINITY : Math.NEGATIVE_INFINITY) : Math.NaN;
|
|
var m = 2.220446049250313e-16 * ((hi & 0xFFFFF) * 4294967296. + (lo >>> 31) * 2147483648. + (lo & 0x7FFFFFFF));
|
|
m = e == 0 ? m * 2.0 : m + 1.0;
|
|
return sign * m * Math.pow(2, e - 1023);
|
|
}
|
|
|
|
static inline function _floatToI32(f:Float):Int {
|
|
if (f == 0)
|
|
return 0;
|
|
var af = f < 0 ? -f : f;
|
|
var exp = Math.floor(Math.log(af) / LN2);
|
|
if (exp > 127) {
|
|
return 0x7F800000;
|
|
} else {
|
|
if (exp <= -127) {
|
|
exp = -127;
|
|
af *= 7.1362384635298e+44; // af * 0.5 * 0x800000 / Math.pow(2, -127)
|
|
} else {
|
|
af = (af / Math.pow(2, exp) - 1.0) * 0x800000;
|
|
}
|
|
return (f < 0 ? 0x80000000 : 0) | ((exp + 127) << 23) | Math.round(af);
|
|
}
|
|
}
|
|
|
|
static inline function _doubleToI64(v:Float):Int64@:privateAccess {
|
|
var i64 = i64tmp;
|
|
if (v == 0) {
|
|
i64.set_low(0);
|
|
i64.set_high(0);
|
|
} else if (!Math.isFinite(v)) {
|
|
i64.set_low(0);
|
|
i64.set_high(v > 0 ? 0x7FF00000 : 0xFFF00000);
|
|
} else {
|
|
var av = v < 0 ? -v : v;
|
|
var exp = Math.floor(Math.log(av) / LN2);
|
|
if (exp > 1023) {
|
|
i64.set_low(0xFFFFFFFF);
|
|
i64.set_high(0x7FEFFFFF);
|
|
} else {
|
|
if (exp <= -1023) {
|
|
exp = -1023;
|
|
av = av / 2.2250738585072014e-308;
|
|
} else {
|
|
av = av / Math.pow(2, exp) - 1.0;
|
|
}
|
|
var sig = Math.fround(av * 4503599627370496.); // 2^52
|
|
// Note: If "sig" is outside of the signed Int32 range, the result is unspecified in HL, C#, Java and Neko,
|
|
var sig_l = Std.int(sig);
|
|
var sig_h = Std.int(sig / 4294967296.0);
|
|
i64.set_low(sig_l);
|
|
i64.set_high((v < 0 ? 0x80000000 : 0) | ((exp + 1023) << 20) | sig_h);
|
|
}
|
|
}
|
|
return i64;
|
|
}
|
|
#end
|
|
|
|
#if neko
|
|
#if neko_v21
|
|
static var helpers = new sys.thread.Tls<neko.NativeArray<Dynamic>>();
|
|
#else
|
|
static var helperf = new sys.thread.Tls<neko.NativeString>();
|
|
static var helperd = new sys.thread.Tls<neko.NativeString>();
|
|
static var _float_of_bytes = neko.Lib.load("std", "float_of_bytes", 2);
|
|
static var _double_of_bytes = neko.Lib.load("std", "double_of_bytes", 2);
|
|
static var _float_bytes = neko.Lib.load("std", "float_bytes", 2);
|
|
static var _double_bytes = neko.Lib.load("std", "double_bytes", 2);
|
|
#end
|
|
#elseif flash
|
|
static var helper = {
|
|
var b = new flash.utils.ByteArray();
|
|
b.endian = flash.utils.Endian.LITTLE_ENDIAN;
|
|
b;
|
|
}
|
|
#elseif js
|
|
static var helper = new js.lib.DataView(new js.lib.ArrayBuffer(8));
|
|
#end
|
|
|
|
#if neko_v21
|
|
inline
|
|
#end
|
|
public static function i32ToFloat(i:Int):Float {
|
|
#if neko
|
|
#if neko_v21
|
|
return untyped $itof(i, false);
|
|
#else
|
|
var helper = helperf.value;
|
|
if (helper == null)
|
|
helperf.value = helper = neko.NativeString.alloc(4);
|
|
untyped $sset(helper, 0, i & 0xFF);
|
|
untyped $sset(helper, 1, (i >> 8) & 0xFF);
|
|
untyped $sset(helper, 2, (i >> 16) & 0xFF);
|
|
untyped $sset(helper, 3, i >>> 24);
|
|
return _float_of_bytes(helper, false);
|
|
#end
|
|
#elseif cpp
|
|
return untyped __global__.__hxcpp_reinterpret_le_int32_as_float32(i);
|
|
#elseif cs
|
|
var helper = new SingleHelper(0);
|
|
if (cs.system.BitConverter.IsLittleEndian) {
|
|
helper.i = i;
|
|
} else {
|
|
helper.i = ((i >>> 24) & 0xFF) | (((i >> 16) & 0xFF) << 8) | (((i >> 8) & 0xFF) << 16) | ((i & 0xFF) << 24);
|
|
}
|
|
|
|
return helper.f;
|
|
#elseif java
|
|
return java.lang.Float.FloatClass.intBitsToFloat(i);
|
|
#elseif flash
|
|
var helper = helper;
|
|
helper.position = 0;
|
|
helper.writeUnsignedInt(i);
|
|
helper.position = 0;
|
|
return helper.readFloat();
|
|
#elseif js
|
|
helper.setInt32(0, i, true);
|
|
return helper.getFloat32(0, true);
|
|
#else
|
|
return _i32ToFloat(i);
|
|
#end
|
|
}
|
|
|
|
#if neko_v21
|
|
inline
|
|
#end
|
|
public static function floatToI32(f:Float):Int {
|
|
#if neko
|
|
#if neko_v21
|
|
return untyped $ftoi(f, false);
|
|
#else
|
|
var r = _float_bytes(f, false);
|
|
return untyped $sget(r, 0) | ($sget(r, 1) << 8) | ($sget(r, 2) << 16) | ($sget(r, 3) << 24);
|
|
#end
|
|
#elseif cpp
|
|
return untyped __global__.__hxcpp_reinterpret_float32_as_le_int32(f);
|
|
#elseif cs
|
|
var helper = new SingleHelper(f);
|
|
if (cs.system.BitConverter.IsLittleEndian) {
|
|
return helper.i;
|
|
} else {
|
|
var i = helper.i;
|
|
return ((i >>> 24) & 0xFF) | (((i >> 16) & 0xFF) << 8) | (((i >> 8) & 0xFF) << 16) | ((i & 0xFF) << 24);
|
|
}
|
|
#elseif java
|
|
return java.lang.Float.FloatClass.floatToRawIntBits(f);
|
|
#elseif flash
|
|
var helper = helper;
|
|
helper.position = 0;
|
|
helper.writeFloat(f);
|
|
helper.position = 0;
|
|
return helper.readUnsignedInt();
|
|
#elseif js
|
|
helper.setFloat32(0, f, true);
|
|
return helper.getInt32(0, true);
|
|
#else
|
|
return _floatToI32(f);
|
|
#end
|
|
}
|
|
|
|
#if neko_v21
|
|
inline
|
|
#end
|
|
public static function i64ToDouble(low:Int, high:Int):Float {
|
|
#if neko
|
|
#if neko_v21
|
|
return untyped $itod(low, high, false);
|
|
#else
|
|
var helper = helperd.value;
|
|
if (helper == null)
|
|
helperd.value = helper = neko.NativeString.alloc(8);
|
|
untyped $sset(helper, 0, low & 0xFF);
|
|
untyped $sset(helper, 1, (low >> 8) & 0xFF);
|
|
untyped $sset(helper, 2, (low >> 16) & 0xFF);
|
|
untyped $sset(helper, 3, low >>> 24);
|
|
untyped $sset(helper, 4, high & 0xFF);
|
|
untyped $sset(helper, 5, (high >> 8) & 0xFF);
|
|
untyped $sset(helper, 6, (high >> 16) & 0xFF);
|
|
untyped $sset(helper, 7, high >>> 24);
|
|
return _double_of_bytes(helper, false);
|
|
#end
|
|
#elseif cpp
|
|
return untyped __global__.__hxcpp_reinterpret_le_int32s_as_float64(low, high);
|
|
#elseif cs
|
|
var helper = new FloatHelper(0);
|
|
if (cs.system.BitConverter.IsLittleEndian) {
|
|
helper.i = haxe.Int64.make(high, low);
|
|
} else {
|
|
var i1 = high, i2 = low;
|
|
var j2 = ((i1 >>> 24) & 0xFF) | (((i1 >> 16) & 0xFF) << 8) | (((i1 >> 8) & 0xFF) << 16) | ((i1 & 0xFF) << 24);
|
|
var j1 = ((i2 >>> 24) & 0xFF) | (((i2 >> 16) & 0xFF) << 8) | (((i2 >> 8) & 0xFF) << 16) | ((i2 & 0xFF) << 24);
|
|
helper.i = haxe.Int64.make(j1, j2);
|
|
}
|
|
return helper.f;
|
|
#elseif java
|
|
return java.lang.Double.DoubleClass.longBitsToDouble(Int64.make(high, low));
|
|
#elseif flash
|
|
var helper = helper;
|
|
helper.position = 0;
|
|
helper.writeUnsignedInt(low);
|
|
helper.writeUnsignedInt(high);
|
|
helper.position = 0;
|
|
return helper.readDouble();
|
|
#elseif js
|
|
helper.setInt32(0, low, true);
|
|
helper.setInt32(4, high, true);
|
|
return helper.getFloat64(0, true);
|
|
#else
|
|
return _i64ToDouble(low, high);
|
|
#end
|
|
}
|
|
|
|
/**
|
|
Returns an Int64 representing the bytes representation of the double precision IEEE float value.
|
|
WARNING : for performance reason, the same Int64 value might be reused every time. Copy its low/high values before calling again.
|
|
We still ensure that this is safe to use in a multithread environment
|
|
**/
|
|
public static function doubleToI64(v:Float):Int64 {
|
|
#if neko
|
|
#if neko_v21
|
|
var helper = helpers.value;
|
|
if (helper == null) {
|
|
helpers.value = helper = neko.NativeArray.alloc(2);
|
|
helper[0] = neko.NativeArray.alloc(2);
|
|
helper[1] = haxe.Int64.ofInt(0);
|
|
}
|
|
var i64:haxe.Int64 = helper[1], int2 = helper[0];
|
|
untyped $dtoi(v, int2, false);
|
|
@:privateAccess {
|
|
i64.set_low(int2[0]);
|
|
i64.set_high(int2[1]);
|
|
}
|
|
return i64;
|
|
#else
|
|
var r = _double_bytes(v, false), i64 = i64tmp.value;
|
|
if (i64 == null)
|
|
i64 = i64tmp.value = haxe.Int64.ofInt(0);
|
|
@:privateAccess {
|
|
i64.set_low(untyped $sget(r, 0) | ($sget(r, 1) << 8) | ($sget(r, 2) << 16) | ($sget(r, 3) << 24));
|
|
i64.set_high(untyped $sget(r, 4) | ($sget(r, 5) << 8) | ($sget(r, 6) << 16) | ($sget(r, 7) << 24));
|
|
}
|
|
return i64;
|
|
#end
|
|
#elseif cpp
|
|
return Int64.make(untyped __global__.__hxcpp_reinterpret_float64_as_le_int32_high(v),
|
|
untyped __global__.__hxcpp_reinterpret_float64_as_le_int32_low(v));
|
|
#elseif java
|
|
return java.lang.Double.DoubleClass.doubleToRawLongBits(v);
|
|
#elseif cs
|
|
var helper = new FloatHelper(v);
|
|
if (cs.system.BitConverter.IsLittleEndian) {
|
|
return helper.i;
|
|
} else {
|
|
var i = helper.i;
|
|
var i1 = haxe.Int64.getHigh(i), i2 = haxe.Int64.getLow(i);
|
|
var j2 = ((i1 >>> 24) & 0xFF) | (((i1 >> 16) & 0xFF) << 8) | (((i1 >> 8) & 0xFF) << 16) | ((i1 & 0xFF) << 24);
|
|
var j1 = ((i2 >>> 24) & 0xFF) | (((i2 >> 16) & 0xFF) << 8) | (((i2 >> 8) & 0xFF) << 16) | ((i2 & 0xFF) << 24);
|
|
|
|
return haxe.Int64.make(j1, j2);
|
|
}
|
|
#elseif flash
|
|
var helper = helper;
|
|
helper.position = 0;
|
|
helper.writeDouble(v);
|
|
helper.position = 0;
|
|
var i64 = i64tmp;
|
|
@:privateAccess {
|
|
i64.set_low(cast helper.readUnsignedInt());
|
|
i64.set_high(cast helper.readUnsignedInt());
|
|
}
|
|
return i64;
|
|
#elseif js
|
|
var i64 = i64tmp;
|
|
helper.setFloat64(0, v, true);
|
|
@:privateAccess {
|
|
i64.set_low(helper.getInt32(0, true));
|
|
i64.set_high(helper.getInt32(4, true));
|
|
}
|
|
return i64;
|
|
#else
|
|
return _doubleToI64(v);
|
|
#end
|
|
}
|
|
}
|
|
|
|
#if cs
|
|
@:meta(System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Explicit))
|
|
@:nativeGen @:struct private class SingleHelper {
|
|
@:meta(System.Runtime.InteropServices.FieldOffset(0))
|
|
public var i:Int;
|
|
@:meta(System.Runtime.InteropServices.FieldOffset(0))
|
|
public var f:Single;
|
|
|
|
public function new(f:Single) {
|
|
this.i = 0;
|
|
this.f = f;
|
|
}
|
|
}
|
|
|
|
@:meta(System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Explicit))
|
|
@:nativeGen @:struct private class FloatHelper {
|
|
@:meta(System.Runtime.InteropServices.FieldOffset(0))
|
|
public var i:haxe.Int64;
|
|
@:meta(System.Runtime.InteropServices.FieldOffset(0))
|
|
public var f:Float;
|
|
|
|
public function new(f:Float) {
|
|
this.i = haxe.Int64.ofInt(0);
|
|
this.f = f;
|
|
}
|
|
}
|
|
#end
|