HaxeFoundation.haxe/std/haxe/Int32.hx

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

/**
	Int32 provides a 32-bit integer with consistent overflow behavior across
	all platforms.
**/
@:transitive
abstract Int32(Int) from Int to Int {
	@:op(-A) private inline function negate():Int32
		return clamp(~this + 1);

	@:op(++A) private inline function preIncrement():Int32
		return this = clamp(++this);

	@:op(A++) private inline function postIncrement():Int32 {
		var ret = this++;
		this = clamp(this);
		return ret;
	}

	@:op(--A) private inline function preDecrement():Int32
		return this = clamp(--this);

	@:op(A--) private inline function postDecrement():Int32 {
		var ret = this--;
		this = clamp(this);
		return ret;
	}

	@:op(A + B) private static inline function add(a:Int32, b:Int32):Int32
		return clamp((a : Int) + (b : Int));

	@:op(A + B) @:commutative private static inline function addInt(a:Int32, b:Int):Int32
		return clamp((a : Int) + (b : Int));

	@:op(A + B) @:commutative private static function addFloat(a:Int32, b:Float):Float;

	@:op(A - B) private static inline function sub(a:Int32, b:Int32):Int32
		return clamp((a : Int) - (b : Int));

	@:op(A - B) private static inline function subInt(a:Int32, b:Int):Int32
		return clamp((a : Int) - (b : Int));

	@:op(A - B) private static inline function intSub(a:Int, b:Int32):Int32
		return clamp((a : Int) - (b : Int));

	@:op(A - B) private static function subFloat(a:Int32, b:Float):Float;

	@:op(A - B) private static function floatSub(a:Float, b:Int32):Float;

	#if (js || php || python || lua)
	#if js
	// on JS we want to try using Math.imul, but we have to assign that function to Int32.mul only once,
	// or else V8 will deoptimize it, so we need to be a bit funky with this.
	// See https://github.com/HaxeFoundation/haxe/issues/5367 for benchmarks.
	@:op(A * B) inline static function mul(a:Int32, b:Int32):Int32
		return _mul(a, b);

	static var _mul:Int32->Int32->Int32 = untyped if (Math.imul != null)
			Math.imul
		else
			function(a:Int32, b:Int32):Int32 return clamp((a : Int) * ((b : Int) & 0xFFFF) + clamp((a : Int) * ((b : Int) >>> 16) << 16));
	#else
	@:op(A * B) private static function mul(a:Int32, b:Int32):Int32
		return clamp((a : Int) * ((b : Int) & 0xFFFF) + clamp((a : Int) * ((b : Int) >>> 16) << 16));
	#end

	@:op(A * B) @:commutative private static inline function mulInt(a:Int32, b:Int):Int32
		return mul(a, b);
	#else
	@:op(A * B) private static function mul(a:Int32, b:Int32):Int32;

	@:op(A * B) @:commutative private static function mulInt(a:Int32, b:Int):Int32;
	#end

	@:op(A * B) @:commutative private static function mulFloat(a:Int32, b:Float):Float;

	@:op(A / B) private static function div(a:Int32, b:Int32):Float;

	@:op(A / B) private static function divInt(a:Int32, b:Int):Float;

	@:op(A / B) private static function intDiv(a:Int, b:Int32):Float;

	@:op(A / B) private static function divFloat(a:Int32, b:Float):Float;

	@:op(A / B) private static function floatDiv(a:Float, b:Int32):Float;

	@:op(A % B) private static function mod(a:Int32, b:Int32):Int32;

	@:op(A % B) private static function modInt(a:Int32, b:Int):Int;

	@:op(A % B) private static function intMod(a:Int, b:Int32):Int;

	@:op(A % B) private static function modFloat(a:Int32, b:Float):Float;

	@:op(A % B) private static function floatMod(a:Float, b:Int32):Float;

	@:op(A == B) private static function eq(a:Int32, b:Int32):Bool;

	@:op(A == B) @:commutative private static function eqInt(a:Int32, b:Int):Bool;

	@:op(A == B) @:commutative private static function eqFloat(a:Int32, b:Float):Bool;

	@:op(A != B) private static function neq(a:Int32, b:Int32):Bool;

	@:op(A != B) @:commutative private static function neqInt(a:Int32, b:Int):Bool;

	@:op(A != B) @:commutative private static function neqFloat(a:Int32, b:Float):Bool;

	@:op(A < B) private static function lt(a:Int32, b:Int32):Bool;

	@:op(A < B) private static function ltInt(a:Int32, b:Int):Bool;

	@:op(A < B) private static function intLt(a:Int, b:Int32):Bool;

	@:op(A < B) private static function ltFloat(a:Int32, b:Float):Bool;

	@:op(A < B) private static function floatLt(a:Float, b:Int32):Bool;

	@:op(A <= B) private static function lte(a:Int32, b:Int32):Bool;

	@:op(A <= B) private static function lteInt(a:Int32, b:Int):Bool;

	@:op(A <= B) private static function intLte(a:Int, b:Int32):Bool;

	@:op(A <= B) private static function lteFloat(a:Int32, b:Float):Bool;

	@:op(A <= B) private static function floatLte(a:Float, b:Int32):Bool;

	@:op(A > B) private static function gt(a:Int32, b:Int32):Bool;

	@:op(A > B) private static function gtInt(a:Int32, b:Int):Bool;

	@:op(A > B) private static function intGt(a:Int, b:Int32):Bool;

	@:op(A > B) private static function gtFloat(a:Int32, b:Float):Bool;

	@:op(A > B) private static function floatGt(a:Float, b:Int32):Bool;

	@:op(A >= B) private static function gte(a:Int32, b:Int32):Bool;

	@:op(A >= B) private static function gteInt(a:Int32, b:Int):Bool;

	@:op(A >= B) private static function intGte(a:Int, b:Int32):Bool;

	@:op(A >= B) private static function gteFloat(a:Int32, b:Float):Bool;

	@:op(A >= B) private static function floatGte(a:Float, b:Int32):Bool;

	#if (lua || python || php)
	@:op(~A) private static inline function complement(a:Int32):Int32
		#if lua return lua.Boot.clampInt32(~a); #else return clamp(~a); #end
	#else
	@:op(~A) private function complement():Int32;
	#end

	@:op(A & B) private static function and(a:Int32, b:Int32):Int32;

	@:op(A & B) @:commutative private static function andInt(a:Int32, b:Int):Int32;

	#if (lua || python || php)
	@:op(A | B) private static #if (python || php) inline #end function or(a:Int32, b:Int32):Int32
		return clamp((a : Int) | (b : Int));

	@:op(A | B) @:commutative private #if (python || php) inline #end static function orInt(a:Int32, b:Int):Int32
		return clamp((a : Int) | b);
	#else
	@:op(A | B) private static function or(a:Int32, b:Int32):Int32;

	@:op(A | B) @:commutative private static function orInt(a:Int32, b:Int):Int32;
	#end

	#if (lua || python || php)
	@:op(A ^ B) private static #if (python || php) inline #end function xor(a:Int32, b:Int32):Int32
		return clamp((a : Int) ^ (b : Int));

	@:op(A ^ B) @:commutative private static #if (python || php) inline #end function xorInt(a:Int32, b:Int):Int32
		return clamp((a : Int) ^ b);
	#else
	@:op(A ^ B) private static function xor(a:Int32, b:Int32):Int32;

	@:op(A ^ B) @:commutative private static function xorInt(a:Int32, b:Int):Int32;
	#end

	#if (lua || python || php)
	@:op(A >> B) private static #if (python || php) inline #end function shr(a:Int32, b:Int32):Int32
		return clamp((a : Int) >> (b : Int));

	@:op(A >> B) private static #if (python || php) inline #end function shrInt(a:Int32, b:Int):Int32
		return clamp((a : Int) >> b);

	@:op(A >> B) private static #if (python || php) inline #end function intShr(a:Int, b:Int32):Int32
		return clamp(a >> (b : Int));
	#else
	@:op(A >> B) private static function shr(a:Int32, b:Int32):Int32;

	@:op(A >> B) private static function shrInt(a:Int32, b:Int):Int32;

	@:op(A >> B) private static function intShr(a:Int, b:Int32):Int32;
	#end

	@:op(A >>> B) private static function ushr(a:Int32, b:Int32):Int32;

	@:op(A >>> B) private static function ushrInt(a:Int32, b:Int):Int32;

	@:op(A >>> B) private static function intUshr(a:Int, b:Int32):Int32;

	#if (php || python || lua)
	// PHP may be 64-bit, so shifts must be clamped
	@:op(A << B) private static inline function shl(a:Int32, b:Int32):Int32
		return clamp((a : Int) << (b : Int));

	@:op(A << B) private static inline function shlInt(a:Int32, b:Int):Int32
		return clamp((a : Int) << b);

	@:op(A << B) private static inline function intShl(a:Int, b:Int32):Int32
		return clamp(a << (b : Int));
	#else
	@:op(A << B) private static function shl(a:Int32, b:Int32):Int32;

	@:op(A << B) private static function shlInt(a:Int32, b:Int):Int32;

	@:op(A << B) private static function intShl(a:Int, b:Int32):Int32;
	#end

	@:to private inline function toFloat():Float
		return this;

	/**
		Compare `a` and `b` in unsigned mode.
	**/
	public static function ucompare(a:Int32, b:Int32):Int {
		if (a < 0)
			return b < 0 ? (~b - ~a) : 1;
		return b < 0 ? -1 : (a - b);
	}

	#if php
	static var extraBits:Int = php.Const.PHP_INT_SIZE * 8 - 32;
	#end

	#if !lua
	inline
	#end
	static function clamp(x:Int):Int {
		// force to-int conversion on platforms that require it
		#if js
		return x | 0;
		#elseif php
		// we might be on 64-bit php, so sign extend from 32-bit
		return (x << extraBits) >> extraBits;
		#elseif python
		return (python.Syntax.code("{0} % {1}", (x + python.Syntax.opPow(2, 31)), python.Syntax.opPow(2, 32)) : Int) - python.Syntax.opPow(2, 31);
		#elseif lua
		return lua.Boot.clampInt32(x);
		#else
		return (x);
		#end
	}
}