add BIT.bit32 Lua 5.2 compat submodule; add btest and arshift

Author: davidm

CHANGES.txt

@@ -1,5 +1,6 @@
-2011-11-26
-  Add functions: tobit, tohex, rshift, lshift, extract, replace, bswap, rrotate, lrotate, rol, ror
+2011-11-29
+  Add functions: tobit, tohex, rshift, lshift, arshift, extract, replace, bswap, rrotate, lrotate, rol, ror, btest
+  Add  BIT.bit32 Lua 5.2 compatibility submodule.
   Add test suite.
 
 2011-09-11 - initial import

lmod/bit/numberlua.lua

@@ -4,6 +4,15 @@ LUA MODULE
 
   bit.numberlua - Bitwise operations implemented in pure Lua as numbers.
 
+SYNOPSIS
+
+  local bit = require 'bit.numberlua'
+  print(bit.band(0xff00ff00, 0x00ff00ff)) --> 0xffffffff
+  
+  -- Interface providing strong Lua 5.2 'bit32' compatibility
+  local bit32 = require 'bit.numberlua'.bit32
+  assert(bit32.band(-1) == 0xffffffff)
+  
 DESCRIPTION
   
   This library implements bitwise operations entirely in Lua.
@@ -24,6 +33,11 @@ DESCRIPTION
   The `xor` function in this module is based partly on Roberto Ierusalimschy's
   post in http://lua-users.org/lists/lua-l/2002-09/msg00134.html .
   
+  The included BIT.bit32 sublibrary aims to provide 100% compatibility with
+  the Lua 5.2 "bit32" library.  This compatbility is at the cost of some
+  efficiency since inputted numbers are normalized and more general
+  forms (e.g. multi-argument bitwise operators) are supported.
+  
 STATUS
 
   WARNING: Not all corner cases have been tested and documented.
@@ -32,6 +46,9 @@ STATUS
   are currently some differences.  Addressing these differences may
   be improved in the future but it is not yet fully determined how to
   resolve these differences.
+  
+  The BIT.bit32 library passes the Lua 5.2 test suite (bitwise.lua)
+  http://www.lua.org/tests/5.2/ .
 
 API
 
@@ -45,15 +62,15 @@ API
   
   BIT.band(x, y) --> z
   
-    Similar to function in Lua 5.2 and BitOp but required two arguments.
+    Similar to function in Lua 5.2 and BitOp but requires two arguments.
   
   BIT.bor(x, y) --> z
   
-    Similar to function in Lua 5.2 and BitOp but required two arguments.
+    Similar to function in Lua 5.2 and BitOp but requires two arguments.
 
   BIT.bxor(x, y) --> z
   
-    Similar to function in Lua 5.2 and BitOp but required two arguments.
+    Similar to function in Lua 5.2 and BitOp but requires two arguments.
   
   BIT.bnot(x) --> z
   
@@ -91,12 +108,30 @@ API
   
   BIT.arshift
   
-    NOT IMPLEMENTED yet.  Similar to function in Lua 5.2 and BitOp.
+    Similar to function in Lua 5.2 and BitOp.
     
   BIT.btest
   
-    NOT IMPLEMENTED yet.  Similar to function in Lua 5.2.
+    Similar to function in Lua 5.2 with requires two arguments.
 
+  BIT.bit32
+  
+    This table contains functions that aim to provide 100% compatibility
+    with the Lua 5.2 "bit32" library.
+    
+    bit32.arshift (x, disp) --> z
+    bit32.band (...) --> z
+    bit32.bnot (x) --> z
+    bit32.bor (...) --> z
+    bit32.btest (...) --> true | false
+    bit32.bxor (...) --> z
+    bit32.extract (x, field [, width]) --> z
+    bit32.replace (x, v, field [, width]) --> z
+    bit32.lrotate (x, disp) --> z
+    bit32.lshift (x, disp) --> z
+    bit32.rrotate (x, disp) --> z
+    bit32.rshift (x, disp) --> z
+    
 DEPENDENCIES
 
   None (other than Lua 5.1 or 5.2).
