Jämför tecken på 64-bitars nummer med 32-bitars bitvisa operationer i Lua

Jag kom på en metod som ser ut att fungera. Det är dock lite fult.

Det första steget är att jämföra de översta 32 bitarna som 2 komplimanger #’sMSB teckenbit stannar, så siffror håller korrekta relationer

-1  —> -1
0 —> 0
9223372036854775807 = 0x7fff ffff ffff ffff -> 0x7ffff ffff = 2147483647

Så att returnera resultatet från MSB:s arbeten om de inte är lika, då måste LSB:s behov kontrolleras.

Jag har några fall för att fastställa några mönster:

-1 = 0xffff ffff ffff ffff
-2 = 0xffff ffff ffff fffe
32 bit is:
-1 -> 0xffff ffff = -1
-2 -> 0xffff fffe = -2
-1 > -2 would be like -1 > -2 : GOOD

Och

8589934591 = 0x0000 0001 ffff ffff
8589934590 = 0x0000 0001 ffff fffe
32 bit is:
8589934591 -> ffff ffff = -1
8589934590 -> ffff fffe = -2
8589934591 > 8589934590 would be -1 > -2 : GOOD

Teckenbiten på MSB spelar ingen roll b/c negativa tal har samma förhållande sinsemellan som positiva tal. t.ex. oavsett teckenbit, lsb-värden för 0xff> 0xfe , alltid.

Vad händer om MSB på de lägre 32 bitarna är annorlunda?

0xff7f ffff 7fff ffff = -36,028,799,166,447,617
0xff7f ffff ffff ffff = -36,028,797,018,963,969
32 bit is:
-..799.. -> 0x7fff ffff = 2147483647
-..797.. -> 0xffff ffff = -1
-..799.. < -..797.. would be 2147483647 < -1 : BAD!

Så vi måste ignorera teckenbiten på de lägre 32 bitarna. Och eftersom relationerna är desamma för LSB:erna oavsett tecken, fungerar bara att använda de lägsta 32 bitarna osignerade för alla fall.

Det betyder att jag vill ha signerade för MSB:erna och osignerade för LSB:erna - så ändring I4 till i4 för LSB:erna. Gör också big endian officiellt och använder '>' på struct.unpack-anropen:

-- ...
local comp_int64s = function (as0, au1, bs0, bu1)
    if as0 > bs0 then
        return 1
    elseif as0 < bs0 then
        return -1
    else
        -- msb's equal comparing lsbs - these are unsigned
        if au1 > bu1 then
            return 1
        elseif au1 < bu1 then
            return -1
        else
            return 0
        end
    end
end
local l, as0, au1, bs0, bu1
as0, l = bit.tobit(struct.unpack(">i4", ARGV[1]))
au1, l = bit.tobit(struct.unpack(">I4", ARGV[1], 5))
bs0, l = bit.tobit(struct.unpack(">i4", blob))
bu1, l = bit.tobit(struct.unpack(">I4", blob, 5))
print("Cmp result", comp_int64s(as0, au1, bs0, bu1))