X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/da9d456e9fabb82fcaefdddcaac50d38b35cf3d9..77cd612f15cb8b50229dbba5e8ec18c8a0bca6f5:/client/pm3_bitlib.c

diff --git a/client/pm3_bitlib.c b/client/pm3_bitlib.c
new file mode 100644
index 00000000..29fc49f1
--- /dev/null
+++ b/client/pm3_bitlib.c
@@ -0,0 +1,152 @@
+/* Bitwise operations library */
+/* (c) Reuben Thomas 2000-2008 */
+/* See README for license */
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <limits.h>
+
+#include "pm3_bit_limits.h"
+
+
+/* FIXME: Assumes lua_Integer is ptrdiff_t */
+#define LUA_INTEGER_MAX PTRDIFF_MAX
+#define LUA_INTEGER_MIN PTRDIFF_MIN
+
+/* FIXME: Assumes size_t is an unsigned lua_Integer */
+typedef size_t lua_UInteger;
+#define LUA_UINTEGER_MAX SIZE_MAX
+
+
+/* Bit type size and limits */
+
+#define BIT_BITS                                                        \
+  (CHAR_BIT * sizeof(lua_Integer) > BITLIB_FLOAT_BITS ?                 \
+   BITLIB_FLOAT_BITS : (CHAR_BIT * sizeof(lua_Integer)))
+
+/* This code may give warnings if BITLIB_FLOAT_* are too big to fit in
+   long, but that doesn't matter since in that case they won't be
+   used. */
+#define BIT_MAX                                                         \
+  (CHAR_BIT * sizeof(lua_Integer) > BITLIB_FLOAT_BITS ? BITLIB_FLOAT_MAX : LUA_INTEGER_MAX)
+
+#define BIT_MIN                                                         \
+  (CHAR_BIT * sizeof(lua_Integer) > BITLIB_FLOAT_BITS ? BITLIB_FLOAT_MIN : LUA_INTEGER_MIN)
+
+#define BIT_UMAX                                                        \
+  (CHAR_BIT * sizeof(lua_Integer) > BITLIB_FLOAT_BITS ? BITLIB_FLOAT_UMAX : LUA_UINTEGER_MAX)
+
+
+/* Define TOBIT to get a bit value */
+#ifdef BUILTIN_CAST
+#define
+#define TOBIT(L, n, res)                    \
+  ((void)(res), luaL_checkinteger((L), (n)))
+#else
+#include <stdint.h>
+#include <math.h>
+
+/* FIXME: Assumes lua_Number fits in a double (use of fmod). */
+#define TOBIT(L, n, res)                                            \
+  ((lua_Integer)(((res) = fmod(luaL_checknumber(L, (n)), (double)BIT_UMAX + 1.0)), \
+                 (res) > BIT_MAX ? ((res) -= (double)BIT_UMAX, (res) -= 1) : \
+                 ((res) < BIT_MIN ? ((res) += (double)BIT_UMAX, (res) += 1) : (res))))
+#endif
+
+
+#define BIT_TRUNCATE(i)                         \
+  ((i) & BIT_UMAX)
+
+
+/* Operations
+
+   The macros MONADIC and VARIADIC only deal with bitwise operations.
+
+   LOGICAL_SHIFT truncates its left-hand operand before shifting so
+   that any extra bits at the most-significant end are not shifted
+   into the result.
+
+   ARITHMETIC_SHIFT does not truncate its left-hand operand, so that
+   the sign bits are not removed and right shift work properly.
+   */
+
+#define MONADIC(name, op)                                       \
+  static int bit_ ## name(lua_State *L) {                       \
+    lua_Number f;                                               \
+    lua_pushinteger(L, BIT_TRUNCATE(op TOBIT(L, 1, f)));        \
+    return 1;                                                   \
+  }
+
+#define VARIADIC(name, op)                      \
+  static int bit_ ## name(lua_State *L) {       \
+    lua_Number f;                               \
+    int n = lua_gettop(L), i;                   \
+    lua_Integer w = TOBIT(L, 1, f);             \
+    for (i = 2; i <= n; i++)                    \
+      w op TOBIT(L, i, f);                      \
+    lua_pushinteger(L, BIT_TRUNCATE(w));        \
+    return 1;                                   \
+  }
+
+#define LOGICAL_SHIFT(name, op)                                         \
+  static int bit_ ## name(lua_State *L) {                               \
+    lua_Number f;                                                       \
+    lua_pushinteger(L, BIT_TRUNCATE(BIT_TRUNCATE((lua_UInteger)TOBIT(L, 1, f)) op \
+                                    (unsigned)luaL_checknumber(L, 2))); \
+    return 1;                                                           \
+  }
+
+#define ARITHMETIC_SHIFT(name, op)                                      \
+  static int bit_ ## name(lua_State *L) {                               \
+    lua_Number f;                                                       \
+    lua_pushinteger(L, BIT_TRUNCATE((lua_Integer)TOBIT(L, 1, f) op      \
+                                    (unsigned)luaL_checknumber(L, 2))); \
+    return 1;                                                           \
+  }
+
+MONADIC(cast,  +)
+MONADIC(bnot,  ~)
+VARIADIC(band, &=)
+VARIADIC(bor,  |=)
+VARIADIC(bxor, ^=)
+ARITHMETIC_SHIFT(lshift,  <<)
+LOGICAL_SHIFT(rshift,     >>)
+ARITHMETIC_SHIFT(arshift, >>)
+
+static const struct luaL_Reg bitlib[] = {
+  {"cast",    bit_cast},
+  {"bnot",    bit_bnot},
+  {"band",    bit_band},
+  {"bor",     bit_bor},
+  {"bxor",    bit_bxor},
+  {"lshift",  bit_lshift},
+  {"rshift",  bit_rshift},
+  {"arshift", bit_arshift},
+  {NULL, NULL}
+};
+
+LUALIB_API int luaopen_bit (lua_State *L) {
+	luaL_newlib(L, bitlib);
+	//luaL_register(L, "bit", bitlib);
+	lua_pushnumber(L, BIT_BITS);
+	lua_setfield(L, -2, "bits");
+	return 1;
+}
+
+/**
+LUALIB_API int luaopen_bit (lua_State *L) {
+  luaL_register(L, "bit", bitlib);
+  lua_pushnumber(L, BIT_BITS);
+  lua_setfield(L, -2, "bits");
+  return 1;
+}
+**/
+/*
+** Open bit library
+*/
+int set_bit_library (lua_State *L) {
+
+   luaL_requiref(L, "bit", luaopen_bit, 1);
+   lua_pop(L, 1);
+  return 1;
+}