issue #157 fix build error on windows

This reverts commit 22d84e74

include/lua.h

@@ -639,6 +639,9 @@ LUA_API int ravi_list_code(lua_State *L);
 /* Returns a table with various system limits */
 LUA_API int ravi_get_limits(lua_State *L);
 
+/* Options */
+LUA_API const char *raviV_options(struct lua_State *L);
+
 /* Following are for debugging purposes only */
 LUAI_DDEC int ravi_parser_debug;
 LUA_API void ravi_set_debuglevel(int level);

include/ravi_jit.h

@@ -96,9 +96,6 @@ void raviV_dumpASM(struct lua_State *L, struct Proto *p);
 /* Return JIT backend identifier */
 const char *raviV_jit_id(struct lua_State *L);
 
-/* Options */
-const char *raviV_options(struct lua_State *L);
-
 #ifdef __cplusplus
 }
 #endif

src/lobject.c

@@ -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,
+void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
-                   TValue *res) {
+                 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 */
     }
   }
-}
+  /* 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));
-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));
-  }
 }
 
 
@@ -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) {
+void luaO_tostring (lua_State *L, StkId obj) {
-  int len;
+  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;
+  setsvalue2s(L, obj, luaS_newlstr(L, buff, 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));
 }
 
 
-
+static void pushstr (lua_State *L, const char *str, size_t l) {
-
-/*
-** {==================================================================
-** '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;
   setsvalue2s(L, L->top, luaS_newlstr(L, str, l));
-  L->top++;  /* may use one extra slot */
+  luaD_inctop(L);
-  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;
-  }
 }
 
 
 /*
-** empty the buffer space into the stack
+** this function handles only '%d', '%c', '%f', '%p', and '%s'
-*/
-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 '%%'
    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 */
+  int n = 0;
-  const char *e;  /* points to next '%' */
+  for (;;) {
-  buff.pushed = buff.blen = 0;
+    const char *e = strchr(fmt, '%');
-  buff.L = L;
+    if (e == NULL) break;
-  while ((e = strchr(fmt, '%')) != NULL) {
+    pushstr(L, fmt, e - fmt);
-    addstr2buff(&buff, fmt, e - fmt);  /* add 'fmt' up to '%' */
+    switch (*(e+1)) {
-    switch (*(e + 1)) {  /* conversion specifier */
       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));
+        char buff = cast(char, va_arg(argp, int));
-        addstr2buff(&buff, &c, sizeof(char));
+        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(L->top, va_arg(argp, int));
-        setivalue(&num, va_arg(argp, int));
+        goto top2str;
-        addnum2buff(&buff, &num);
-        break;
       }
       case 'I': {  /* a 'lua_Integer' */
-        TValue num;
+        setivalue(L->top, cast(lua_Integer, va_arg(argp, l_uacInt)));
-        setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt)));
+        goto top2str;
-        addnum2buff(&buff, &num);
-        break;
       }
       case 'f': {  /* a 'lua_Number' */
-        TValue num;
+        setfltvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
-        setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber)));
+      top2str:  /* convert the top element to a string */
-        addnum2buff(&buff, &num);
+        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 buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */
-        char *bf = getbuff(&buff, sz);
         void *p = va_arg(argp, void *);
-        int len = lua_pointer2str(bf, sz, p);
+        int l = lua_pointer2str(buff, sizeof(buff), p);
-        addsize(&buff, len);
+        pushstr(L, buff, l);
         break;
       }
