[lua] Port _hx_bit_clamp to haxe code

src/generators/genlua.ml

@@ -2215,7 +2215,7 @@ let generate com =
     List.iter (generate_type_forward ctx) com.types; newline ctx;
 
     (* Generate some dummy placeholders for utility libs that may be required*)
-    println ctx "local _hx_bind, _hx_bit, _hx_staticToInstance, _hx_funcToField, _hx_anonToField, _hx_maxn, _hx_print, _hx_apply_self, _hx_box_mr, _hx_bit_clamp, _hx_table, _hx_bit_raw";
+    println ctx "local _hx_bind, _hx_bit, _hx_staticToInstance, _hx_funcToField, _hx_anonToField, _hx_maxn, _hx_print, _hx_apply_self, _hx_box_mr, _hx_table, _hx_bit_raw";
     println ctx "local _hx_pcall_default = {};";
     println ctx "local _hx_pcall_break = {};";
 
@@ -2227,9 +2227,6 @@ let generate com =
         print_file (find_file "lua/_lua/_hx_bit.lua");
     end;
 
-    (* integer clamping is always required, and will use bit ops if available *)
-    print_file (find_file "lua/_lua/_hx_bit_clamp.lua");
-
     (* Array is required, always patch it *)
     println ctx "_hx_array_mt.__index = Array.prototype";
     newline ctx;

std/lua/Boot.hx

@@ -30,8 +30,8 @@ class Boot {
 	static var _:Dynamic;
 	static var _fid = 0;
 
-	static var Max_Int32 = 2147483647;
-	static var Min_Int32 = -2147483648;
+	static inline var Max_Int32 = 2147483647;
+	static inline var Min_Int32 = -2147483648;
 
 
 	// A max stack size to respect for unpack operations
@@ -194,11 +194,90 @@ class Boot {
 			+ (if (h < 10) "0" + h else "" + h) + ":" + (if (mi < 10) "0" + mi else "" + mi) + ":" + (if (s < 10) "0" + s else "" + s);
 	}
 
+	// wrap with common functionality for all implementations
+	extern inline static function clampWrapper(inner:Float->Null<Int>):Float->Null<Int> {
+		return function (v:Float) {
+			if (v <= Max_Int32 && v >= Min_Int32)
+				return v > 0 ? Math.floor(v) : Math.ceil(v);
+
+			if (inline std.Math.isNaN(v) || !inline std.Math.isFinite(v))
+				return null;
+
+			return inner(v);
+		};
+	}
+
+	extern inline static function prepareForBitwise(v:Float) {
+		if (v > 2251798999999999) {
+			return v * 2;
+		}
+		return v;
+	}
+
+	// Ideally, these should be extern inline because they should only be used
+	// via inlining (we also don't want clampNativeOperator outside testFunctionSupport)
+	// however, extern inline prevents closures, even if they are immediately inlined
+	inline static function clampNativeOperator(v:Float) {
+		v = prepareForBitwise(v);
+		return lua.Syntax.code("({0} & 0x7FFFFFFF) - ({0} & 0x80000000)", v);
+	}
+
+	inline static function clampHxBit(v:Float):Int {
+		v = prepareForBitwise(v);
+		final band:(Float, Float) -> Int = untyped _hx_bit_raw.band;
+		return band(v, Max_Int32) - cast Math.abs(band(v, -Min_Int32));
+	}
+
+	inline static function clampModulo(v:Float):Int {
+		v %= 4294967296;
+		if (v >= 2147483648) {
+			v -= 4294967296;
+		}
+		return cast v;
+	}
+
+	/**
+		Test whether the syntax used in function `f` is supported on the current lua version.
+
+		If it is, return it, otherwise return null.
+	**/
+	extern inline static function testFunctionSupport<T, S>(f:T->S):Null<T->S> {
+		final result = Lua.pcall(Lua.load, lua.Syntax.code("[[return {0}]]", f));
+		if (result.status && result.value != null) {
+			final fn:() -> (T->S) = result.value;
+			return fn();
+		}
+		return null;
+	}
+
 	/**
 		A 32 bit clamp function for numbers
 	**/
-	public inline static function clampInt32(x:Float) {
-        return untyped _hx_bit_clamp(x);
+	@:ifFeature("use._bitop")
+	public static function clampInt32(v:Float) {
+		#if (lua_ver >= 5.3)
+		return clampWrapper(clampNativeOperator);
+		#else
+		final clampImpl = {
+			// Try native Lua 5.3+ bit operators first (preferred over bit32/bit library)
+			final nativeOperators = testFunctionSupport(clampWrapper(clampNativeOperator));
+			if (nativeOperators != null) {
+				nativeOperators;
+			#if !(lua_ver >= 5.2) // lua 5.2 definitely has bit32
+			} else if (untyped _hx_bit_raw == null) {
+				// Fallback for Lua without bit, bit32, or native bit ops: wrap using modulo
+				clampWrapper(clampModulo);
+			#end
+			} else {
+				clampWrapper(clampHxBit);
+			}
+		};
+
+		// set implementation so that future calls don't have to perform detection
+		untyped lua.Boot.clampInt32 = clampImpl;
+
+		return clampImpl(v);
+		#end
 	}
 
 	/**

std/lua/_lua/_hx_bit.lua

@@ -3,13 +3,13 @@ if _G.bit32 or pcall(require, 'bit32') then
   _hx_bit_raw = _G.bit32 or require('bit32')
   _hx_bit = setmetatable({}, { __index = _hx_bit_raw })
   -- bit32 operations require manual clamping
-  _hx_bit.bnot = function(...) return _hx_bit_clamp(_hx_bit_raw.bnot(...)) end
-  _hx_bit.bxor = function(...) return _hx_bit_clamp(_hx_bit_raw.bxor(...)) end
+  _hx_bit.bnot = function(...) return __lua_Boot.clampInt32(_hx_bit_raw.bnot(...)) end
+  _hx_bit.bxor = function(...) return __lua_Boot.clampInt32(_hx_bit_raw.bxor(...)) end
   -- see https://github.com/HaxeFoundation/haxe/issues/8849
-  _hx_bit.bor = function(...) return _hx_bit_clamp(_hx_bit_raw.bor(...)) end
-  _hx_bit.band = function(...) return _hx_bit_clamp(_hx_bit_raw.band(...)) end
-  _hx_bit.arshift = function(...) return _hx_bit_clamp(_hx_bit_raw.arshift(...)) end
-  _hx_bit.lshift = function(...) return _hx_bit_clamp(_hx_bit_raw.lshift(...)) end
+  _hx_bit.bor = function(...) return __lua_Boot.clampInt32(_hx_bit_raw.bor(...)) end
+  _hx_bit.band = function(...) return __lua_Boot.clampInt32(_hx_bit_raw.band(...)) end
+  _hx_bit.arshift = function(...) return __lua_Boot.clampInt32(_hx_bit_raw.arshift(...)) end
+  _hx_bit.lshift = function(...) return __lua_Boot.clampInt32(_hx_bit_raw.lshift(...)) end
 elseif _G.bit or pcall(require, 'bit') then
   -- if we do not have bit32, fallback to bit, default on luajit
   _hx_bit_raw = _G.bit or require('bit')

std/lua/_std/Array.hx

@@ -62,7 +62,7 @@ class Array<T> {
 	public function reverse():Void {
 		var tmp:T;
 		var i = 0;
-		while (i < Std.int(this.length / 2)) {
+		while (i < Math.floor(this.length / 2)) {
 			tmp = this[i];
 			this[i] = this[this.length - i - 1];
 			this[this.length - i - 1] = tmp;