@@ -140,6 +175,9 @@ local M = {_TYPE='module', _NAME='bit.numberlua', _VERSION='000.003.2011-11-29'}
 
 local floor = math.floor
 
+local MOD = 2^32
+local MODM = MOD-1
+
 local function memoize(f)
   local mt = {}
   local t = setmetatable({}, mt)
@@ -184,24 +222,24 @@ end
 M.bxor = make_bitop {[0]={[0]=0,[1]=1},[1]={[0]=1,[1]=0}, n=4}
 local bxor = M.bxor
 
-local F8 = 2^32 - 1
-function M.bnot(a)   return F8 - a end
+function M.bnot(a)   return MODM - a end
 local bnot = M.bnot
 
 function M.band(a,b) return ((a+b) - bxor(a,b))/2 end
 local band = M.band
 
-function M.bor(a,b)  return F8 - band(F8 - a, F8 - b) end
+function M.bor(a,b)  return MODM - band(MODM - a, MODM - b) end
+local bor = M.bor
 
 local lshift, rshift -- forward declare
 
-function M.rshift(a,disp) -- Lua5.2 style
+function M.rshift(a,disp) -- Lua5.2 insipred
   if disp < 0 then return lshift(a,-disp) end
   return floor(a % 2^32 / 2^disp)
 end
 rshift = M.rshift
 
-function M.lshift(a,disp) -- Lua5.2 style
+function M.lshift(a,disp) -- Lua5.2 inspired
   if disp < 0 then return rshift(a,-disp) end 
   return (a * 2^disp) % 2^32
 end
@@ -218,18 +256,20 @@ function M.tohex(x, n) -- BitOp style
   return ('%0'..n..(up and 'X' or 'x')):format(x)
 end
 
-function M.extract(n, field, width) -- Lua5.2 style
+function M.extract(n, field, width) -- Lua5.2 inspired
   width = width or 1
   return band(rshift(n, field), 2^width-1)
 end
+local extract = M.extract
 
-function M.replace(n, v, field, width) -- Lua5.2 style
+function M.replace(n, v, field, width) -- Lua5.2 inspired
   width = width or 1
   local mask1 = 2^width-1
   v = band(v, mask1) -- required by spec?
   local mask = bnot(lshift(mask1, field))
   return band(n, mask) + lshift(v, field)
 end
+local replace = M.replace
 
 function M.bswap(x)  -- BitOp style
   local a = band(x, 0xff); x = rshift(x, 8)
@@ -239,18 +279,153 @@ function M.bswap(x)  -- BitOp style
   return lshift(lshift(lshift(a, 8) + b, 8) + c, 8) + d
 end
 
-function M.rrotate(x, disp)  -- Lua5.2 style
+function M.rrotate(x, disp)  -- Lua5.2 inspired
   disp = disp % 32
   local low = band(x, 2^disp-1)
   return rshift(x, disp) + lshift(low, 32-disp)
 end
 local rrotate = M.rrotate
 
-function M.lrotate(x, disp)  -- Lua5.2 style
+function M.lrotate(x, disp)  -- Lua5.2 inspired
   return rrotate(x, -disp)
 end
