[Wxlua-commit] wxLua/modules/wxlua/src wxlstate.cpp,1.169,1.170

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/wxlua/wxLua/modules/wxlua/src
In directory sc8-pr-cvs9.sourceforge.net:/tmp/cvs-serv15324/wxLua/modules/wxlua/src

Modified Files:
	wxlstate.cpp 
Log Message:
Update bitlib to version 25

Index: wxlstate.cpp
===================================================================
RCS file: /cvsroot/wxlua/wxLua/modules/wxlua/src/wxlstate.cpp,v
retrieving revision 1.169
retrieving revision 1.170
diff -C2 -d -r1.169 -r1.170
*** wxlstate.cpp	29 Jan 2008 00:49:15 -0000	1.169
--- wxlstate.cpp	1 Feb 2008 05:36:38 -0000	1.170
***************
*** 3994,4002 ****
  }

  //-----------------------------------------------------------------------------
! // bitlib release 21 - Bitwise operations library
  // by Reuben Thomas <rr...@sc...>
  // http://luaforge.net/projects/bitlib
! // copyright Reuben Thomas 2000-2006, and is released under the MIT license
  //-----------------------------------------------------------------------------

--- 3994,4003 ----
  }

+ 
  //-----------------------------------------------------------------------------
! // bitlib release 25 - Bitwise operations library
  // by Reuben Thomas <rr...@sc...>
  // http://luaforge.net/projects/bitlib
! // copyright Reuben Thomas 2000-2008, and is released under the MIT license
  //-----------------------------------------------------------------------------

***************
*** 4005,4054 ****

  /* Bitwise operations library */
! /* Reuben Thomas   nov00-08dec06 */

! //#include "lauxlib.h"
! //#include "lua.h"

! //#include <inttypes.h>

! //typedef uintmax_t Integer;
! //typedef intmax_t UInteger;

! typedef long Integer; // FIXME - is this good enough? probably for us
! typedef unsigned long UInteger;

! #define TDYADIC(name, op, type1, type2) \
!   static int bit_ ## name(lua_State* L) { \
!     lua_pushnumber(L, \
!       (type1)luaL_checknumber(L, 1) op (type2)luaL_checknumber(L, 2)); \
!     return 1; \
    }

! #define MONADIC(name, op, type) \
!   static int bit_ ## name(lua_State* L) { \
!     lua_pushnumber(L, op (type)luaL_checknumber(L, 1)); \
!     return 1; \
    }

! #define VARIADIC(name, op, type) \
!   static int bit_ ## name(lua_State *L) { \
!     int n = lua_gettop(L), i; \
!     Integer w = (type)luaL_checknumber(L, 1); \
!     for (i = 2; i <= n; i++) \
!       w op (type)luaL_checknumber(L, i); \
!     lua_pushnumber(L, w); \
!     return 1; \
    }

! MONADIC(bnot,    ~,  Integer)
! VARIADIC(band,   &=, Integer)
! VARIADIC(bor,    |=, Integer)
! VARIADIC(bxor,   ^=, Integer)
! TDYADIC(lshift,  <<, Integer, UInteger)
! TDYADIC(rshift,  >>, UInteger, UInteger)
! TDYADIC(arshift, >>, Integer, UInteger)
! TDYADIC(mod,     %,  Integer, Integer)

  static const struct luaL_reg bitlib[] = {
    {"bnot",    bit_bnot},
    {"band",    bit_band},
--- 4006,4134 ----

  /* Bitwise operations library */
! /* (c) Reuben Thomas 2000-2008 */
! /* See README for license */

! //#include "config.h"

! //#include <lua.h>
! //#include <lauxlib.h>
! #include <limits.h>

! //#include "bit_limits.h"
! #define BITLIB_FLOAT_BITS 53
! #define BITLIB_FLOAT_MAX  0xfffffffffffffL
! #define BITLIB_FLOAT_MIN  (-0x10000000000000L)
! #define BITLIB_FLOAT_UMAX 0x1fffffffffffffULL

! /* FIXME: Assume lua_Integer is ptrdiff_t */
! #define LUA_INTEGER_MAX PTRDIFF_MAX
! #define LUA_INTEGER_MIN PTRDIFF_MIN

! #ifndef SIZE_MAX
! #define SIZE_MAX ((size_t)-1)
! #endif
! 
! /* FIXME: Assume 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 BUILTIN_CAST
! 
! /* Define TOBIT to get a bit value */
! #ifdef BUILTIN_CAST
! #define TOBIT(L, n, res)                    \
!   ((void)(res), luaL_checkinteger((L), (n)))
! #else
! #include <stdint.h>
! #include <math.h>
! 
! /* FIXME: Assume 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},
***************
*** 4058,4067 ****
    {"rshift",  bit_rshift},
    {"arshift", bit_arshift},
!   {"mod",     bit_mod},
    {NULL, NULL}
  };

! int LUACALL luaopen_bit (lua_State *L) {
!   luaL_openlib(L, "bit", bitlib, 0);
    return 1;
  }
--- 4138,4149 ----
    {"rshift",  bit_rshift},
    {"arshift", bit_arshift},
! 
    {NULL, NULL}
  };

! 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;
  }