apps/plugins/lua/lbitlib.c

   1 /* Bitwise operations library */
   2 /* (c) Reuben Thomas 2000-2008 */
   3 /* bitlib is copyright Reuben Thomas 2000-2008, and is released under the MIT
   4    license, like Lua (see http://www.lua.org/copyright.html; it's
   5    basically the same as the BSD license). There is no warranty. */
   6
   7 #include "config.h"
   8
   9 #include "lua.h"
  10 #include "lauxlib.h"
  11 #include <limits.h>
  12
  13
  14 /* FIXME: Assume lua_Integer is ptrdiff_t */
  15 #define LUA_INTEGER_MAX INTPTR_MAX
  16 #define LUA_INTEGER_MIN INTPTR_MIN
  17
  18 /* FIXME: Assume size_t is an unsigned lua_Integer */
  19 typedef size_t lua_UInteger;
  20 #define LUA_UINTEGER_MAX UINT_MAX
  21
  22
  23 /* Bit type size and limits */
  24
  25 #define BIT_BITS (CHAR_BIT * sizeof(lua_Integer))
  26
  27 /* This code may give warnings if BITLIB_FLOAT_* are too big to fit in
  28    long, but that doesn't matter since in that case they won't be
  29    used. */
  30 #define BIT_MAX  (LUA_INTEGER_MAX)
  31
  32 #define BIT_MIN  (LUA_INTEGER_MIN)
  33
  34 #define BIT_UMAX (LUA_UINTEGER_MAX)
  35
  36
  37 /* Define TOBIT to get a bit value */
  38 #ifdef BUILTIN_CAST
  39 #define
  40 #define TOBIT(L, n, res)                    \
  41   ((void)(res), luaL_checkinteger((L), (n)))
  42 #else
  43
  44 #define TOBIT(L, n, res)                                            \
  45   ((lua_Integer)(((res) = luaL_checknumber(L, (n)) % BIT_UMAX), \
  46                  (res) > BIT_MAX ? ((res) -= BIT_UMAX, (res) -= 1) : \
  47                  ((res) < BIT_MIN ? ((res) += BIT_UMAX, (res) += 1) : (res))))
  48 #endif
  49
  50
  51 #define BIT_TRUNCATE(i)                         \
  52   ((i) & BIT_UMAX)
  53
  54
  55 /* Operations
  56
  57    The macros MONADIC and VARIADIC only deal with bitwise operations.
  58
  59    LOGICAL_SHIFT truncates its left-hand operand before shifting so
  60    that any extra bits at the most-significant end are not shifted
  61    into the result.
  62
  63    ARITHMETIC_SHIFT does not truncate its left-hand operand, so that
  64    the sign bits are not removed and right shift work properly.
  65    */
  66
  67 #define MONADIC(name, op)                                       \
  68   static int bit_ ## name(lua_State *L) {                       \
  69     lua_Number f;                                               \
  70     lua_pushinteger(L, BIT_TRUNCATE(op TOBIT(L, 1, f)));        \
  71     return 1;                                                   \
  72   }
  73
  74 #define VARIADIC(name, op)                      \
  75   static int bit_ ## name(lua_State *L) {       \
  76     lua_Number f;                               \
  77     int n = lua_gettop(L), i;                   \
  78     lua_Integer w = TOBIT(L, 1, f);             \
  79     for (i = 2; i <= n; i++)                    \
  80       w op TOBIT(L, i, f);                      \
  81     lua_pushinteger(L, BIT_TRUNCATE(w));        \
  82     return 1;                                   \
  83   }
  84
  85 #define LOGICAL_SHIFT(name, op)                                         \
  86   static int bit_ ## name(lua_State *L) {                               \
  87     lua_Number f;                                                       \
  88     lua_pushinteger(L, BIT_TRUNCATE(BIT_TRUNCATE((lua_UInteger)TOBIT(L, 1, f)) op \
  89                                     (unsigned)luaL_checknumber(L, 2))); \
  90     return 1;                                                           \
  91   }
  92
  93 #define ARITHMETIC_SHIFT(name, op)                                      \
  94   static int bit_ ## name(lua_State *L) {                               \
  95     lua_Number f;                                                       \
  96     lua_pushinteger(L, BIT_TRUNCATE((lua_Integer)TOBIT(L, 1, f) op      \
  97                                     (unsigned)luaL_checknumber(L, 2))); \
  98     return 1;                                                           \
  99   }
 100
 101 MONADIC(bnot,  ~)
 102 VARIADIC(band, &=)
 103 VARIADIC(bor,  |=)
 104 VARIADIC(bxor, ^=)
 105 ARITHMETIC_SHIFT(lshift,  <<)
 106 LOGICAL_SHIFT(rshift,     >>)
 107 ARITHMETIC_SHIFT(arshift, >>)
 108
 109 static const struct luaL_reg bitlib[] = {
 110   {"bnot",    bit_bnot},
 111   {"band",    bit_band},
 112   {"bor",     bit_bor},
 113   {"bxor",    bit_bxor},
 114   {"lshift",  bit_lshift},
 115   {"rshift",  bit_rshift},
 116   {"arshift", bit_arshift},
 117   {NULL, NULL}
 118 };
 119
 120 LUALIB_API int luaopen_bit (lua_State *L) {
 121   luaL_register(L, "bit", bitlib);
 122   lua_pushnumber(L, BIT_BITS);
 123   lua_setfield(L, -2, "bits");
 124   return 1;
 125 }