+local lrotate = M.lrotate
+
+M.rol = M.lrotate  -- LuaOp inspired
+M.ror = M.rrotate  -- LuaOp insipred
+
+
+function M.arshift(x, disp) -- Lua5.2 inspired
+  local z = rshift(x, disp)
+  if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
+  return z
+end
+
+function M.btest(x, y) -- Lua5.2 inspired
+  return band(x, y) ~= 0
+end
+
+--
+-- Start Lua 5.2 "bit32" compat section.
+--
+
+M.bit32 = {} -- Lua 5.2 'bit32' compatibility
+
+
+local function bit32_bnot(x)
+  return (-1 - x) % MOD
+end
+M.bit32.bnot = bit32_bnot
+
+local function bit32_bxor(a, b, c, ...)
+  local z
+  if b then
+    a = a % MOD
+    b = b % MOD
+    z = bxor(a, b)
+    if c then
+      z = bxor(z, c, ...)
+    end
+    return z
+  elseif a then
+    return a % MOD
+  else
+    return 0
+  end
+end
+M.bit32.bxor = bit32_bxor
+
+local function bit32_band(a, b, c, ...)
+  local z
+  if b then
+    a = a % MOD
+    b = b % MOD
+    z = ((a+b) - bxor(a,b)) / 2
+    if c then
+      z = band(z, c, ...)
+    end
+    return z
+  elseif a then
+    return a % MOD
+  else
+    return MODM
+  end
+end
+M.bit32.band = bit32_band
+
+local function bit32_bor(a, b, c, ...)
+  local z
+  if b then
+    a = a % MOD
+    b = b % MOD
+    z = MODM - band(MODM - a, MODM - b)
+    if c then
+      z = bor(z, c, ...)
+    end
+    return z
+  elseif a then
+    return a % MOD
+  else
+    return 0
+  end
+end
+M.bit32.bor = bit32_bor
+
+function M.bit32.btest(...)
+  return bit32_band(...) ~= 0
+end
+
+function M.bit32.lrotate(x, disp)
+  return lrotate(x % MOD, disp)
+end
+
+function M.bit32.rrotate(x, disp)
+  return rrotate(x % MOD, disp)
+end
+
+function M.bit32.lshift(x,disp)
+  if disp > 31 or disp < -31 then return 0 end
+  return lshift(x % MOD, disp)
+end
+
+function M.bit32.rshift(x,disp)
+  if disp > 31 or disp < -31 then return 0 end
+  return rshift(x % MOD, disp)
+end
+
+function M.bit32.arshift(x,disp)
+  x = x % MOD
+  if disp >= 0 then
+    if disp > 31 then
+      return (x >= 0x80000000) and MODM or 0
+    else
+      local z = rshift(x, disp)
+      if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
+      return z
+    end
+  else
+    return lshift(x, -disp)
+  end
+end
+
+function M.bit32.extract(x, field, ...)
+  local width = ... or 1
+  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
+  x = x % MOD
+  return extract(x, field, ...)
+end
+
+function M.bit32.replace(x, v, field, ...)
+  local width = ... or 1
+  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
+  x = x % MOD
+  v = v % MOD
+  return replace(x, v, field, ...)
+end
+
+
+-- TODO? Likewise add  LuaOp "bit" compat section?
+-- M.bit32 = {} -- LuaOp "bit" compatibility
 
-M.rol = M.lrotate  -- LuaOp style
-M.ror = M.rrotate  -- LuaOp style
 
 return M

test.lua

@@ -42,6 +42,11 @@ checkeq(bit.band(0xffffffff,0), 0)
 checkeq(bit.band(0xa207f158,0x2e1054c9), 0x22005048)
 -- note: multiple args not currently supported
 
+-- bit.btest
+checkeq(bit.btest(0,0), false)
+checkeq(bit.btest(0xf000,0xf000), true)
+checkeq(bit.btest(0xffffffff,0), false)
+
 --- bit.bor
 checkeq(bit.bor(0,0), 0)
 checkeq(bit.bor(0xffffffff,0xffffffff), 0xffffffff)
@@ -82,9 +87,20 @@ checkeq(bit.ror, bit.rrotate)
 checkeq(bit.bswap(0x12345678), 0x78563412)
 checkeq(bit.bswap(0x78563412), 0x12345678)
 
---TODO
 -- bit.arshift
--- bit.btest
-
+checkeq(bit.arshift(0, 0), 0)
+checkeq(bit.arshift(0xffffffff, 0), 0xffffffff)
+checkeq(bit.arshift(0xffffffff, 4), 0xffffffff)
+checkeq(bit.arshift(0xffffffff, 32), 0xffffffff)
+checkeq(bit.arshift(0x7fffffff, 4), 0x07ffffff)
+checkeq(bit.arshift(0x7fffffff, 31), 0)
+checkeq(bit.arshift(0x7fffffff, 32), 0)
+
+-- Note: optionally run bitwise.lua from Lua test suite.
+-- http://www.lua.org/tests/5.2/
+if TEST_BIT32 then
+  bit32 = require 'bit.numberlua' . bit32
+  dofile 'bitwise.lua'
+end
 
 print 'DONE'