mirror of
https://github.com/cloudwu/skynet.git
synced 2026-07-24 03:53:09 +00:00
update to lua 5.3, remove lua unsigned api
This commit is contained in:
Cloud Wu
@@ -1,19 +1,22 @@
|
||||
/*
|
||||
** $Id: lstrlib.c,v 1.178.1.1 2013/04/12 18:48:47 roberto Exp $
|
||||
** $Id: lstrlib.c,v 1.221 2014/12/11 14:03:07 roberto Exp $
|
||||
** Standard library for string operations and pattern-matching
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lstrlib_c
|
||||
#define LUA_LIB
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define lstrlib_c
|
||||
#define LUA_LIB
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lauxlib.h"
|
||||
@@ -29,10 +32,19 @@
|
||||
#endif
|
||||
|
||||
|
||||
/* macro to `unsign' a character */
|
||||
/* macro to 'unsign' a character */
|
||||
#define uchar(c) ((unsigned char)(c))
|
||||
|
||||
|
||||
/*
|
||||
** Some sizes are better limited to fit in 'int', but must also fit in
|
||||
** 'size_t'. (We assume that 'lua_Integer' cannot be smaller than 'int'.)
|
||||
*/
|
||||
#define MAXSIZE \
|
||||
(sizeof(size_t) < sizeof(int) ? (~(size_t)0) : (size_t)(INT_MAX))
|
||||
|
||||
|
||||
|
||||
|
||||
static int str_len (lua_State *L) {
|
||||
size_t l;
|
||||
@@ -43,22 +55,22 @@ static int str_len (lua_State *L) {
|
||||
|
||||
|
||||
/* translate a relative string position: negative means back from end */
|
||||
static size_t posrelat (ptrdiff_t pos, size_t len) {
|
||||
if (pos >= 0) return (size_t)pos;
|
||||
static lua_Integer posrelat (lua_Integer pos, size_t len) {
|
||||
if (pos >= 0) return pos;
|
||||
else if (0u - (size_t)pos > len) return 0;
|
||||
else return len - ((size_t)-pos) + 1;
|
||||
else return (lua_Integer)len + pos + 1;
|
||||
}
|
||||
|
||||
|
||||
static int str_sub (lua_State *L) {
|
||||
size_t l;
|
||||
const char *s = luaL_checklstring(L, 1, &l);
|
||||
size_t start = posrelat(luaL_checkinteger(L, 2), l);
|
||||
size_t end = posrelat(luaL_optinteger(L, 3, -1), l);
|
||||
lua_Integer start = posrelat(luaL_checkinteger(L, 2), l);
|
||||
lua_Integer end = posrelat(luaL_optinteger(L, 3, -1), l);
|
||||
if (start < 1) start = 1;
|
||||
if (end > l) end = l;
|
||||
if (end > (lua_Integer)l) end = l;
|
||||
if (start <= end)
|
||||
lua_pushlstring(L, s + start - 1, end - start + 1);
|
||||
lua_pushlstring(L, s + start - 1, (size_t)(end - start + 1));
|
||||
else lua_pushliteral(L, "");
|
||||
return 1;
|
||||
}
|
||||
@@ -102,25 +114,23 @@ static int str_upper (lua_State *L) {
|
||||
}
|
||||
|
||||
|
||||
/* reasonable limit to avoid arithmetic overflow */
|
||||
#define MAXSIZE ((~(size_t)0) >> 1)
|
||||
|
||||
static int str_rep (lua_State *L) {
|
||||
size_t l, lsep;
|
||||
const char *s = luaL_checklstring(L, 1, &l);
|
||||
int n = luaL_checkint(L, 2);
|
||||
lua_Integer n = luaL_checkinteger(L, 2);
|
||||
const char *sep = luaL_optlstring(L, 3, "", &lsep);
|
||||
if (n <= 0) lua_pushliteral(L, "");
|
||||
else if (l + lsep < l || l + lsep >= MAXSIZE / n) /* may overflow? */
|
||||
else if (l + lsep < l || l + lsep > MAXSIZE / n) /* may overflow? */
|
||||
return luaL_error(L, "resulting string too large");
|
||||
else {
|
||||
size_t totallen = n * l + (n - 1) * lsep;
|
||||
size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep;
|
||||
luaL_Buffer b;
|
||||
char *p = luaL_buffinitsize(L, &b, totallen);
|
||||
while (n-- > 1) { /* first n-1 copies (followed by separator) */
|
||||
memcpy(p, s, l * sizeof(char)); p += l;
|
||||
if (lsep > 0) { /* avoid empty 'memcpy' (may be expensive) */
|
||||
memcpy(p, sep, lsep * sizeof(char)); p += lsep;
|
||||
if (lsep > 0) { /* empty 'memcpy' is not that cheap */
|
||||
memcpy(p, sep, lsep * sizeof(char));
|
||||
p += lsep;
|
||||
}
|
||||
}
|
||||
memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */
|
||||
@@ -133,14 +143,14 @@ static int str_rep (lua_State *L) {
|
||||
static int str_byte (lua_State *L) {
|
||||
size_t l;
|
||||
const char *s = luaL_checklstring(L, 1, &l);
|
||||
size_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
|
||||
size_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
|
||||
lua_Integer posi = posrelat(luaL_optinteger(L, 2, 1), l);
|
||||
lua_Integer pose = posrelat(luaL_optinteger(L, 3, posi), l);
|
||||
int n, i;
|
||||
if (posi < 1) posi = 1;
|
||||
if (pose > l) pose = l;
|
||||
if (pose > (lua_Integer)l) pose = l;
|
||||
if (posi > pose) return 0; /* empty interval; return no values */
|
||||
n = (int)(pose - posi + 1);
|
||||
if (posi + n <= pose) /* (size_t -> int) overflow? */
|
||||
if (posi + n <= pose) /* arithmetic overflow? */
|
||||
return luaL_error(L, "string slice too long");
|
||||
luaL_checkstack(L, n, "string slice too long");
|
||||
for (i=0; i<n; i++)
|
||||
@@ -155,7 +165,7 @@ static int str_char (lua_State *L) {
|
||||
luaL_Buffer b;
|
||||
char *p = luaL_buffinitsize(L, &b, n);
|
||||
for (i=1; i<=n; i++) {
|
||||
int c = luaL_checkint(L, i);
|
||||
lua_Integer c = luaL_checkinteger(L, i);
|
||||
luaL_argcheck(L, uchar(c) == c, i, "value out of range");
|
||||
p[i - 1] = uchar(c);
|
||||
}
|
||||
@@ -164,19 +174,20 @@ static int str_char (lua_State *L) {
|
||||
}
|
||||
|
||||
|
||||
static int writer (lua_State *L, const void* b, size_t size, void* B) {
|
||||
static int writer (lua_State *L, const void *b, size_t size, void *B) {
|
||||
(void)L;
|
||||
luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);
|
||||
luaL_addlstring((luaL_Buffer *) B, (const char *)b, size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int str_dump (lua_State *L) {
|
||||
luaL_Buffer b;
|
||||
int strip = lua_toboolean(L, 2);
|
||||
luaL_checktype(L, 1, LUA_TFUNCTION);
|
||||
lua_settop(L, 1);
|
||||
luaL_buffinit(L,&b);
|
||||
if (lua_dump(L, writer, &b) != 0)
|
||||
if (lua_dump(L, writer, &b, strip) != 0)
|
||||
return luaL_error(L, "unable to dump given function");
|
||||
luaL_pushresult(&b);
|
||||
return 1;
|
||||
@@ -243,16 +254,16 @@ static const char *classend (MatchState *ms, const char *p) {
|
||||
switch (*p++) {
|
||||
case L_ESC: {
|
||||
if (p == ms->p_end)
|
||||
luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
|
||||
luaL_error(ms->L, "malformed pattern (ends with '%%')");
|
||||
return p+1;
|
||||
}
|
||||
case '[': {
|
||||
if (*p == '^') p++;
|
||||
do { /* look for a `]' */
|
||||
do { /* look for a ']' */
|
||||
if (p == ms->p_end)
|
||||
luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
|
||||
luaL_error(ms->L, "malformed pattern (missing ']')");
|
||||
if (*(p++) == L_ESC && p < ms->p_end)
|
||||
p++; /* skip escapes (e.g. `%]') */
|
||||
p++; /* skip escapes (e.g. '%]') */
|
||||
} while (*p != ']');
|
||||
return p+1;
|
||||
}
|
||||
@@ -287,7 +298,7 @@ static int matchbracketclass (int c, const char *p, const char *ec) {
|
||||
int sig = 1;
|
||||
if (*(p+1) == '^') {
|
||||
sig = 0;
|
||||
p++; /* skip the `^' */
|
||||
p++; /* skip the '^' */
|
||||
}
|
||||
while (++p < ec) {
|
||||
if (*p == L_ESC) {
|
||||
@@ -325,8 +336,7 @@ static int singlematch (MatchState *ms, const char *s, const char *p,
|
||||
static const char *matchbalance (MatchState *ms, const char *s,
|
||||
const char *p) {
|
||||
if (p >= ms->p_end - 1)
|
||||
luaL_error(ms->L, "malformed pattern "
|
||||
"(missing arguments to " LUA_QL("%%b") ")");
|
||||
luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')");
|
||||
if (*s != *p) return NULL;
|
||||
else {
|
||||
int b = *p;
|
||||
@@ -425,7 +435,7 @@ static const char *match (MatchState *ms, const char *s, const char *p) {
|
||||
break;
|
||||
}
|
||||
case '$': {
|
||||
if ((p + 1) != ms->p_end) /* is the `$' the last char in pattern? */
|
||||
if ((p + 1) != ms->p_end) /* is the '$' the last char in pattern? */
|
||||
goto dflt; /* no; go to default */
|
||||
s = (s == ms->src_end) ? s : NULL; /* check end of string */
|
||||
break;
|
||||
@@ -443,8 +453,7 @@ static const char *match (MatchState *ms, const char *s, const char *p) {
|
||||
const char *ep; char previous;
|
||||
p += 2;
|
||||
if (*p != '[')
|
||||
luaL_error(ms->L, "missing " LUA_QL("[") " after "
|
||||
LUA_QL("%%f") " in pattern");
|
||||
luaL_error(ms->L, "missing '[' after '%%f' in pattern");
|
||||
ep = classend(ms, p); /* points to what is next */
|
||||
previous = (s == ms->src_init) ? '\0' : *(s - 1);
|
||||
if (!matchbracketclass(uchar(previous), p, ep - 1) &&
|
||||
@@ -514,16 +523,16 @@ static const char *match (MatchState *ms, const char *s, const char *p) {
|
||||
static const char *lmemfind (const char *s1, size_t l1,
|
||||
const char *s2, size_t l2) {
|
||||
if (l2 == 0) return s1; /* empty strings are everywhere */
|
||||
else if (l2 > l1) return NULL; /* avoids a negative `l1' */
|
||||
else if (l2 > l1) return NULL; /* avoids a negative 'l1' */
|
||||
else {
|
||||
const char *init; /* to search for a `*s2' inside `s1' */
|
||||
l2--; /* 1st char will be checked by `memchr' */
|
||||
l1 = l1-l2; /* `s2' cannot be found after that */
|
||||
const char *init; /* to search for a '*s2' inside 's1' */
|
||||
l2--; /* 1st char will be checked by 'memchr' */
|
||||
l1 = l1-l2; /* 's2' cannot be found after that */
|
||||
while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
|
||||
init++; /* 1st char is already checked */
|
||||
if (memcmp(init, s2+1, l2) == 0)
|
||||
return init-1;
|
||||
else { /* correct `l1' and `s1' to try again */
|
||||
else { /* correct 'l1' and 's1' to try again */
|
||||
l1 -= init-s1;
|
||||
s1 = init;
|
||||
}
|
||||
@@ -539,7 +548,7 @@ static void push_onecapture (MatchState *ms, int i, const char *s,
|
||||
if (i == 0) /* ms->level == 0, too */
|
||||
lua_pushlstring(ms->L, s, e - s); /* add whole match */
|
||||
else
|
||||
luaL_error(ms->L, "invalid capture index");
|
||||
luaL_error(ms->L, "invalid capture index %%%d", i + 1);
|
||||
}
|
||||
else {
|
||||
ptrdiff_t l = ms->capture[i].len;
|
||||
@@ -578,16 +587,16 @@ static int str_find_aux (lua_State *L, int find) {
|
||||
size_t ls, lp;
|
||||
const char *s = luaL_checklstring(L, 1, &ls);
|
||||
const char *p = luaL_checklstring(L, 2, &lp);
|
||||
size_t init = posrelat(luaL_optinteger(L, 3, 1), ls);
|
||||
lua_Integer init = posrelat(luaL_optinteger(L, 3, 1), ls);
|
||||
if (init < 1) init = 1;
|
||||
else if (init > ls + 1) { /* start after string's end? */
|
||||
else if (init > (lua_Integer)ls + 1) { /* start after string's end? */
|
||||
lua_pushnil(L); /* cannot find anything */
|
||||
return 1;
|
||||
}
|
||||
/* explicit request or no special characters? */
|
||||
if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {
|
||||
/* do a plain search */
|
||||
const char *s2 = lmemfind(s + init - 1, ls - init + 1, p, lp);
|
||||
const char *s2 = lmemfind(s + init - 1, ls - (size_t)init + 1, p, lp);
|
||||
if (s2) {
|
||||
lua_pushinteger(L, s2 - s + 1);
|
||||
lua_pushinteger(L, s2 - s + lp);
|
||||
@@ -678,7 +687,8 @@ static int gmatch (lua_State *L) {
|
||||
static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
|
||||
const char *e) {
|
||||
size_t l, i;
|
||||
const char *news = lua_tolstring(ms->L, 3, &l);
|
||||
lua_State *L = ms->L;
|
||||
const char *news = lua_tolstring(L, 3, &l);
|
||||
for (i = 0; i < l; i++) {
|
||||
if (news[i] != L_ESC)
|
||||
luaL_addchar(b, news[i]);
|
||||
@@ -686,14 +696,15 @@ static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
|
||||
i++; /* skip ESC */
|
||||
if (!isdigit(uchar(news[i]))) {
|
||||
if (news[i] != L_ESC)
|
||||
luaL_error(ms->L, "invalid use of " LUA_QL("%c")
|
||||
" in replacement string", L_ESC);
|
||||
luaL_error(L, "invalid use of '%c' in replacement string", L_ESC);
|
||||
luaL_addchar(b, news[i]);
|
||||
}
|
||||
else if (news[i] == '0')
|
||||
luaL_addlstring(b, s, e - s);
|
||||
else {
|
||||
push_onecapture(ms, news[i] - '1', s, e);
|
||||
luaL_tolstring(L, -1, NULL); /* if number, convert it to string */
|
||||
lua_remove(L, -2); /* remove original value */
|
||||
luaL_addvalue(b); /* add capture to accumulated result */
|
||||
}
|
||||
}
|
||||
@@ -737,9 +748,9 @@ static int str_gsub (lua_State *L) {
|
||||
const char *src = luaL_checklstring(L, 1, &srcl);
|
||||
const char *p = luaL_checklstring(L, 2, &lp);
|
||||
int tr = lua_type(L, 3);
|
||||
size_t max_s = luaL_optinteger(L, 4, srcl+1);
|
||||
lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1);
|
||||
int anchor = (*p == '^');
|
||||
size_t n = 0;
|
||||
lua_Integer n = 0;
|
||||
MatchState ms;
|
||||
luaL_Buffer b;
|
||||
luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
|
||||
@@ -786,48 +797,17 @@ static int str_gsub (lua_State *L) {
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
** LUA_INTFRMLEN is the length modifier for integer conversions in
|
||||
** 'string.format'; LUA_INTFRM_T is the integer type corresponding to
|
||||
** the previous length
|
||||
*/
|
||||
#if !defined(LUA_INTFRMLEN) /* { */
|
||||
#if defined(LUA_USE_LONGLONG)
|
||||
|
||||
#define LUA_INTFRMLEN "ll"
|
||||
#define LUA_INTFRM_T long long
|
||||
|
||||
#else
|
||||
|
||||
#define LUA_INTFRMLEN "l"
|
||||
#define LUA_INTFRM_T long
|
||||
|
||||
#endif
|
||||
#endif /* } */
|
||||
|
||||
|
||||
/*
|
||||
** LUA_FLTFRMLEN is the length modifier for float conversions in
|
||||
** 'string.format'; LUA_FLTFRM_T is the float type corresponding to
|
||||
** the previous length
|
||||
*/
|
||||
#if !defined(LUA_FLTFRMLEN)
|
||||
|
||||
#define LUA_FLTFRMLEN ""
|
||||
#define LUA_FLTFRM_T double
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
|
||||
#define MAX_ITEM 512
|
||||
|
||||
/* valid flags in a format specification */
|
||||
#define FLAGS "-+ #0"
|
||||
|
||||
/*
|
||||
** maximum size of each format specification (such as '%-099.99d')
|
||||
** (+10 accounts for %99.99x plus margin of error)
|
||||
** maximum size of each format specification (such as "%-099.99d")
|
||||
** (+2 for length modifiers; +10 accounts for %99.99x plus margin of error)
|
||||
*/
|
||||
#define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)
|
||||
#define MAX_FORMAT (sizeof(FLAGS) + 2 + 10)
|
||||
|
||||
|
||||
static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
|
||||
@@ -903,7 +883,7 @@ static int str_format (lua_State *L) {
|
||||
else if (*++strfrmt == L_ESC)
|
||||
luaL_addchar(&b, *strfrmt++); /* %% */
|
||||
else { /* format item */
|
||||
char form[MAX_FORMAT]; /* to store the format (`%...') */
|
||||
char form[MAX_FORMAT]; /* to store the format ('%...') */
|
||||
char *buff = luaL_prepbuffsize(&b, MAX_ITEM); /* to put formatted item */
|
||||
int nb = 0; /* number of bytes in added item */
|
||||
if (++arg > top)
|
||||
@@ -911,36 +891,23 @@ static int str_format (lua_State *L) {
|
||||
strfrmt = scanformat(L, strfrmt, form);
|
||||
switch (*strfrmt++) {
|
||||
case 'c': {
|
||||
nb = sprintf(buff, form, luaL_checkint(L, arg));
|
||||
break;
|
||||
}
|
||||
case 'd': case 'i': {
|
||||
lua_Number n = luaL_checknumber(L, arg);
|
||||
LUA_INTFRM_T ni = (LUA_INTFRM_T)n;
|
||||
lua_Number diff = n - (lua_Number)ni;
|
||||
luaL_argcheck(L, -1 < diff && diff < 1, arg,
|
||||
"not a number in proper range");
|
||||
addlenmod(form, LUA_INTFRMLEN);
|
||||
nb = sprintf(buff, form, ni);
|
||||
nb = sprintf(buff, form, (int)luaL_checkinteger(L, arg));
|
||||
break;
|
||||
}
|
||||
case 'd': case 'i':
|
||||
case 'o': case 'u': case 'x': case 'X': {
|
||||
lua_Number n = luaL_checknumber(L, arg);
|
||||
unsigned LUA_INTFRM_T ni = (unsigned LUA_INTFRM_T)n;
|
||||
lua_Number diff = n - (lua_Number)ni;
|
||||
luaL_argcheck(L, -1 < diff && diff < 1, arg,
|
||||
"not a non-negative number in proper range");
|
||||
addlenmod(form, LUA_INTFRMLEN);
|
||||
nb = sprintf(buff, form, ni);
|
||||
lua_Integer n = luaL_checkinteger(L, arg);
|
||||
addlenmod(form, LUA_INTEGER_FRMLEN);
|
||||
nb = sprintf(buff, form, n);
|
||||
break;
|
||||
}
|
||||
case 'e': case 'E': case 'f':
|
||||
#if defined(LUA_USE_AFORMAT)
|
||||
case 'a': case 'A':
|
||||
#endif
|
||||
case 'e': case 'E': case 'f':
|
||||
case 'g': case 'G': {
|
||||
addlenmod(form, LUA_FLTFRMLEN);
|
||||
nb = sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg));
|
||||
addlenmod(form, LUA_NUMBER_FRMLEN);
|
||||
nb = sprintf(buff, form, luaL_checknumber(L, arg));
|
||||
break;
|
||||
}
|
||||
case 'q': {
|
||||
@@ -962,9 +929,9 @@ static int str_format (lua_State *L) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
default: { /* also treat cases `pnLlh' */
|
||||
return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
|
||||
LUA_QL("format"), *(strfrmt - 1));
|
||||
default: { /* also treat cases 'pnLlh' */
|
||||
return luaL_error(L, "invalid option '%%%c' to 'format'",
|
||||
*(strfrmt - 1));
|
||||
}
|
||||
}
|
||||
luaL_addsize(&b, nb);
|
||||
@@ -977,6 +944,447 @@ static int str_format (lua_State *L) {
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** PACK/UNPACK
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
|
||||
/* value used for padding */
|
||||
#if !defined(LUA_PACKPADBYTE)
|
||||
#define LUA_PACKPADBYTE 0x00
|
||||
#endif
|
||||
|
||||
/* maximum size for the binary representation of an integer */
|
||||
#define MAXINTSIZE 16
|
||||
|
||||
/* number of bits in a character */
|
||||
#define NB CHAR_BIT
|
||||
|
||||
/* mask for one character (NB 1's) */
|
||||
#define MC ((1 << NB) - 1)
|
||||
|
||||
/* size of a lua_Integer */
|
||||
#define SZINT ((int)sizeof(lua_Integer))
|
||||
|
||||
|
||||
/* dummy union to get native endianness */
|
||||
static const union {
|
||||
int dummy;
|
||||
char little; /* true iff machine is little endian */
|
||||
} nativeendian = {1};
|
||||
|
||||
|
||||
/* dummy structure to get native alignment requirements */
|
||||
struct cD {
|
||||
char c;
|
||||
union { double d; void *p; lua_Integer i; lua_Number n; } u;
|
||||
};
|
||||
|
||||
#define MAXALIGN (offsetof(struct cD, u))
|
||||
|
||||
|
||||
/*
|
||||
** Union for serializing floats
|
||||
*/
|
||||
typedef union Ftypes {
|
||||
float f;
|
||||
double d;
|
||||
lua_Number n;
|
||||
char buff[5 * sizeof(lua_Number)]; /* enough for any float type */
|
||||
} Ftypes;
|
||||
|
||||
|
||||
/*
|
||||
** information to pack/unpack stuff
|
||||
*/
|
||||
typedef struct Header {
|
||||
lua_State *L;
|
||||
int islittle;
|
||||
int maxalign;
|
||||
} Header;
|
||||
|
||||
|
||||
/*
|
||||
** options for pack/unpack
|
||||
*/
|
||||
typedef enum KOption {
|
||||
Kint, /* signed integers */
|
||||
Kuint, /* unsigned integers */
|
||||
Kfloat, /* floating-point numbers */
|
||||
Kchar, /* fixed-length strings */
|
||||
Kstring, /* strings with prefixed length */
|
||||
Kzstr, /* zero-terminated strings */
|
||||
Kpadding, /* padding */
|
||||
Kpaddalign, /* padding for alignment */
|
||||
Knop /* no-op (configuration or spaces) */
|
||||
} KOption;
|
||||
|
||||
|
||||
/*
|
||||
** Read an integer numeral from string 'fmt' or return 'df' if
|
||||
** there is no numeral
|
||||
*/
|
||||
static int digit (int c) { return '0' <= c && c <= '9'; }
|
||||
|
||||
static int getnum (const char **fmt, int df) {
|
||||
if (!digit(**fmt)) /* no number? */
|
||||
return df; /* return default value */
|
||||
else {
|
||||
int a = 0;
|
||||
do {
|
||||
a = a*10 + (*((*fmt)++) - '0');
|
||||
} while (digit(**fmt) && a <= ((int)MAXSIZE - 9)/10);
|
||||
return a;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Read an integer numeral and raises an error if it is larger
|
||||
** than the maximum size for integers.
|
||||
*/
|
||||
static int getnumlimit (Header *h, const char **fmt, int df) {
|
||||
int sz = getnum(fmt, df);
|
||||
if (sz > MAXINTSIZE || sz <= 0)
|
||||
luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
|
||||
sz, MAXINTSIZE);
|
||||
return sz;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Initialize Header
|
||||
*/
|
||||
static void initheader (lua_State *L, Header *h) {
|
||||
h->L = L;
|
||||
h->islittle = nativeendian.little;
|
||||
h->maxalign = 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Read and classify next option. 'size' is filled with option's size.
|
||||
*/
|
||||
static KOption getoption (Header *h, const char **fmt, int *size) {
|
||||
int opt = *((*fmt)++);
|
||||
*size = 0; /* default */
|
||||
switch (opt) {
|
||||
case 'b': *size = sizeof(char); return Kint;
|
||||
case 'B': *size = sizeof(char); return Kuint;
|
||||
case 'h': *size = sizeof(short); return Kint;
|
||||
case 'H': *size = sizeof(short); return Kuint;
|
||||
case 'l': *size = sizeof(long); return Kint;
|
||||
case 'L': *size = sizeof(long); return Kuint;
|
||||
case 'j': *size = sizeof(lua_Integer); return Kint;
|
||||
case 'J': *size = sizeof(lua_Integer); return Kuint;
|
||||
case 'T': *size = sizeof(size_t); return Kuint;
|
||||
case 'f': *size = sizeof(float); return Kfloat;
|
||||
case 'd': *size = sizeof(double); return Kfloat;
|
||||
case 'n': *size = sizeof(lua_Number); return Kfloat;
|
||||
case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint;
|
||||
case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint;
|
||||
case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring;
|
||||
case 'c':
|
||||
*size = getnum(fmt, -1);
|
||||
if (*size == -1)
|
||||
luaL_error(h->L, "missing size for format option 'c'");
|
||||
return Kchar;
|
||||
case 'z': return Kzstr;
|
||||
case 'x': *size = 1; return Kpadding;
|
||||
case 'X': return Kpaddalign;
|
||||
case ' ': break;
|
||||
case '<': h->islittle = 1; break;
|
||||
case '>': h->islittle = 0; break;
|
||||
case '=': h->islittle = nativeendian.little; break;
|
||||
case '!': h->maxalign = getnumlimit(h, fmt, MAXALIGN); break;
|
||||
default: luaL_error(h->L, "invalid format option '%c'", opt);
|
||||
}
|
||||
return Knop;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Read, classify, and fill other details about the next option.
|
||||
** 'psize' is filled with option's size, 'notoalign' with its
|
||||
** alignment requirements.
|
||||
** Local variable 'size' gets the size to be aligned. (Kpadal option
|
||||
** always gets its full alignment, other options are limited by
|
||||
** the maximum alignment ('maxalign'). Kchar option needs no alignment
|
||||
** despite its size.
|
||||
*/
|
||||
static KOption getdetails (Header *h, size_t totalsize,
|
||||
const char **fmt, int *psize, int *ntoalign) {
|
||||
KOption opt = getoption(h, fmt, psize);
|
||||
int align = *psize; /* usually, alignment follows size */
|
||||
if (opt == Kpaddalign) { /* 'X' gets alignment from following option */
|
||||
if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
|
||||
luaL_argerror(h->L, 1, "invalid next option for option 'X'");
|
||||
}
|
||||
if (align <= 1 || opt == Kchar) /* need no alignment? */
|
||||
*ntoalign = 0;
|
||||
else {
|
||||
if (align > h->maxalign) /* enforce maximum alignment */
|
||||
align = h->maxalign;
|
||||
if ((align & (align - 1)) != 0) /* is 'align' not a power of 2? */
|
||||
luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
|
||||
*ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1);
|
||||
}
|
||||
return opt;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Pack integer 'n' with 'size' bytes and 'islittle' endianness.
|
||||
** The final 'if' handles the case when 'size' is larger than
|
||||
** the size of a Lua integer, correcting the extra sign-extension
|
||||
** bytes if necessary (by default they would be zeros).
|
||||
*/
|
||||
static void packint (luaL_Buffer *b, lua_Unsigned n,
|
||||
int islittle, int size, int neg) {
|
||||
char *buff = luaL_prepbuffsize(b, size);
|
||||
int i;
|
||||
buff[islittle ? 0 : size - 1] = (char)(n & MC); /* first byte */
|
||||
for (i = 1; i < size; i++) {
|
||||
n >>= NB;
|
||||
buff[islittle ? i : size - 1 - i] = (char)(n & MC);
|
||||
}
|
||||
if (neg && size > SZINT) { /* negative number need sign extension? */
|
||||
for (i = SZINT; i < size; i++) /* correct extra bytes */
|
||||
buff[islittle ? i : size - 1 - i] = (char)MC;
|
||||
}
|
||||
luaL_addsize(b, size); /* add result to buffer */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Copy 'size' bytes from 'src' to 'dest', correcting endianness if
|
||||
** given 'islittle' is different from native endianness.
|
||||
*/
|
||||
static void copywithendian (volatile char *dest, volatile const char *src,
|
||||
int size, int islittle) {
|
||||
if (islittle == nativeendian.little) {
|
||||
while (size-- != 0)
|
||||
*(dest++) = *(src++);
|
||||
}
|
||||
else {
|
||||
dest += size - 1;
|
||||
while (size-- != 0)
|
||||
*(dest--) = *(src++);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int str_pack (lua_State *L) {
|
||||
luaL_Buffer b;
|
||||
Header h;
|
||||
const char *fmt = luaL_checkstring(L, 1); /* format string */
|
||||
int arg = 1; /* current argument to pack */
|
||||
size_t totalsize = 0; /* accumulate total size of result */
|
||||
initheader(L, &h);
|
||||
lua_pushnil(L); /* mark to separate arguments from string buffer */
|
||||
luaL_buffinit(L, &b);
|
||||
while (*fmt != '\0') {
|
||||
int size, ntoalign;
|
||||
KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
|
||||
totalsize += ntoalign + size;
|
||||
while (ntoalign-- > 0)
|
||||
luaL_addchar(&b, LUA_PACKPADBYTE); /* fill alignment */
|
||||
arg++;
|
||||
switch (opt) {
|
||||
case Kint: { /* signed integers */
|
||||
lua_Integer n = luaL_checkinteger(L, arg);
|
||||
if (size < SZINT) { /* need overflow check? */
|
||||
lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1);
|
||||
luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow");
|
||||
}
|
||||
packint(&b, (lua_Unsigned)n, h.islittle, size, (n < 0));
|
||||
break;
|
||||
}
|
||||
case Kuint: { /* unsigned integers */
|
||||
lua_Integer n = luaL_checkinteger(L, arg);
|
||||
if (size < SZINT) /* need overflow check? */
|
||||
luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)),
|
||||
arg, "unsigned overflow");
|
||||
packint(&b, (lua_Unsigned)n, h.islittle, size, 0);
|
||||
break;
|
||||
}
|
||||
case Kfloat: { /* floating-point options */
|
||||
volatile Ftypes u;
|
||||
char *buff = luaL_prepbuffsize(&b, size);
|
||||
lua_Number n = luaL_checknumber(L, arg); /* get argument */
|
||||
if (size == sizeof(u.f)) u.f = (float)n; /* copy it into 'u' */
|
||||
else if (size == sizeof(u.d)) u.d = (double)n;
|
||||
else u.n = n;
|
||||
/* move 'u' to final result, correcting endianness if needed */
|
||||
copywithendian(buff, u.buff, size, h.islittle);
|
||||
luaL_addsize(&b, size);
|
||||
break;
|
||||
}
|
||||
case Kchar: { /* fixed-size string */
|
||||
size_t len;
|
||||
const char *s = luaL_checklstring(L, arg, &len);
|
||||
luaL_argcheck(L, len == (size_t)size, arg, "wrong length");
|
||||
luaL_addlstring(&b, s, size);
|
||||
break;
|
||||
}
|
||||
case Kstring: { /* strings with length count */
|
||||
size_t len;
|
||||
const char *s = luaL_checklstring(L, arg, &len);
|
||||
luaL_argcheck(L, size >= (int)sizeof(size_t) ||
|
||||
len < ((size_t)1 << (size * NB)),
|
||||
arg, "string length does not fit in given size");
|
||||
packint(&b, (lua_Unsigned)len, h.islittle, size, 0); /* pack length */
|
||||
luaL_addlstring(&b, s, len);
|
||||
totalsize += len;
|
||||
break;
|
||||
}
|
||||
case Kzstr: { /* zero-terminated string */
|
||||
size_t len;
|
||||
const char *s = luaL_checklstring(L, arg, &len);
|
||||
luaL_argcheck(L, strlen(s) == len, arg, "string contains zeros");
|
||||
luaL_addlstring(&b, s, len);
|
||||
luaL_addchar(&b, '\0'); /* add zero at the end */
|
||||
totalsize += len + 1;
|
||||
break;
|
||||
}
|
||||
case Kpadding: luaL_addchar(&b, LUA_PACKPADBYTE); /* go through */
|
||||
case Kpaddalign: case Knop:
|
||||
arg--; /* undo increment */
|
||||
break;
|
||||
}
|
||||
}
|
||||
luaL_pushresult(&b);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int str_packsize (lua_State *L) {
|
||||
Header h;
|
||||
const char *fmt = luaL_checkstring(L, 1); /* format string */
|
||||
size_t totalsize = 0; /* accumulate total size of result */
|
||||
initheader(L, &h);
|
||||
while (*fmt != '\0') {
|
||||
int size, ntoalign;
|
||||
KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
|
||||
size += ntoalign; /* total space used by option */
|
||||
luaL_argcheck(L, totalsize <= MAXSIZE - size, 1,
|
||||
"format result too large");
|
||||
totalsize += size;
|
||||
switch (opt) {
|
||||
case Kstring: /* strings with length count */
|
||||
case Kzstr: /* zero-terminated string */
|
||||
luaL_argerror(L, 1, "variable-length format");
|
||||
break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
lua_pushinteger(L, (lua_Integer)totalsize);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Unpack an integer with 'size' bytes and 'islittle' endianness.
|
||||
** If size is smaller than the size of a Lua integer and integer
|
||||
** is signed, must do sign extension (propagating the sign to the
|
||||
** higher bits); if size is larger than the size of a Lua integer,
|
||||
** it must check the unread bytes to see whether they do not cause an
|
||||
** overflow.
|
||||
*/
|
||||
static lua_Integer unpackint (lua_State *L, const char *str,
|
||||
int islittle, int size, int issigned) {
|
||||
lua_Unsigned res = 0;
|
||||
int i;
|
||||
int limit = (size <= SZINT) ? size : SZINT;
|
||||
for (i = limit - 1; i >= 0; i--) {
|
||||
res <<= NB;
|
||||
res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i];
|
||||
}
|
||||
if (size < SZINT) { /* real size smaller than lua_Integer? */
|
||||
if (issigned) { /* needs sign extension? */
|
||||
lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1);
|
||||
res = ((res ^ mask) - mask); /* do sign extension */
|
||||
}
|
||||
}
|
||||
else if (size > SZINT) { /* must check unread bytes */
|
||||
int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC;
|
||||
for (i = limit; i < size; i++) {
|
||||
if ((unsigned char)str[islittle ? i : size - 1 - i] != mask)
|
||||
luaL_error(L, "%d-byte integer does not fit into Lua Integer", size);
|
||||
}
|
||||
}
|
||||
return (lua_Integer)res;
|
||||
}
|
||||
|
||||
|
||||
static int str_unpack (lua_State *L) {
|
||||
Header h;
|
||||
const char *fmt = luaL_checkstring(L, 1);
|
||||
size_t ld;
|
||||
const char *data = luaL_checklstring(L, 2, &ld);
|
||||
size_t pos = (size_t)posrelat(luaL_optinteger(L, 3, 1), ld) - 1;
|
||||
int n = 0; /* number of results */
|
||||
luaL_argcheck(L, pos <= ld, 3, "initial position out of string");
|
||||
initheader(L, &h);
|
||||
while (*fmt != '\0') {
|
||||
int size, ntoalign;
|
||||
KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign);
|
||||
if ((size_t)ntoalign + size > ~pos || pos + ntoalign + size > ld)
|
||||
luaL_argerror(L, 2, "data string too short");
|
||||
pos += ntoalign; /* skip alignment */
|
||||
/* stack space for item + next position */
|
||||
luaL_checkstack(L, 2, "too many results");
|
||||
n++;
|
||||
switch (opt) {
|
||||
case Kint:
|
||||
case Kuint: {
|
||||
lua_Integer res = unpackint(L, data + pos, h.islittle, size,
|
||||
(opt == Kint));
|
||||
lua_pushinteger(L, res);
|
||||
break;
|
||||
}
|
||||
case Kfloat: {
|
||||
volatile Ftypes u;
|
||||
lua_Number num;
|
||||
copywithendian(u.buff, data + pos, size, h.islittle);
|
||||
if (size == sizeof(u.f)) num = (lua_Number)u.f;
|
||||
else if (size == sizeof(u.d)) num = (lua_Number)u.d;
|
||||
else num = u.n;
|
||||
lua_pushnumber(L, num);
|
||||
break;
|
||||
}
|
||||
case Kchar: {
|
||||
lua_pushlstring(L, data + pos, size);
|
||||
break;
|
||||
}
|
||||
case Kstring: {
|
||||
size_t len = (size_t)unpackint(L, data + pos, h.islittle, size, 0);
|
||||
luaL_argcheck(L, pos + len + size <= ld, 2, "data string too short");
|
||||
lua_pushlstring(L, data + pos + size, len);
|
||||
pos += len; /* skip string */
|
||||
break;
|
||||
}
|
||||
case Kzstr: {
|
||||
size_t len = (int)strlen(data + pos);
|
||||
lua_pushlstring(L, data + pos, len);
|
||||
pos += len + 1; /* skip string plus final '\0' */
|
||||
break;
|
||||
}
|
||||
case Kpaddalign: case Kpadding: case Knop:
|
||||
n--; /* undo increment */
|
||||
break;
|
||||
}
|
||||
pos += size;
|
||||
}
|
||||
lua_pushinteger(L, pos + 1); /* next position */
|
||||
return n + 1;
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
static const luaL_Reg strlib[] = {
|
||||
{"byte", str_byte},
|
||||
{"char", str_char},
|
||||
@@ -992,6 +1400,9 @@ static const luaL_Reg strlib[] = {
|
||||
{"reverse", str_reverse},
|
||||
{"sub", str_sub},
|
||||
{"upper", str_upper},
|
||||
{"pack", str_pack},
|
||||
{"packsize", str_packsize},
|
||||
{"unpack", str_unpack},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user