32位Lua编译器下64位大端十六进制数转小端及位运算实现问询

在32位Lua环境里处理64位数据确实有点棘手——毕竟原生的双精度浮点数只能精确表示到2^53，超过这个范围就会丢失精度。不过我们可以通过拆分64位数据为高低两个32位部分的方式来绕开这个限制，再结合bitop库完成位运算操作，亲测可行，下面是具体步骤：

1. 大端64位十六进制转小端十六进制 #

首先要把大端字节序的十六进制字符串转换成小端，本质就是反转字节的顺序（每两个十六进制字符对应一个字节）：

function hex_big_to_little(big_hex)
    -- 先验证输入是标准64位十六进制字符串
    assert(#big_hex == 16, "必须输入16字符的64位十六进制字符串")
    local little_hex = ""
    -- 从后往前，每两个字符为一组拼接
    for i = #big_hex, 2, -2 do
        little_hex = little_hex .. string.sub(big_hex, i-1, i)
    end
    return little_hex
end

举个例子：输入"123456789ABCDEF0"，会输出小端格式的"F0DEBC9A78563412"。

2. 把小端十六进制拆成高低32位数值 #

转换后的小端十六进制可以拆成高32位和低32位的无符号整数，这样就能在32位Lua里安全处理了：

local bit = require("bit")

function little_hex_to_high_low(little_hex)
    -- 拆分低32位和高32位的十六进制片段
    local low_hex = string.sub(little_hex, 1, 8)
    local high_hex = string.sub(little_hex, 9, 16)
    -- 转成32位无符号整数，用bitop确保无符号特性
    local low = tonumber(low_hex, 16) or 0
    local high = tonumber(high_hex, 16) or 0
    low = bit.band(low, 0xFFFFFFFF)
    high = bit.band(high, 0xFFFFFFFF)
    return high, low
end

示例：输入"F0DEBC9A78563412"，会返回high=0x78563412、low=0xF0DEBC9A。

3. 封装64位位运算操作 #

基于高低32位的结构，我们可以把常用的位运算封装成函数，以下是几个核心操作的实现：

无符号左移 #

function bit64_lshift(high, low, shift)
    shift = shift % 64 -- 确保移位范围在0-63之间
    if shift == 0 then return high, low end
    if shift < 32 then
        local new_low = bit.bor(bit.lshift(low, shift), bit.rshift(high, 32 - shift))
        local new_high = bit.lshift(high, shift)
        return bit.band(new_high, 0xFFFFFFFF), bit.band(new_low, 0xFFFFFFFF)
    else
        local new_low = bit.lshift(high, shift - 32)
        return 0, bit.band(new_low, 0xFFFFFFFF)
    end
end

无符号右移 #

function bit64_rshift(high, low, shift)
    shift = shift % 64
    if shift == 0 then return high, low end
    if shift < 32 then
        local new_high = bit.bor(bit.rshift(high, shift), bit.lshift(low, 32 - shift))
        local new_low = bit.rshift(low, shift)
        return bit.band(new_high, 0xFFFFFFFF), bit.band(new_low, 0xFFFFFFFF)
    else
        local new_low = bit.rshift(high, shift - 32)
        return 0, bit.band(new_low, 0xFFFFFFFF)
    end
end

按位与/或 #

-- 按位与
function bit64_and(h1, l1, h2, l2)
    return bit.band(h1, h2), bit.band(l1, l2)
end

-- 按位或
function bit64_or(h1, l1, h2, l2)
    return bit.bor(h1, h2), bit.bor(l1, l2)
end

完整使用示例 #

-- 输入大端64位十六进制
local big_hex = "123456789ABCDEF0"
-- 转小端格式
local little_hex = hex_big_to_little(big_hex)
-- 拆分为高低32位
local high, low = little_hex_to_high_low(little_hex)
-- 执行左移8位操作
local new_high, new_low = bit64_lshift(high, low, 8)
-- 输出结果（转成十六进制）
print(string.format("0x%08X%08X", new_high, new_low)) -- 输出: 0x56341200DEBC9AF0

内容的提问来源于stack exchange，提问作者cool