|
|
|
@ -116,49 +116,43 @@ static lua_Number numarith (lua_State *L, int op, lua_Number v1,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int luaO_rawarith (lua_State *L, int op, const TValue *p1, const TValue *p2,
|
|
|
|
|
TValue *res) {
|
|
|
|
|
void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
|
|
|
|
|
TValue *res) {
|
|
|
|
|
switch (op) {
|
|
|
|
|
case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
|
|
|
|
|
case LUA_OPSHL: case LUA_OPSHR:
|
|
|
|
|
case LUA_OPBNOT: { /* operate only on integers */
|
|
|
|
|
lua_Integer i1; lua_Integer i2;
|
|
|
|
|
if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) {
|
|
|
|
|
if (tointeger(p1, &i1) && tointeger(p2, &i2)) {
|
|
|
|
|
setivalue(res, intarith(L, op, i1, i2));
|
|
|
|
|
return 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else return 0; /* fail */
|
|
|
|
|
else break; /* go to the end */
|
|
|
|
|
}
|
|
|
|
|
case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */
|
|
|
|
|
lua_Number n1; lua_Number n2;
|
|
|
|
|
if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
|
|
|
|
|
if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
|
|
|
|
|
setfltvalue(res, numarith(L, op, n1, n2));
|
|
|
|
|
return 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else return 0; /* fail */
|
|
|
|
|
else break; /* go to the end */
|
|
|
|
|
}
|
|
|
|
|
default: { /* other operations */
|
|
|
|
|
lua_Number n1; lua_Number n2;
|
|
|
|
|
if (ttisinteger(p1) && ttisinteger(p2)) {
|
|
|
|
|
setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
|
|
|
|
|
return 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
|
|
|
|
|
else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
|
|
|
|
|
setfltvalue(res, numarith(L, op, n1, n2));
|
|
|
|
|
return 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else return 0; /* fail */
|
|
|
|
|
else break; /* go to the end */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
|
|
|
|
|
StkId res) {
|
|
|
|
|
if (!luaO_rawarith(L, op, p1, p2, res)) {
|
|
|
|
|
/* could not perform raw operation; try metamethod */
|
|
|
|
|
luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
|
|
|
|
|
}
|
|
|
|
|
/* could not perform raw operation; try metamethod */
|
|
|
|
|
lua_assert(L != NULL); /* should not fail when folding (compile time) */
|
|
|
|
|
luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@ -189,7 +183,7 @@ static int isneg (const char **s) {
|
|
|
|
|
#define MAXSIGDIG 30
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** convert a hexadecimal numeric string to a number, following
|
|
|
|
|
** convert an hexadecimal numeric string to a number, following
|
|
|
|
|
** C99 specification for 'strtod'
|
|
|
|
|
*/
|
|
|
|
|
static lua_Number lua_strx2number (const char *s, char **endptr) {
|
|
|
|
@ -200,9 +194,9 @@ static lua_Number lua_strx2number (const char *s, char **endptr) {
|
|
|
|
|
int e = 0; /* exponent correction */
|
|
|
|
|
int neg; /* 1 if number is negative */
|
|
|
|
|
int hasdot = 0; /* true after seen a dot */
|
|
|
|
|
*endptr = cast_charp(s); /* nothing is valid yet */
|
|
|
|
|
*endptr = cast(char *, s); /* nothing is valid yet */
|
|
|
|
|
while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */
|
|
|
|
|
neg = isneg(&s); /* check sign */
|
|
|
|
|
neg = isneg(&s); /* check signal */
|
|
|
|
|
if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))) /* check '0x' */
|
|
|
|
|
return 0.0; /* invalid format (no '0x') */
|
|
|
|
|
for (s += 2; ; s++) { /* skip '0x' and read numeral */
|
|
|
|
@ -222,20 +216,20 @@ static lua_Number lua_strx2number (const char *s, char **endptr) {
|
|
|
|
|
}
|
|
|
|
|
if (nosigdig + sigdig == 0) /* no digits? */
|
|
|
|
|
return 0.0; /* invalid format */
|
|
|
|
|
*endptr = cast_charp(s); /* valid up to here */
|
|
|
|
|
*endptr = cast(char *, s); /* valid up to here */
|
|
|
|
|
e *= 4; /* each digit multiplies/divides value by 2^4 */
|
|
|
|
|
if (*s == 'p' || *s == 'P') { /* exponent part? */
|
|
|
|
|
int exp1 = 0; /* exponent value */
|
|
|
|
|
int neg1; /* exponent sign */
|
|
|
|
|
int neg1; /* exponent signal */
|
|
|
|
|
s++; /* skip 'p' */
|
|
|
|
|
neg1 = isneg(&s); /* sign */
|
|
|
|
|
neg1 = isneg(&s); /* signal */
|
|
|
|
|
if (!lisdigit(cast_uchar(*s)))
|
|
|
|
|
return 0.0; /* invalid; must have at least one digit */
|
|
|
|
|
while (lisdigit(cast_uchar(*s))) /* read exponent */
|
|
|
|
|
exp1 = exp1 * 10 + *(s++) - '0';
|
|
|
|
|
if (neg1) exp1 = -exp1;
|
|
|
|
|
e += exp1;
|
|
|
|
|
*endptr = cast_charp(s); /* valid up to here */
|
|
|
|
|
*endptr = cast(char *, s); /* valid up to here */
|
|
|
|
|
}
|
|
|
|
|
if (neg) r = -r;
|
|
|
|
|
return l_mathop(ldexp)(r, e);
|
|
|
|
@ -264,11 +258,11 @@ static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
|
|
|
|
|
** Convert string 's' to a Lua number (put in 'result'). Return NULL
|
|
|
|
|
** on fail or the address of the ending '\0' on success.
|
|
|
|
|
** 'pmode' points to (and 'mode' contains) special things in the string:
|
|
|
|
|
** - 'x'/'X' means a hexadecimal numeral
|
|
|
|
|
** - 'x'/'X' means an hexadecimal numeral
|
|
|
|
|
** - 'n'/'N' means 'inf' or 'nan' (which should be rejected)
|
|
|
|
|
** - '.' just optimizes the search for the common case (nothing special)
|
|
|
|
|
** This function accepts both the current locale or a dot as the radix
|
|
|
|
|
** mark. If the conversion fails, it may mean number has a dot but
|
|
|
|
|
** mark. If the convertion fails, it may mean number has a dot but
|
|
|
|
|
** locale accepts something else. In that case, the code copies 's'
|
|
|
|
|
** to a buffer (because 's' is read-only), changes the dot to the
|
|
|
|
|
** current locale radix mark, and tries to convert again.
|
|
|
|
@ -349,15 +343,15 @@ int luaO_utf8esc (char *buff, unsigned long x) {
|
|
|
|
|
int n = 1; /* number of bytes put in buffer (backwards) */
|
|
|
|
|
lua_assert(x <= 0x7FFFFFFFu);
|
|
|
|
|
if (x < 0x80) /* ascii? */
|
|
|
|
|
buff[UTF8BUFFSZ - 1] = cast_char(x);
|
|
|
|
|
buff[UTF8BUFFSZ - 1] = cast(char, x);
|
|
|
|
|
else { /* need continuation bytes */
|
|
|
|
|
unsigned int mfb = 0x3f; /* maximum that fits in first byte */
|
|
|
|
|
do { /* add continuation bytes */
|
|
|
|
|
buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f));
|
|
|
|
|
buff[UTF8BUFFSZ - (n++)] = cast(char, 0x80 | (x & 0x3f));
|
|
|
|
|
x >>= 6; /* remove added bits */
|
|
|
|
|
mfb >>= 1; /* now there is one less bit available in first byte */
|
|
|
|
|
} while (x > mfb); /* still needs continuation byte? */
|
|
|
|
|
buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */
|
|
|
|
|
buff[UTF8BUFFSZ - n] = cast(char, (~mfb << 1) | x); /* add first byte */
|
|
|
|
|
}
|
|
|
|
|
return n;
|
|
|
|
|
}
|
|
|
|
@ -368,178 +362,88 @@ int luaO_utf8esc (char *buff, unsigned long x) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Convert a number object to a string, adding it to a buffer
|
|
|
|
|
** Convert a number object to a string
|
|
|
|
|
*/
|
|
|
|
|
static int tostringbuff (TValue *obj, char *buff) {
|
|
|
|
|
int len;
|
|
|
|
|
void luaO_tostring (lua_State *L, StkId obj) {
|
|
|
|
|
char buff[MAXNUMBER2STR];
|
|
|
|
|
size_t len;
|
|
|
|
|
lua_assert(ttisnumber(obj));
|
|
|
|
|
if (ttisinteger(obj))
|
|
|
|
|
len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj));
|
|
|
|
|
len = lua_integer2str(buff, sizeof(buff), ivalue(obj));
|
|
|
|
|
else {
|
|
|
|
|
len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj));
|
|
|
|
|
len = lua_number2str(buff, sizeof(buff), fltvalue(obj));
|
|
|
|
|
#if !defined(LUA_COMPAT_FLOATSTRING)
|
|
|
|
|
if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */
|
|
|
|
|
buff[len++] = lua_getlocaledecpoint();
|
|
|
|
|
buff[len++] = '0'; /* adds '.0' to result */
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Convert a number object to a Lua string, replacing the value at 'obj'
|
|
|
|
|
*/
|
|
|
|
|
void luaO_tostring (lua_State *L, TValue *obj) {
|
|
|
|
|
char buff[MAXNUMBER2STR];
|
|
|
|
|
int len = tostringbuff(obj, buff);
|
|
|
|
|
setsvalue(L, obj, luaS_newlstr(L, buff, len));
|
|
|
|
|
setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** {==================================================================
|
|
|
|
|
** 'luaO_pushvfstring'
|
|
|
|
|
** ===================================================================
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* size for buffer space used by 'luaO_pushvfstring' */
|
|
|
|
|
#define BUFVFS 400
|
|
|
|
|
|
|
|
|
|
/* buffer used by 'luaO_pushvfstring' */
|
|
|
|
|
typedef struct BuffFS {
|
|
|
|
|
lua_State *L;
|
|
|
|
|
int pushed; /* number of string pieces already on the stack */
|
|
|
|
|
int blen; /* length of partial string in 'space' */
|
|
|
|
|
char space[BUFVFS]; /* holds last part of the result */
|
|
|
|
|
} BuffFS;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Push given string to the stack, as part of the buffer. If the stack
|
|
|
|
|
** is almost full, join all partial strings in the stack into one.
|
|
|
|
|
*/
|
|
|
|
|
static void pushstr (BuffFS *buff, const char *str, size_t l) {
|
|
|
|
|
lua_State *L = buff->L;
|
|
|
|
|
static void pushstr (lua_State *L, const char *str, size_t l) {
|
|
|
|
|
setsvalue2s(L, L->top, luaS_newlstr(L, str, l));
|
|
|
|
|
L->top++; /* may use one extra slot */
|
|
|
|
|
buff->pushed++;
|
|
|
|
|
if (buff->pushed > 1 && L->top + 1 >= L->stack_last) {
|
|
|
|
|
luaV_concat(L, buff->pushed); /* join all partial results into one */
|
|
|
|
|
buff->pushed = 1;
|
|
|
|
|
}
|
|
|
|
|
luaD_inctop(L);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** empty the buffer space into the stack
|
|
|
|
|
*/
|
|
|
|
|
static void clearbuff (BuffFS *buff) {
|
|
|
|
|
pushstr(buff, buff->space, buff->blen); /* push buffer contents */
|
|
|
|
|
buff->blen = 0; /* space now is empty */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Get a space of size 'sz' in the buffer. If buffer has not enough
|
|
|
|
|
** space, empty it. 'sz' must fit in an empty buffer.
|
|
|
|
|
*/
|
|
|
|
|
static char *getbuff (BuffFS *buff, int sz) {
|
|
|
|
|
lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS);
|
|
|
|
|
if (sz > BUFVFS - buff->blen) /* not enough space? */
|
|
|
|
|
clearbuff(buff);
|
|
|
|
|
return buff->space + buff->blen;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define addsize(b,sz) ((b)->blen += (sz))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Add 'str' to the buffer. If string is larger than the buffer space,
|
|
|
|
|
** push the string directly to the stack.
|
|
|
|
|
*/
|
|
|
|
|
static void addstr2buff (BuffFS *buff, const char *str, size_t slen) {
|
|
|
|
|
if (slen <= BUFVFS) { /* does string fit into buffer? */
|
|
|
|
|
char *bf = getbuff(buff, cast_int(slen));
|
|
|
|
|
memcpy(bf, str, slen); /* add string to buffer */
|
|
|
|
|
addsize(buff, cast_int(slen));
|
|
|
|
|
}
|
|
|
|
|
else { /* string larger than buffer */
|
|
|
|
|
clearbuff(buff); /* string comes after buffer's content */
|
|
|
|
|
pushstr(buff, str, slen); /* push string */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Add a number to the buffer.
|
|
|
|
|
*/
|
|
|
|
|
static void addnum2buff (BuffFS *buff, TValue *num) {
|
|
|
|
|
char *numbuff = getbuff(buff, MAXNUMBER2STR);
|
|
|
|
|
int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */
|
|
|
|
|
addsize(buff, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** this function handles only '%d', '%c', '%f', '%p', '%s', and '%%'
|
|
|
|
|
** this function handles only '%d', '%c', '%f', '%p', and '%s'
|
|
|
|
|
conventional formats, plus Lua-specific '%I' and '%U'
|
|
|
|
|
*/
|
|
|
|
|
const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
|
|
|
|
|
BuffFS buff; /* holds last part of the result */
|
|
|
|
|
const char *e; /* points to next '%' */
|
|
|
|
|
buff.pushed = buff.blen = 0;
|
|
|
|
|
buff.L = L;
|
|
|
|
|
while ((e = strchr(fmt, '%')) != NULL) {
|
|
|
|
|
addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */
|
|
|
|
|
switch (*(e + 1)) { /* conversion specifier */
|
|
|
|
|
int n = 0;
|
|
|
|
|
for (;;) {
|
|
|
|
|
const char *e = strchr(fmt, '%');
|
|
|
|
|
if (e == NULL) break;
|
|
|
|
|
pushstr(L, fmt, e - fmt);
|
|
|
|
|
switch (*(e+1)) {
|
|
|
|
|
case 's': { /* zero-terminated string */
|
|
|
|
|
const char *s = va_arg(argp, char *);
|
|
|
|
|
if (s == NULL) s = "(null)";
|
|
|
|
|
addstr2buff(&buff, s, strlen(s));
|
|
|
|
|
pushstr(L, s, strlen(s));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 'c': { /* an 'int' as a character */
|
|
|
|
|
char c = cast_uchar(va_arg(argp, int));
|
|
|
|
|
addstr2buff(&buff, &c, sizeof(char));
|
|
|
|
|
char buff = cast(char, va_arg(argp, int));
|
|
|
|
|
if (lisprint(cast_uchar(buff)))
|
|
|
|
|
pushstr(L, &buff, 1);
|
|
|
|
|
else /* non-printable character; print its code */
|
|
|
|
|
luaO_pushfstring(L, "<\\%d>", cast_uchar(buff));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 'd': { /* an 'int' */
|
|
|
|
|
TValue num;
|
|
|
|
|
setivalue(&num, va_arg(argp, int));
|
|
|
|
|
addnum2buff(&buff, &num);
|
|
|
|
|
break;
|
|
|
|
|
setivalue(L->top, va_arg(argp, int));
|
|
|
|
|
goto top2str;
|
|
|
|
|
}
|
|
|
|
|
case 'I': { /* a 'lua_Integer' */
|
|
|
|
|
TValue num;
|
|
|
|
|
setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt)));
|
|
|
|
|
addnum2buff(&buff, &num);
|
|
|
|
|
break;
|
|
|
|
|
setivalue(L->top, cast(lua_Integer, va_arg(argp, l_uacInt)));
|
|
|
|
|
goto top2str;
|
|
|
|
|
}
|
|
|
|
|
case 'f': { /* a 'lua_Number' */
|
|
|
|
|
TValue num;
|
|
|
|
|
setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber)));
|
|
|
|
|
addnum2buff(&buff, &num);
|
|
|
|
|
setfltvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
|
|
|
|
|
top2str: /* convert the top element to a string */
|
|
|
|
|
luaD_inctop(L);
|
|
|
|
|
luaO_tostring(L, L->top - 1);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 'p': { /* a pointer */
|
|
|
|
|
const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */
|
|
|
|
|
char *bf = getbuff(&buff, sz);
|
|
|
|
|
char buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */
|
|
|
|
|
void *p = va_arg(argp, void *);
|
|
|
|
|
int len = lua_pointer2str(bf, sz, p);
|
|
|
|
|
addsize(&buff, len);
|
|
|
|
|
int l = lua_pointer2str(buff, sizeof(buff), p);
|
|
|
|
|
pushstr(L, buff, l);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 'U': { /* a 'long' as a UTF-8 sequence */
|
|
|
|
|
char bf[UTF8BUFFSZ];
|
|
|
|
|
int len = luaO_utf8esc(bf, va_arg(argp, long));
|
|
|
|
|
addstr2buff(&buff, bf + UTF8BUFFSZ - len, len);
|
|
|
|
|
case 'U': { /* an 'int' as a UTF-8 sequence */
|
|
|
|
|
char buff[UTF8BUFFSZ];
|
|
|
|
|
int l = luaO_utf8esc(buff, va_arg(argp, long));
|
|
|
|
|
pushstr(L, buff + UTF8BUFFSZ - l, l);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case '%': {
|
|
|
|
|
addstr2buff(&buff, "%", 1);
|
|
|
|
|
pushstr(L, "%", 1);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default: {
|
|
|
|
@ -547,12 +451,12 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
|
|
|
|
|
*(e + 1));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
fmt = e + 2; /* skip '%' and the specifier */
|
|
|
|
|
n += 2;
|
|
|
|
|
fmt = e+2;
|
|
|
|
|
}
|
|
|
|
|
addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */
|
|
|
|
|
clearbuff(&buff); /* empty buffer into the stack */
|
|
|
|
|
if (buff.pushed > 1)
|
|
|
|
|
luaV_concat(L, buff.pushed); /* join all partial results */
|
|
|
|
|
luaD_checkstack(L, 1);
|
|
|
|
|
pushstr(L, fmt, strlen(fmt));
|
|
|
|
|
if (n > 0) luaV_concat(L, n + 1);
|
|
|
|
|
return svalue(L->top - 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -566,7 +470,6 @@ const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
|
|
|
|
|
return msg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }================================================================== */
|
|
|
|
|
|
|
|
|
|
/* number of chars of a literal string without the ending \0 */
|
|
|
|
|
#define LL(x) (sizeof(x)/sizeof(char) - 1)
|
|
|
|
|