-      case 'U': {  /* a 'long' as a UTF-8 sequence */
+      case 'U': {  /* an 'int' as a UTF-8 sequence */
-        char bf[UTF8BUFFSZ];
+        char buff[UTF8BUFFSZ];
-        int len = luaO_utf8esc(bf, va_arg(argp, long));
+        int l = luaO_utf8esc(buff, va_arg(argp, long));
-        addstr2buff(&buff, bf + UTF8BUFFSZ - len, len);
+        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' */
+  luaD_checkstack(L, 1);
-  clearbuff(&buff);  /* empty buffer into the stack */
+  pushstr(L, fmt, strlen(fmt));
-  if (buff.pushed > 1)
+  if (n > 0) luaV_concat(L, n + 1);
-    luaV_concat(L, buff.pushed);  /* join all partial results */
   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)

src/ltests.c

@@ -115,7 +115,7 @@ static void freeblock (Memcontrol *mc, Header *block) {
     size_t size = block->d.size;
     int i;
     for (i = 0; i < MARKSIZE; i++)  /* check marks after block */
-      lua_assert(*(cast_charp(block + 1) + size + i) == MARK);
+      lua_assert(*(cast(char *, block + 1) + size + i) == MARK);
     mc->objcount[block->d.type]--;
     fillmem(block, sizeof(Header) + size + MARKSIZE);  /* erase block */
     free(block);  /* actually free block */
@@ -167,10 +167,10 @@ LUA_API void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) {
       freeblock(mc, block);  /* erase (and check) old copy */
     }
     /* initialize new part of the block with something weird */
-    fillmem(cast_charp(newblock + 1) + commonsize, size - commonsize);
+    fillmem(cast(char *, newblock + 1) + commonsize, size - commonsize);
     /* initialize marks after block */
     for (i = 0; i < MARKSIZE; i++)
-      *(cast_charp(newblock + 1) + size + i) = MARK;
+      *(cast(char *, newblock + 1) + size + i) = MARK;
     newblock->d.size = size;
     newblock->d.type = type;
     mc->total += size;
@@ -1377,15 +1377,6 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
     else if EQ("pushvalue") {
       lua_pushvalue(L1, getindex);
     }
-    else if EQ("pushfstringI") {
-      lua_pushfstring(L1, lua_tostring(L, -2), (int)lua_tointeger(L, -1));
-    }
-    else if EQ("pushfstringS") {
-      lua_pushfstring(L1, lua_tostring(L, -2), lua_tostring(L, -1));
-    }
-    else if EQ("pushfstringP") {
-      lua_pushfstring(L1, lua_tostring(L, -2), lua_topointer(L, -1));
-    }
     else if EQ("rawgeti") {
       int t = getindex;
       lua_rawgeti(L1, t, getnum);

tests/lua53/strings.lua

@@ -148,43 +148,6 @@ else   -- compatible coercion
   assert(tostring(-1203 + 0.0) == "-1203")
 end
 
-do  -- tests for '%p' format
-  -- not much to test, as C does not specify what '%p' does.
-  -- ("The value of the pointer is converted to a sequence of printing
-  -- characters, in an implementation-defined manner.")
-  local null = "(null)"    -- nulls are formatted by Lua
-  assert(string.format("%p", 4) == null)
-  assert(string.format("%p", true) == null)
-  assert(string.format("%p", nil) == null)
-  assert(string.format("%p", {}) ~= null)
-  assert(string.format("%p", print) ~= null)
-  assert(string.format("%p", coroutine.running()) ~= null)
-  assert(string.format("%p", io.stdin) ~= null)
-  assert(string.format("%p", io.stdin) == string.format("%p", io.stdin))
-  assert(string.format("%p", print) == string.format("%p", print))
-  assert(string.format("%p", print) ~= string.format("%p", assert))
-
-  assert(#string.format("%90p", {}) == 90)
-  assert(#string.format("%-60p", {}) == 60)
-  assert(string.format("%10p", false) == string.rep(" ", 10 - #null) .. null)
-  assert(string.format("%-12p", 1.5) == null .. string.rep(" ", 12 - #null))
-
-  do
-    local t1 = {}; local t2 = {}
-    assert(string.format("%p", t1) ~= string.format("%p", t2))
-  end
-
-  do     -- short strings are internalized
-    local s1 = string.rep("a", 10)
-    local s2 = string.rep("aa", 5)
-  assert(string.format("%p", s1) == string.format("%p", s2))
-  end
-
-  do     -- long strings aren't internalized
-    local s1 = string.rep("a", 300); local s2 = string.rep("a", 300)
-    --assert(string.format("%p", s1) ~= string.format("%p", s2))
-  end
-end
 
 x = '"ílo"\n\\'
 assert(string.format('%q%s', x, x) == '"\\"ílo\\"\\\n\\\\""ílo"\n\\')
@@ -412,68 +375,5 @@ do
   assert(co() == "2")
 end
 
-
-if T==nil then
-  (Message or print)
-     ("\n >>> testC not active: skipping 'pushfstring' tests <<<\n")
-else
-
-  print"testing 'pushfstring'"
-
-  -- formats %U, %f, %I already tested elsewhere
-
-  local blen = 400    -- internal buffer length in 'luaO_pushfstring'
-
-  local function callpfs (op, fmt, n)
-    local x = {T.testC("pushfstring" .. op .. "; return *", fmt, n)}
-    -- stack has code, 'fmt', 'n', and result from operation
-    assert(#x == 4)  -- make sure nothing else was left in the stack
-    return x[4]
-  end
-
-  local function testpfs (op, fmt, n)
-    assert(callpfs(op, fmt, n) == string.format(fmt, n))
-  end
-
-  testpfs("I", "", 0)
-  testpfs("I", string.rep("a", blen - 1), 0)
-  testpfs("I", string.rep("a", blen), 0)
-  testpfs("I", string.rep("a", blen + 1), 0)
-
-  local str = string.rep("ab", blen) .. "%d" .. string.rep("d", blen / 2)
-  testpfs("I", str, 2^14)
-  testpfs("I", str, -2^15)
-
-  str = "%d" .. string.rep("cd", blen)
-  testpfs("I", str, 2^14)
-  testpfs("I", str, -2^15)
-
-  str = string.rep("c", blen - 2) .. "%d"
-  testpfs("I", str, 2^14)
-  testpfs("I", str, -2^15)
-
-  for l = 12, 14 do
-    local str1 = string.rep("a", l)
-    for i = 0, 500, 13 do
-      for j = 0, 500, 13 do
-        str = string.rep("a", i) .. "%s" .. string.rep("d", j)
-        testpfs("S", str, str1)
-        testpfs("S", str, str)
-      end
-    end
-  end
-
-  str = "abc %c def"
-  testpfs("I", str, string.byte("A"))
-  testpfs("I", str, 255)
-
-  str = string.rep("a", blen - 1) .. "%p" .. string.rep("cd", blen)
-  testpfs("P", str, {})
-
-  str = string.rep("%%", 3 * blen) .. "%p" .. string.rep("%%", 2 * blen)
-  testpfs("P", str, {})
-end
-
-
 print('OK')