lua

commit 29256e8960d7f4bae728bb07a86eb0d604f5d98d
parent 438c534ff4c8ccad117354826d4ac133b84f2fdc
Author: Roberto Ierusalimschy <roberto@inf.puc-rio.br>
Date:   Sun,  5 Jan 2014 12:05:33 -0200

first implementation of string.packint/string.unpackint

Diffstat:
M
lstrlib.c
 | 
125
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-

1 file changed, 124 insertions(+), 1 deletion(-)
diff --git a/lstrlib.c b/lstrlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstrlib.c,v 1.181 2013/06/19 14:29:01 roberto Exp roberto $
+** $Id: lstrlib.c,v 1.182 2013/06/20 15:06:51 roberto Exp roberto $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
@@ -938,6 +938,127 @@ static int str_format (lua_State *L) {
 /* }====================================================== */
 
 
+/*
+** {======================================================
+** PACK/UNPACK
+** =======================================================
+*/
+
+/* maximum size for the binary representation of an integer */
+#define MAXINTSIZE	8
+
+
+static union {
+  int dummy;
+  char little;  /* true iff machine is little endian */
+} const nativeendian = {1};
+
+
+static int getendian (lua_State *L, int arg) {
+  const char *endian = luaL_optstring(L, arg,
+                             (nativeendian.little ? "l" : "b"));
+  luaL_argcheck(L, *endian == 'l' || *endian == 'b', arg,
+                   "endianess must be 'l' or 'b'");
+  return (*endian == 'l');
+}
+
+
+static int getintsize (lua_State *L, int arg) {
+  int size = luaL_optint(L, arg, sizeof(lua_Integer));
+  luaL_argcheck(L, 1 <= size && size <= MAXINTSIZE, arg,
+                   "integer size out of valid range");
+  return size;
+}
+
+
+static int packint (char *buff, lua_Integer n, int littleendian, int size) {
+  int i;
+  if (littleendian) {
+    for (i = 0; i < size - 1; i++) {
+      buff[i] = (n & 0xff);
+      n >>= 8;
+    }
+  }
+  else {
+    for (i = size - 1; i > 0; i--) {
+      buff[i] = (n & 0xff);
+      n >>= 8;
+    }
+  }
+  buff[i] = (n & 0xff);  /* last byte */
+  /* test for overflow: OK if there are only zeros left in higher bytes,
+     or if there are only oneś left and packed number is negative (signal
+     bit, the higher bit in last byte, is one) */
+  return ((n & ~(lua_Integer)0xff) == 0 || (n | 0x7f) == ~(lua_Integer)0);
+}
+
+
+static int packint_l (lua_State *L) {
+  char buff[MAXINTSIZE];
+  lua_Integer n = luaL_checkinteger(L, 1);
+  int size = getintsize(L, 2);
+  int endian = getendian(L, 3);
+  if (packint(buff, n, endian, size))
+    lua_pushlstring(L, buff, size);
+  else
+    luaL_error(L, "integer does not fit into given size (%d)", size);
+  return 1;
+}
+
+
+/* mask to check higher-order byte in a Lua integer */
+#define HIGHERBYTE	(~((lua_Unsigned)~0 >> 8))
+
+/* mask to check higher-order byte + signal bit of next byte */
+#define HIGHERBYTE1	(~((lua_Unsigned)~0 >> 9))
+
+static int unpackint (const char *buff, lua_Integer *res,
+                      int littleendian, int size) {
+  lua_Integer n = 0;
+  int i;
+  for (i = 0; i < size; i++) {
+    if (i >= (int)sizeof(lua_Integer)) {  /* will throw away a byte? */
+      /* check for overflow: it is OK to throw away leading zeros for a
+         positive number; leading ones for a negative number; and one
+         last leading zero to allow unsigned integers with a 1 in
+         its "signal bit" */
+      if (!((n & HIGHERBYTE1) == 0 ||  /* zeros for pos. number */
+          (n & HIGHERBYTE1) == HIGHERBYTE1 ||  /* ones for neg. number */
+          ((n & HIGHERBYTE) == 0 && i == size - 1)))  /* last zero */
+        return 0;  /* overflow */
+    }
+    n <<= 8;
+    n |= (lua_Integer)(unsigned char)buff[littleendian ? size - 1 - i : i];
+  }
+  if (size < (int)sizeof(lua_Integer)) {  /* need sign extension? */
+    lua_Integer mask = (~(lua_Integer)0) << (size*8 - 1);
+    if (n & mask)  /* negative value? */
+      n |= mask;  /* signal extension */
+  }
+  *res = n;
+  return 1;
+}
+
+
+static int unpackint_l (lua_State *L) {
+  lua_Integer res;
+  size_t len;
+  const char *s = luaL_checklstring(L, 1, &len);
+  lua_Integer pos = posrelat(luaL_optinteger(L, 2, 1), len);
+  int size = getintsize(L, 3);
+  int endian = getendian(L, 4);
+  luaL_argcheck(L, 1 <= pos && (size_t)pos + size - 1 <= len, 1,
+                   "string too short");
+  if(unpackint(s + pos - 1, &res, endian, size))
+    lua_pushinteger(L, res);
+  else
+    luaL_error(L, "result does not fit into a Lua integer");
+  return 1;
+}
+
+/* }====================================================== */
+
+
 static const luaL_Reg strlib[] = {
   {"byte", str_byte},
   {"char", str_char},
@@ -953,6 +1074,8 @@ static const luaL_Reg strlib[] = {
   {"reverse", str_reverse},
   {"sub", str_sub},
   {"upper", str_upper},
+  {"packint", packint_l},
+  {"unpackint", unpackint_l},
   {NULL, NULL}
 };