plan9-archive/lua

src/.fix+1−1

@@ -1,2 +1,2 @@
1	#define nvalue(x) 0	1	#define nvalue(x) ((lua_Number)0)
2	#define ttypenv(x) ttnov(x)	2	#define ttypenv(x) ttnov(x)

src/Makefile+5−4

 	lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o \
 	ltm.o lundump.o lvm.o lzio.o
 LIB_O=	lauxlib.o lbaselib.o lbitlib.o lcorolib.o ldblib.o liolib.o \
-	lmathlib.o loslib.o lstrlib.o ltablib.o loadlib.o linit.o
+	lmathlib.o loslib.o lstrlib.o ltablib.o lutf8lib.o loadlib.o linit.o
 BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
 LUA_T=	lua
 linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
 liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
 llex.o: llex.c lua.h luaconf.h lctype.h llimits.h ldo.h lobject.h \
- lstate.h ltm.h lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
+ lstate.h ltm.h lzio.h lmem.h lgc.h llex.h lparser.h lstring.h ltable.h
 lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
 lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
  ltm.h lzio.h lmem.h ldo.h lgc.h
 lstate.o: lstate.c lua.h luaconf.h lapi.h llimits.h lstate.h lobject.h \
  ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h llex.h lstring.h \
  ltable.h
-lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
+lstring.o: lstring.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
- ltm.h lzio.h lstring.h lgc.h
+ llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h
 lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
 ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
  ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
  ltm.h lzio.h lmem.h lundump.h ldebug.h lopcodes.h
 lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
+lutf8lib.o: lutf8lib.c lua.h luaconf.h lauxlib.h lualib.h
 lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
 lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \

src/lapi.c+66−70

 /*
-** $Id: lapi.c,v 2.185 2013/07/05 14:29:51 roberto Exp $
+** $Id: lapi.c,v 2.201 2014/03/12 20:57:40 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
 LUA_API int lua_isuserdata (lua_State *L, int idx) {
   const TValue *o = index2addr(L, idx);
-  return (ttisuserdata(o) || ttislightuserdata(o));
+  return (ttisfulluserdata(o) || ttislightuserdata(o));
 }
 LUA_API void lua_arith (lua_State *L, int op) {
   lua_lock(L);
-  if (op != LUA_OPUNM) /* all other operations expect two operands */
+  if (op != LUA_OPUNM && op != LUA_OPBNOT)
-    api_checknelems(L, 2);
+    api_checknelems(L, 2);  /* all other operations expect two operands */
-  else {  /* for unary minus, add fake 2nd operand */
+  else {  /* for unary operations, add fake 2nd operand */
     api_checknelems(L, 1);
     setobjs2s(L, L->top, L->top - 1);
     L->top++;
       isnum = 1;
       break;
     }
-    case LUA_TNUMFLT: {
+    case LUA_TNUMFLT: {  /* compute floor(n) % 2^(numbits in an integer) */
-      const lua_Number twop = (~(lua_Unsigned)0) + cast_num(1);
+      const lua_Number twop = cast_num(MAX_UINTEGER) + cast_num(1);  /* 2^n */
-      lua_Number n = fltvalue(o);
+      lua_Number n = fltvalue(o);  /* get value */
       int neg = 0;
-      n = l_floor(n);
+      n = l_floor(n);  /* get its floor */
       if (n < 0) {
         neg = 1;
-        n = -n;
+        n = -n;  /* make 'n' positive, so that 'fmod' is the same as '%' */
       }
-      n = l_mathop(fmod)(n, twop);
+      n = l_mathop(fmod)(n, twop);  /* n = n % 2^(numbits in an integer) */
-      if (luai_numisnan(L,n))   /* not a number? */
+      if (luai_numisnan(n))   /* not a number? */
         break;  /* not an integer, too */
-      res = cast_unsigned(n);
+      res = cast_unsigned(n);  /* 'n' now must fit in an unsigned */
-      if (neg) res = 0u - res;
+      if (neg) res = 0u - res;  /* back to negative, if needed */
       isnum = 1;
       break;
     }
     cl = luaF_newCclosure(L, n);
     cl->c.f = fn;
     L->top -= n;
-    while (n--)
+    while (n--) {
       setobj2n(L, &cl->c.upvalue[n], L->top + n);
+      /* does not need barrier because closure is white */
+    }
     setclCvalue(L, L->top, cl);
   }
   api_incr_top(L);
 */
-LUA_API void lua_getglobal (lua_State *L, const char *var) {
+LUA_API int lua_getglobal (lua_State *L, const char *var) {
   Table *reg = hvalue(&G(L)->l_registry);
   const TValue *gt;  /* global table */
   lua_lock(L);
   setsvalue2s(L, L->top++, luaS_new(L, var));
   luaV_gettable(L, gt, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_gettable (lua_State *L, int idx) {
+LUA_API int lua_gettable (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   luaV_gettable(L, t, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
+LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   api_incr_top(L);
   luaV_gettable(L, t, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_rawget (lua_State *L, int idx) {
+LUA_API int lua_rawget (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   api_check(L, ttistable(t), "table expected");
   setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
+LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   setobj2s(L, L->top, luaH_getint(hvalue(t), n));
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_rawgetp (lua_State *L, int idx, const void *p) {
+LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
   StkId t;
   TValue k;
   lua_lock(L);
   setobj2s(L, L->top, luaH_get(hvalue(t), &k));
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
   StkId o;
   lua_lock(L);
   o = index2addr(L, idx);
-  api_check(L, ttisuserdata(o), "userdata expected");
+  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  if (uvalue(o)->env) {
+  getuservalue(L, rawuvalue(o), L->top);
-    sethvalue(L, L->top, uvalue(o)->env);
-  } else
-    setnilvalue(L->top);
   api_incr_top(L);
   lua_unlock(L);
 }
     case LUA_TTABLE: {
       hvalue(obj)->metatable = mt;
       if (mt) {
-        luaC_objbarrierback(L, gcvalue(obj), mt);
+        luaC_objbarrier(L, gcvalue(obj), mt);
         luaC_checkfinalizer(L, gcvalue(obj), mt);
       }
       break;
   lua_lock(L);
   api_checknelems(L, 1);
   o = index2addr(L, idx);
-  api_check(L, ttisuserdata(o), "userdata expected");
+  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  if (ttisnil(L->top - 1))
+  setuservalue(L, rawuvalue(o), L->top - 1);
-    uvalue(o)->env = NULL;
+  luaC_barrier(L, gcvalue(o), L->top - 1);
-  else {
-    api_check(L, ttistable(L->top - 1), "table expected");
-    uvalue(o)->env = hvalue(L->top - 1);
-    luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
-  }
   L->top--;
   lua_unlock(L);
 }
 }
-LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
+LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) {
   int status;
   TValue *o;
   lua_lock(L);
   api_checknelems(L, 1);
   o = L->top - 1;
   if (isLfunction(o))
-    status = luaU_dump(L, getproto(o), writer, data, 0);
+    status = luaU_dump(L, getproto(o), writer, data, strip);
   else
     status = 1;
   lua_unlock(L);
       break;
     }
     case LUA_GCSTEP: {
-      if (g->gckind == KGC_GEN) {  /* generational mode? */
+      l_mem debt = 1;  /* =1 to signal that it did an actual step */
-        res = (g->GCestimate == 0);  /* true if it will do major collection */
+      int oldrunning = g->gcrunning;
-        luaC_forcestep(L);  /* do a single step */
+      g->gcrunning = 1;  /* force GC to run */
+      if (data == 0) {
+        luaE_setdebt(g, -GCSTEPSIZE);  /* to do a "small" step */
+        luaC_step(L);
       }
-      else {
+      else {  /* add 'data' to total debt */
-       lu_mem debt = cast(lu_mem, data) * 1024 - GCSTEPSIZE;
+        debt = cast(l_mem, data) * 1024 + g->GCdebt;
-       if (g->gcrunning)
+        luaE_setdebt(g, debt);
-         debt += g->GCdebt;  /* include current debt */
+        luaC_checkGC(L);
-       luaE_setdebt(g, debt);
-       luaC_forcestep(L);
-       if (g->gcstate == GCSpause)  /* end of cycle? */
-         res = 1;  /* signal it */
       }
+      g->gcrunning = oldrunning;  /* restore previous state */
+      if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */
+        res = 1;  /* signal it */
       break;
     }
     case LUA_GCSETPAUSE: {
       g->gcpause = data;
       break;
     }
-    case LUA_GCSETMAJORINC: {
-      res = g->gcmajorinc;
-      g->gcmajorinc = data;
-      break;
-    }
     case LUA_GCSETSTEPMUL: {
       res = g->gcstepmul;
+      if (data < 40) data = 40;  /* avoid ridiculous low values (and 0) */
       g->gcstepmul = data;
       break;
     }
       res = g->gcrunning;
       break;
     }
-    case LUA_GCGEN: {  /* change collector to generational mode */
-      luaC_changemode(L, KGC_GEN);
-      break;
-    }
-    case LUA_GCINC: {  /* change collector to incremental mode */
-      luaC_changemode(L, KGC_NORMAL);
-      break;
-    }
     default: res = -1;  /* invalid option */
   }
   lua_unlock(L);
   Udata *u;
   lua_lock(L);
   luaC_checkGC(L);
-  u = luaS_newudata(L, size, NULL);
+  u = luaS_newudata(L, size);
   setuvalue(L, L->top, u);
   api_incr_top(L);
   lua_unlock(L);
 static const char *aux_upvalue (StkId fi, int n, TValue **val,
-                                GCObject **owner) {
+                                GCObject **owner, UpVal **uv) {
   switch (ttype(fi)) {
     case LUA_TCCL: {  /* C closure */
       CClosure *f = clCvalue(fi);
       Proto *p = f->p;
       if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
       *val = f->upvals[n-1]->v;
-      if (owner) *owner = obj2gco(f->upvals[n - 1]);
+      if (uv) *uv = f->upvals[n - 1];
       name = p->upvalues[n-1].name;
-      return (name == NULL) ? "" : getstr(name);
+      return (name == NULL) ? "(*no name)" : getstr(name);
     }
     default: return NULL;  /* not a closure */
   }
   const char *name;
   TValue *val = NULL;  /* to avoid warnings */
   lua_lock(L);
-  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL);
+  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL, NULL);
   if (name) {
     setobj2s(L, L->top, val);
     api_incr_top(L);
 LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
   const char *name;
   TValue *val = NULL;  /* to avoid warnings */
-  GCObject *owner = NULL;  /* to avoid warnings */
+  GCObject *owner = NULL;
+  UpVal *uv = NULL;
   StkId fi;
   lua_lock(L);
   fi = index2addr(L, funcindex);
   api_checknelems(L, 1);
-  name = aux_upvalue(fi, n, &val, &owner);
+  name = aux_upvalue(fi, n, &val, &owner, &uv);
   if (name) {
     L->top--;
     setobj(L, val, L->top);
-    luaC_barrier(L, owner, L->top);
+    if (owner) { luaC_barrier(L, owner, L->top); }
+    else if (uv) { luaC_upvalbarrier(L, uv); }
   }
   lua_unlock(L);
   return name;
   LClosure *f1;
   UpVal **up1 = getupvalref(L, fidx1, n1, &f1);
   UpVal **up2 = getupvalref(L, fidx2, n2, NULL);
+  luaC_upvdeccount(L, *up1);
   *up1 = *up2;
-  luaC_objbarrier(L, f1, *up2);
+  (*up1)->refcount++;
+  if (upisopen(*up1)) (*up1)->u.open.touched = 1;
+  luaC_upvalbarrier(L, *up1);
 }

src/lauxlib.c+71−59

 /*
-** $Id: lauxlib.c,v 1.255 2013/06/27 18:32:33 roberto Exp $
+** $Id: lauxlib.c,v 1.260 2014/03/12 20:57:40 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 ** =======================================================
 */
-LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
   lua_Debug ar;
   if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
-    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
+    return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
   lua_getinfo(L, "n", &ar);
   if (strcmp(ar.namewhat, "method") == 0) {
-    narg--;  /* do not count `self' */
+    arg--;  /* do not count `self' */
-    if (narg == 0)  /* error is in the self argument itself? */
+    if (arg == 0)  /* error is in the self argument itself? */
       return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
                            ar.name, extramsg);
   }
   if (ar.name == NULL)
     ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
   return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
-                        narg, ar.name, extramsg);
+                        arg, ar.name, extramsg);
 }
-static int typeerror (lua_State *L, int narg, const char *tname) {
+static int typeerror (lua_State *L, int arg, const char *tname) {
-  const char *msg = lua_pushfstring(L, "%s expected, got %s",
+  const char *msg;
-                                    tname, luaL_typename(L, narg));
+  const char *typearg = luaL_typename(L, arg);
-  return luaL_argerror(L, narg, msg);
+  if (lua_getmetatable(L, arg)) {
+    if (lua_getfield(L, -1, "__name") == LUA_TSTRING)
+      typearg = lua_tostring(L, -1);
+  }
+  else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
+    typearg = "light userdata";
+  msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
+  return luaL_argerror(L, arg, msg);
 }
-static void tag_error (lua_State *L, int narg, int tag) {
+static void tag_error (lua_State *L, int arg, int tag) {
-  typeerror(L, narg, lua_typename(L, tag));
+  typeerror(L, arg, lua_typename(L, tag));
 }
     return 0;  /* leave previous value on top, but return 0 */
   lua_pop(L, 1);
   lua_newtable(L);  /* create metatable */
+  lua_pushstring(L, tname);
+  lua_setfield(L, -2, "__name");  /* metatable.__name = tname */
   lua_pushvalue(L, -1);
   lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
   return 1;
 ** =======================================================
 */
-LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
+LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
                                  const char *const lst[]) {
-  const char *name = (def) ? luaL_optstring(L, narg, def) :
+  const char *name = (def) ? luaL_optstring(L, arg, def) :
-                             luaL_checkstring(L, narg);
+                             luaL_checkstring(L, arg);
   int i;
   for (i=0; lst[i]; i++)
     if (strcmp(lst[i], name) == 0)
       return i;
-  return luaL_argerror(L, narg,
+  return luaL_argerror(L, arg,
                        lua_pushfstring(L, "invalid option " LUA_QS, name));
 }
 }
-LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
+LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {
-  if (lua_type(L, narg) != t)
+  if (lua_type(L, arg) != t)
-    tag_error(L, narg, t);
+    tag_error(L, arg, t);
 }
-LUALIB_API void luaL_checkany (lua_State *L, int narg) {
+LUALIB_API void luaL_checkany (lua_State *L, int arg) {
-  if (lua_type(L, narg) == LUA_TNONE)
+  if (lua_type(L, arg) == LUA_TNONE)
-    luaL_argerror(L, narg, "value expected");
+    luaL_argerror(L, arg, "value expected");
 }
-LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
+LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {
-  const char *s = lua_tolstring(L, narg, len);
+  const char *s = lua_tolstring(L, arg, len);
-  if (!s) tag_error(L, narg, LUA_TSTRING);
+  if (!s) tag_error(L, arg, LUA_TSTRING);
   return s;
 }
-LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
+LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
                                         const char *def, size_t *len) {
-  if (lua_isnoneornil(L, narg)) {
+  if (lua_isnoneornil(L, arg)) {
     if (len)
       *len = (def ? strlen(def) : 0);
     return def;
   }
-  else return luaL_checklstring(L, narg, len);
+  else return luaL_checklstring(L, arg, len);
 }
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
+LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
   int isnum;
-  lua_Number d = lua_tonumberx(L, narg, &isnum);
+  lua_Number d = lua_tonumberx(L, arg, &isnum);
   if (!isnum)
-    tag_error(L, narg, LUA_TNUMBER);
+    tag_error(L, arg, LUA_TNUMBER);
   return d;
 }
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
+LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {
-  return luaL_opt(L, luaL_checknumber, narg, def);
+  return luaL_opt(L, luaL_checknumber, arg, def);
 }
-static void interror (lua_State *L, int narg) {
+static void interror (lua_State *L, int arg) {
-  if (lua_type(L, narg) == LUA_TNUMBER)
+  if (lua_type(L, arg) == LUA_TNUMBER)
-    luaL_argerror(L, narg, "float value out of range");
+    luaL_argerror(L, arg, "float value out of range");
   else
-    tag_error(L, narg, LUA_TNUMBER);
+    tag_error(L, arg, LUA_TNUMBER);
 }
-LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
+LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
   int isnum;
-  lua_Integer d = lua_tointegerx(L, narg, &isnum);
+  lua_Integer d = lua_tointegerx(L, arg, &isnum);
   if (!isnum) {
-    interror(L, narg);
+    interror(L, arg);
   }
   return d;
 }
-LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) {
+LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int arg) {
   int isnum;
-  lua_Unsigned d = lua_tounsignedx(L, narg, &isnum);
+  lua_Unsigned d = lua_tounsignedx(L, arg, &isnum);
   if (!isnum)
-    interror(L, narg);
+    interror(L, arg);
   return d;
 }
-LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
+LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
                                                       lua_Integer def) {
-  return luaL_opt(L, luaL_checkinteger, narg, def);
+  return luaL_opt(L, luaL_checkinteger, arg, def);
 }
-LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg,
+LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int arg,
                                                         lua_Unsigned def) {
-  return luaL_opt(L, luaL_checkunsigned, narg, def);
+  return luaL_opt(L, luaL_checkunsigned, arg, def);
 }
 /* }====================================================== */
   if (!lua_getmetatable(L, obj))  /* no metatable? */
     return 0;
   lua_pushstring(L, event);
-  lua_rawget(L, -2);
+  if (lua_rawget(L, -2) == LUA_TNIL) {  /* is metafield nil? */
-  if (lua_isnil(L, -1)) {
     lua_pop(L, 2);  /* remove metatable and metafield */
     return 0;
   }
 LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
   if (!luaL_callmeta(L, idx, "__tostring")) {  /* no metafield? */
     switch (lua_type(L, idx)) {
-      case LUA_TNUMBER: {  /* concatenate with empty string to convert */
+      case LUA_TNUMBER: {
-        lua_pushvalue(L, idx);
+        if (lua_isinteger(L, idx))
-        lua_pushliteral(L, "");
+          lua_pushfstring(L, "%I", lua_tointeger(L, idx));
-        lua_concat(L, 2);
+        else {
+          const char *s = lua_pushfstring(L, "%f", lua_tonumber(L, idx));
+          if (s[strspn(s, "-0123456789")] == '\0') {  /* looks like an int? */
+            lua_pushliteral(L, ".0");  /* add a '.0' to result */
+            lua_concat(L, 2);
+          }
+        }
         break;
       }
       case LUA_TSTRING:
     e = strchr(fname, '.');
     if (e == NULL) e = fname + strlen(fname);
     lua_pushlstring(L, fname, e - fname);
-    lua_rawget(L, -2);
+    if (lua_rawget(L, -2) == LUA_TNIL) {  /* no such field? */
-    if (lua_isnil(L, -1)) {  /* no such field? */
       lua_pop(L, 1);  /* remove this nil */
       lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
       lua_pushlstring(L, fname, e - fname);
 LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,
                                  int sizehint) {
   luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);  /* get _LOADED table */
-  lua_getfield(L, -1, modname);  /* get _LOADED[modname] */
+  if (lua_getfield(L, -1, modname) != LUA_TTABLE) {  /* no _LOADED[modname]? */
-  if (!lua_istable(L, -1)) {  /* not found? */
     lua_pop(L, 1);  /* remove previous result */
     /* try global variable (and create one if it does not exist) */
     lua_pushglobaltable(L);
 ** into the stack
 */
 LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
-  lua_getfield(L, idx, fname);
+  if (lua_getfield(L, idx, fname) == LUA_TTABLE)
-  if (lua_istable(L, -1)) return 1;  /* table already there */
+    return 1;  /* table already there */
   else {
     lua_pop(L, 1);  /* remove previous result */
     idx = lua_absindex(L, idx);

src/lauxlib.h+15−15

src/lbaselib.c+7−9

 /*
-** $Id: lbaselib.c,v 1.279 2013/07/05 14:39:15 roberto Exp $
+** $Id: lbaselib.c,v 1.285 2014/03/12 20:57:40 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
   s += strspn(s, SPACECHARS);  /* skip trailing spaces */
   if (s != e)  /* invalid trailing characters? */
     return 0;
-  *pn = (neg) ? -(lua_Integer)n : (lua_Integer)n;
+  *pn = (lua_Integer)((neg) ? (0u - n) : n);
   return 1;
 }
 static int luaB_collectgarbage (lua_State *L) {
   static const char *const opts[] = {"stop", "restart", "collect",
     "count", "step", "setpause", "setstepmul",
-    "setmajorinc", "isrunning", "generational", "incremental", NULL};
+    "isrunning", NULL};
   static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
     LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
-    LUA_GCSETMAJORINC, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
+    LUA_GCISRUNNING};
   int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
   int ex = luaL_optint(L, 2, 0);
   int res = lua_gc(L, o, ex);
   switch (o) {
     case LUA_GCCOUNT: {
       int b = lua_gc(L, LUA_GCCOUNTB, 0);
-      lua_pushnumber(L, res + ((lua_Number)b/1024));
+      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
-      lua_pushinteger(L, b);
+      return 1;
-      return 2;
     }
     case LUA_GCSTEP: case LUA_GCISRUNNING: {
       lua_pushboolean(L, res);
   luaL_checktype(L, 1, LUA_TTABLE);
   i++;  /* next value */
   lua_pushinteger(L, i);
-  lua_rawgeti(L, 1, i);
+  return (lua_rawgeti(L, 1, i) == LUA_TNIL) ? 1 : 2;
-  return (lua_isnil(L, -1)) ? 1 : 2;
 }

src/lbitlib.c+37−22

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lbitlib.c,v 1.20 2013/06/21 17:27:24 roberto Exp $	2	** $Id: lbitlib.c,v 1.25 2014/03/20 19:22:16 roberto Exp $
3	** Standard library for bitwise operations	3	** Standard library for bitwise operations
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -13,17 +13,21 @@ · 7 unmodified lines
13	#include "lualib.h"	13	#include "lualib.h"
14		14
15		15
		16	#if defined(LUA_COMPAT_BITLIB) /* { */
		17
		18
16	/* number of bits to consider in a number */	19	/* number of bits to consider in a number */
17	#if !defined(LUA_NBITS)	20	#if !defined(LUA_NBITS)
18	#define LUA_NBITS 32	21	#define LUA_NBITS 32
19	#endif	22	#endif
20		23
21		24
22	/* type with (at least) LUA_NBITS bits */	25	/*
23	typedef unsigned long b_uint;	26	** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must
24		27	** be made in two parts to avoid problems when LUA_NBITS is equal to the
25		28	** number of bits in a lua_Unsigned.)
26	#define ALLONES (~(((~(b_uint)0) << (LUA_NBITS - 1)) << 1))	29	*/
		30	#define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
27		31
28		32
29	/* macro to trim extra bits */	33	/* macro to trim extra bits */
@@ -35,9 +39,9 @@ typedef unsigned long b_uint; · 5 unmodified lines
35		39
36		40
37		41
38	static b_uint andaux (lua_State *L) {	42	static lua_Unsigned andaux (lua_State *L) {
39	int i, n = lua_gettop(L);	43	int i, n = lua_gettop(L);
40	b_uint r = ~(b_uint)0;	44	lua_Unsigned r = ~(lua_Unsigned)0;
41	for (i = 1; i <= n; i++)	45	for (i = 1; i <= n; i++)
42	r &= luaL_checkunsigned(L, i);	46	r &= luaL_checkunsigned(L, i);
43	return trim(r);	47	return trim(r);
@@ -45,14 +49,14 @@ static b_uint andaux (lua_State *L) { · 1 unmodified line
45		49
46		50
47	static int b_and (lua_State *L) {	51	static int b_and (lua_State *L) {
48	b_uint r = andaux(L);	52	lua_Unsigned r = andaux(L);
49	lua_pushunsigned(L, r);	53	lua_pushunsigned(L, r);
50	return 1;	54	return 1;
51	}	55	}
52		56
53		57
54	static int b_test (lua_State *L) {	58	static int b_test (lua_State *L) {
55	b_uint r = andaux(L);	59	lua_Unsigned r = andaux(L);
56	lua_pushboolean(L, r != 0);	60	lua_pushboolean(L, r != 0);
57	return 1;	61	return 1;
58	}	62	}
@@ -60,7 +64,7 @@ static int b_test (lua_State *L) { · 1 unmodified line
60		64
61	static int b_or (lua_State *L) {	65	static int b_or (lua_State *L) {
62	int i, n = lua_gettop(L);	66	int i, n = lua_gettop(L);
63	b_uint r = 0;	67	lua_Unsigned r = 0;
64	for (i = 1; i <= n; i++)	68	for (i = 1; i <= n; i++)
65	r \|= luaL_checkunsigned(L, i);	69	r \|= luaL_checkunsigned(L, i);
66	lua_pushunsigned(L, trim(r));	70	lua_pushunsigned(L, trim(r));
@@ -70,7 +74,7 @@ static int b_or (lua_State *L) { · 3 unmodified lines
70		74
71	static int b_xor (lua_State *L) {	75	static int b_xor (lua_State *L) {
72	int i, n = lua_gettop(L);	76	int i, n = lua_gettop(L);
73	b_uint r = 0;	77	lua_Unsigned r = 0;
74	for (i = 1; i <= n; i++)	78	for (i = 1; i <= n; i++)
75	r ^= luaL_checkunsigned(L, i);	79	r ^= luaL_checkunsigned(L, i);
76	lua_pushunsigned(L, trim(r));	80	lua_pushunsigned(L, trim(r));
@@ -79,13 +83,13 @@ static int b_xor (lua_State *L) { · 2 unmodified lines
79		83
80		84
81	static int b_not (lua_State *L) {	85	static int b_not (lua_State *L) {
82	b_uint r = ~luaL_checkunsigned(L, 1);	86	lua_Unsigned r = ~luaL_checkunsigned(L, 1);
83	lua_pushunsigned(L, trim(r));	87	lua_pushunsigned(L, trim(r));
84	return 1;	88	return 1;
85	}	89	}
86		90
87		91
88	static int b_shift (lua_State *L, b_uint r, int i) {	92	static int b_shift (lua_State *L, lua_Unsigned r, int i) {
89	if (i < 0) { /* shift right? */	93	if (i < 0) { /* shift right? */
90	i = -i;	94	i = -i;
91	r = trim(r);	95	r = trim(r);
@@ -113,14 +117,14 @@ static int b_rshift (lua_State *L) { · 21 unmodified lines
113		117
114		118
115	static int b_arshift (lua_State *L) {	119	static int b_arshift (lua_State *L) {
116	b_uint r = luaL_checkunsigned(L, 1);	120	lua_Unsigned r = luaL_checkunsigned(L, 1);
117	int i = luaL_checkint(L, 2);	121	int i = luaL_checkint(L, 2);
118	if (i < 0 \|\| !(r & ((b_uint)1 << (LUA_NBITS - 1))))	122	if (i < 0 \|\| !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
119	return b_shift(L, r, -i);	123	return b_shift(L, r, -i);
120	else { /* arithmetic shift for 'negative' number */	124	else { /* arithmetic shift for 'negative' number */
121	if (i >= LUA_NBITS) r = ALLONES;	125	if (i >= LUA_NBITS) r = ALLONES;
122	else	126	else
123	r = trim((r >> i) \| ~(trim(~(b_uint)0) >> i)); /* add signal bit */	127	r = trim((r >> i) \| ~(trim(~(lua_Unsigned)0) >> i)); /* add signal bit */
124	lua_pushunsigned(L, r);	128	lua_pushunsigned(L, r);
125	return 1;	129	return 1;
126	}	130	}
@@ -128,10 +132,11 @@ static int b_arshift (lua_State *L) { · 1 unmodified line
128		132
129		133
130	static int b_rot (lua_State *L, int i) {	134	static int b_rot (lua_State *L, int i) {
131	b_uint r = luaL_checkunsigned(L, 1);	135	lua_Unsigned r = luaL_checkunsigned(L, 1);
132	i &= (LUA_NBITS - 1); /* i = i % NBITS */	136	i &= (LUA_NBITS - 1); /* i = i % NBITS */
133	r = trim(r);	137	r = trim(r);
134	r = (r << i) \| (r >> (LUA_NBITS - i));	138	if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */
		139	r = (r << i) \| (r >> (LUA_NBITS - i));
135	lua_pushunsigned(L, trim(r));	140	lua_pushunsigned(L, trim(r));
136	return 1;	141	return 1;
137	}	142	}
@@ -167,7 +172,7 @@ static int fieldargs (lua_State L, int farg, int width) { · 29 unmodified lines
167		172
168	static int b_extract (lua_State *L) {	173	static int b_extract (lua_State *L) {
169	int w;	174	int w;
170	b_uint r = trim(luaL_checkunsigned(L, 1));	175	lua_Unsigned r = trim(luaL_checkunsigned(L, 1));
171	int f = fieldargs(L, 2, &w);	176	int f = fieldargs(L, 2, &w);
172	r = (r >> f) & mask(w);	177	r = (r >> f) & mask(w);
173	lua_pushunsigned(L, r);	178	lua_pushunsigned(L, r);
@@ -177,8 +182,8 @@ static int b_extract (lua_State *L) { · 3 unmodified lines
177		182
178	static int b_replace (lua_State *L) {	183	static int b_replace (lua_State *L) {
179	int w;	184	int w;
180	b_uint r = trim(luaL_checkunsigned(L, 1));	185	lua_Unsigned r = trim(luaL_checkunsigned(L, 1));
181	b_uint v = luaL_checkunsigned(L, 2);	186	lua_Unsigned v = luaL_checkunsigned(L, 2);
182	int f = fieldargs(L, 3, &w);	187	int f = fieldargs(L, 3, &w);
183	int m = mask(w);	188	int m = mask(w);
184	v &= m; /* erase bits outside given width */	189	v &= m; /* erase bits outside given width */
@@ -211,3 +216,13 @@ LUAMOD_API int luaopen_bit32 (lua_State *L) { · 26 unmodified lines
211	return 1;	216	return 1;
212	}	217	}
213		218
		219
		220	#else /* }{ */
		221
		222
		223	LUAMOD_API int luaopen_bit32 (lua_State *L) {
		224	lua_pushnil(L);
		225	return 1;
		226	}
		227
		228	#endif /* } */

src/lcode.c+65−36

 /*
-** $Id: lcode.c,v 2.71 2013/06/25 18:57:18 roberto Exp $
+** $Id: lcode.c,v 2.85 2014/03/21 13:52:33 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 }
+/*
+** Use scanner's table to cache position of constants in constant list
+** and try to reuse constants
+*/
 static int addk (FuncState *fs, TValue *key, TValue *v) {
   lua_State *L = fs->ls->L;
-  TValue *idx = luaH_set(L, fs->h, key);
   Proto *f = fs->f;
+  TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
   int k, oldsize;
-  if (ttisinteger(idx)) {
+  if (ttisinteger(idx)) {  /* is there an index there? */
     k = ivalue(idx);
-    if (luaV_rawequalobj(&f->k[k], v))
+    /* correct value? (warning: must distinguish floats from integers!) */
-      return k;
+    if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&
-    /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
+                      luaV_rawequalobj(&f->k[k], v))
-       go through and create a new entry for this value */
+      return k;  /* reuse index */
   }
   /* constant not found; create a new entry */
   oldsize = f->sizek;
 */
 static int luaK_numberK (FuncState *fs, lua_Number r) {
   TValue o;
-  lua_assert(!luai_numisnan(NULL, r) && !isminuszero(r));
+  lua_assert(!luai_numisnan(r) && !isminuszero(r));
   setnvalue(&o, r);
   return addk(fs, &o, &o);
 }
   TValue k, v;
   setnilvalue(&v);
   /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->ls->L, &k, fs->h);
+  sethvalue(fs->ls->L, &k, fs->ls->h);
   return addk(fs, &k, &v);
 }
 }
-static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
+/*
-  TValue v1, v2, res;
+** return false if folding can raise an error
+*/
+static int validop (int op, TValue *v1, TValue *v2) {
+  lua_Number a, b;
   lua_Integer i;
-  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2))
+  cast_void(a); cast_void(b);  /* macro may not use its arguments */
+  if (luai_numinvalidop(op, (cast_void(tonumber(v1, &a)), a),
+                            (cast_void(tonumber(v2, &b)), b)))
     return 0;
-  if (op == OP_IDIV &&
+  switch (op) {
-        (!tointeger(&v1, &i) || !tointeger(&v2, &i) || i == 0))
+    case LUA_OPIDIV:  /* division by 0 and conversion errors */
-    return 0;  /* avoid division by 0 and conversion errors */
+      return (tointeger(v1, &i) && tointeger(v2, &i) && i != 0);
-  if (op == OP_MOD && ttisinteger(&v1) && ttisinteger(&v2) && ivalue(&v2) == 0)
+    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
-    return 0;  /* avoid module by 0 at compile time */
+    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT:  /* conversion errors */
-  luaO_arith(NULL, op - OP_ADD + LUA_OPADD, &v1, &v2, &res);
+      return (tointeger(v1, &i) && tointeger(v2, &i));
+    case LUA_OPMOD:  /* integer module by 0 */
+      return !(ttisinteger(v1) && ttisinteger(v2) && ivalue(v2) == 0);
+    case LUA_OPPOW:  /* negative integer exponentiation */
+      return !(ttisinteger(v1) && ttisinteger(v2) && ivalue(v2) < 0);
+    default: return 1;  /* everything else is valid */
+  }
+}
+/*
+** Try to "constant-fold" an operation; return 1 iff successful
+*/
+static int constfolding (FuncState *fs, int op, expdesc *e1, expdesc *e2) {
+  TValue v1, v2, res;
+  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
+    return 0;  /* non-numeric operands or not safe to fold */
+  luaO_arith(fs->ls->L, op, &v1, &v2, &res);
   if (ttisinteger(&res)) {
     e1->k = VKINT;
     e1->u.ival = ivalue(&res);
   }
   else {
     lua_Number n = fltvalue(&res);
-    if (luai_numisnan(NULL, n) || isminuszero(n))
+    if (luai_numisnan(n) || isminuszero(n))
       return 0;  /* folds neither NaN nor -0 */
     e1->k = VKFLT;
     e1->u.nval = n;
 static void codearith (FuncState *fs, OpCode op,
                        expdesc *e1, expdesc *e2, int line) {
-  if (!constfolding(op, e1, e2)) {  /* could not fold operation? */
+  if (!constfolding(fs, op - OP_ADD + LUA_OPADD, e1, e2)) {
-    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
+    int o1, o2;
-    int o1 = luaK_exp2RK(fs, e1);
+    if (op == OP_UNM || op == OP_BNOT || op == OP_LEN) {
+      o2 = 0;
+      o1 = luaK_exp2anyreg(fs, e1);  /* cannot operate on constants */
+    }
+    else {  /* regular case (binary operators) */
+      o2 = luaK_exp2RK(fs, e2);
+      o1 = luaK_exp2RK(fs, e1);
+    }
     if (o1 > o2) {
       freeexp(fs, e1);
       freeexp(fs, e2);
 void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
   expdesc e2;
-  e2.t = e2.f = NO_JUMP; e2.k = VKFLT; e2.u.nval = 0;
+  e2.t = e2.f = NO_JUMP; e2.k = VKINT; e2.u.ival = 0;
   switch (op) {
-    case OPR_MINUS: {
+    case OPR_MINUS: case OPR_BNOT: case OPR_LEN: {
-      if (!constfolding(OP_UNM, e, e)) {  /* cannot fold it? */
+      codearith(fs, cast(OpCode, (op - OPR_MINUS) + OP_UNM), e, &e2, line);
-        luaK_exp2anyreg(fs, e);
-        codearith(fs, OP_UNM, e, &e2, line);
-      }
       break;
     }
     case OPR_NOT: codenot(fs, e); break;
-    case OPR_LEN: {
-      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
-      codearith(fs, OP_LEN, e, &e2, line);
-      break;
-    }
     default: lua_assert(0);
   }
 }
     }
     case OPR_ADD: case OPR_SUB:
     case OPR_MUL: case OPR_DIV: case OPR_IDIV:
-    case OPR_MOD: case OPR_POW: {
+    case OPR_MOD: case OPR_POW:
+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
+    case OPR_SHL: case OPR_SHR: {
       if (!tonumeral(v, NULL)) luaK_exp2RK(fs, v);
       break;
     }
       break;
     }
     case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_IDIV: case OPR_MOD: case OPR_POW: {
+    case OPR_IDIV: case OPR_MOD: case OPR_POW:
-      codearith(fs, cast(OpCode, op - OPR_ADD + OP_ADD), e1, e2, line);
+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
+    case OPR_SHL: case OPR_SHR: {
+      codearith(fs, cast(OpCode, (op - OPR_ADD) + OP_ADD), e1, e2, line);
       break;
     }
     case OPR_EQ: case OPR_LT: case OPR_LE: {

src/lcode.h+7−3

 /*
-** $Id: lcode.h,v 1.60 2013/04/26 13:07:53 roberto Exp $
+** $Id: lcode.h,v 1.63 2013/12/30 20:47:58 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 ** grep "ORDER OPR" if you change these enums  (ORDER OP)
 */
 typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_IDIV, OPR_MOD, OPR_POW,
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
+  OPR_DIV,
+  OPR_IDIV,
+  OPR_BAND, OPR_BOR, OPR_BXOR,
+  OPR_SHL, OPR_SHR,
   OPR_CONCAT,
   OPR_EQ, OPR_LT, OPR_LE,
   OPR_NE, OPR_GT, OPR_GE,
 } BinOpr;
-typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
 #define getcode(fs,e)	((fs)->f->code[(e)->u.info])

src/ldblib.c+3−7

 /*
-** $Id: ldblib.c,v 1.133 2013/06/25 19:37:00 roberto Exp $
+** $Id: ldblib.c,v 1.137 2014/03/12 20:57:40 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 static int db_setuservalue (lua_State *L) {
-  if (lua_type(L, 1) == LUA_TLIGHTUSERDATA)
-    luaL_argerror(L, 1, "full userdata expected, got light userdata");
   luaL_checktype(L, 1, LUA_TUSERDATA);
-  if (!lua_isnoneornil(L, 2))
+  luaL_checkany(L, 2);
-    luaL_checktype(L, 2, LUA_TTABLE);
   lua_settop(L, 2);
   lua_setuservalue(L, 1);
   return 1;
     {"call", "return", "line", "count", "tail call"};
   gethooktable(L);
   lua_pushthread(L);
-  lua_rawget(L, -2);
+  if (lua_rawget(L, -2) == LUA_TFUNCTION) {
-  if (lua_isfunction(L, -1)) {
     lua_pushstring(L, hooknames[(int)ar->event]);
     if (ar->currentline >= 0)
       lua_pushinteger(L, ar->currentline);

src/ldebug.c+20−13

 /*
-** $Id: ldebug.c,v 2.95 2013/05/06 17:21:59 roberto Exp $
+** $Id: ldebug.c,v 2.97 2013/12/09 14:21:10 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
 /*
 ** this function can be called asynchronous (e.g. during a signal)
 */
-LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
+LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
   if (func == NULL || mask == 0) {  /* turn off hooks? */
     mask = 0;
     func = NULL;
   L->basehookcount = count;
   resethookcount(L);
   L->hookmask = cast_byte(mask);
-  return 1;
 }
 }
+static int filterpc (int pc, int jmptarget) {
+  if (pc < jmptarget)  /* is code conditional (inside a jump)? */
+    return -1;  /* cannot know who sets that register */
+  else return pc;  /* current position sets that register */
+}
 /*
 ** try to find last instruction before 'lastpc' that modified register 'reg'
 */
 static int findsetreg (Proto *p, int lastpc, int reg) {
   int pc;
   int setreg = -1;  /* keep last instruction that changed 'reg' */
+  int jmptarget = 0;  /* any code before this address is conditional */
   for (pc = 0; pc < lastpc; pc++) {
     Instruction i = p->code[pc];
     OpCode op = GET_OPCODE(i);
       case OP_LOADNIL: {
         int b = GETARG_B(i);
         if (a <= reg && reg <= a + b)  /* set registers from 'a' to 'a+b' */
-          setreg = pc;
+          setreg = filterpc(pc, jmptarget);
         break;
       }
       case OP_TFORCALL: {
-        if (reg >= a + 2) setreg = pc;  /* affect all regs above its base */
+        if (reg >= a + 2)  /* affect all regs above its base */
+          setreg = filterpc(pc, jmptarget);
         break;
       }
       case OP_CALL:
       case OP_TAILCALL: {
-        if (reg >= a) setreg = pc;  /* affect all registers above base */
+        if (reg >= a)  /* affect all registers above base */
+          setreg = filterpc(pc, jmptarget);
         break;
       }
       case OP_JMP: {
         int b = GETARG_sBx(i);
         int dest = pc + 1 + b;
         /* jump is forward and do not skip `lastpc'? */
-        if (pc < dest && dest <= lastpc)
+        if (pc < dest && dest <= lastpc) {
-          pc += b;  /* do the jump */
+          if (dest > jmptarget)
-        break;
+            jmptarget = dest;  /* update 'jmptarget' */
-      }
+        }
-      case OP_TEST: {
-        if (reg == a) setreg = pc;  /* jumped code can change 'a' */
         break;
       }
       default:
         if (testAMode(op) && reg == a)  /* any instruction that set A */
-          setreg = pc;
+          setreg = filterpc(pc, jmptarget);
         break;
     }
   }

src/ldebug.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldebug.h,v 2.10 2013/05/06 17:19:11 roberto Exp $	2	** $Id: ldebug.h,v 2.11 2014/02/25 14:31:16 roberto Exp $
3	** Auxiliary functions from Debug Interface module	3	** Auxiliary functions from Debug Interface module
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -13,7 +13,7 @@ · 7 unmodified lines
13		13
14	#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1)	14	#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1)
15		15
16	#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0)	16	#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : -1)
17		17
18	#define resethookcount(L) (L->hookcount = L->basehookcount)	18	#define resethookcount(L) (L->hookcount = L->basehookcount)
19		19

src/ldo.c+23−20

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldo.c,v 2.109 2013/04/19 21:05:04 roberto Exp $	2	** $Id: ldo.c,v 2.115 2014/03/21 13:52:33 roberto Exp $
3	** Stack and Call structure of Lua	3	** Stack and Call structure of Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -46,30 +46,33 @@ · 40 unmodified lines
46	** C++ code, with _longjmp/_setjmp when asked to use them, and with	46	** C++ code, with _longjmp/_setjmp when asked to use them, and with
47	** longjmp/setjmp otherwise.	47	** longjmp/setjmp otherwise.
48	*/	48	*/
49	#if !defined(LUAI_THROW)	49	#if !defined(LUAI_THROW) /* { */
		50
		51	#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) /* { */
50		52
51	#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)
52	/* C++ exceptions */	53	/* C++ exceptions */
53	#define LUAI_THROW(L,c) throw(c)	54	#define LUAI_THROW(L,c) throw(c)
54	#define LUAI_TRY(L,c,a) \	55	#define LUAI_TRY(L,c,a) \
55	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }	56	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
56	#define luai_jmpbuf int /* dummy variable */	57	#define luai_jmpbuf int /* dummy variable */
57		58
58	#elif defined(LUA_USE_ULONGJMP)	59	#elif defined(LUA_USE_POSIX) /* }{ */
59	/* in Unix, try _longjmp/_setjmp (more efficient) */	60
		61	/* in POSIX, try _longjmp/_setjmp (more efficient) */
60	#define LUAI_THROW(L,c) _longjmp((c)->b, 1)	62	#define LUAI_THROW(L,c) _longjmp((c)->b, 1)
61	#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }	63	#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
62	#define luai_jmpbuf jmp_buf	64	#define luai_jmpbuf jmp_buf
63		65
64	#else	66	#else /* }{ */
65	/* default handling with long jumps */	67
		68	/* ANSI handling with long jumps */
66	#define LUAI_THROW(L,c) longjmp((c)->b, 1)	69	#define LUAI_THROW(L,c) longjmp((c)->b, 1)
67	#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }	70	#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
68	#define luai_jmpbuf jmp_buf	71	#define luai_jmpbuf jmp_buf
69		72
70	#endif	73	#endif /* } */
71		74
72	#endif	75	#endif /* } */
73		76
74		77
75		78
@@ -141,10 +144,10 @@ int luaD_rawrunprotected (lua_State L, Pfunc f, void ud) { · 65 unmodified lines
141		144
142	static void correctstack (lua_State L, TValue oldstack) {	145	static void correctstack (lua_State L, TValue oldstack) {
143	CallInfo *ci;	146	CallInfo *ci;
144	GCObject *up;	147	UpVal *up;
145	L->top = (L->top - oldstack) + L->stack;	148	L->top = (L->top - oldstack) + L->stack;
146	for (up = L->openupval; up != NULL; up = up->gch.next)	149	for (up = L->openupval; up != NULL; up = up->u.open.next)
147	gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;	150	up->v = (up->v - oldstack) + L->stack;
148	for (ci = L->ci; ci != NULL; ci = ci->previous) {	151	for (ci = L->ci; ci != NULL; ci = ci->previous) {
149	ci->top = (ci->top - oldstack) + L->stack;	152	ci->top = (ci->top - oldstack) + L->stack;
150	ci->func = (ci->func - oldstack) + L->stack;	153	ci->func = (ci->func - oldstack) + L->stack;
@@ -206,7 +209,11 @@ void luaD_shrinkstack (lua_State *L) { · 55 unmodified lines
206	int inuse = stackinuse(L);	209	int inuse = stackinuse(L);
207	int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;	210	int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
208	if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK;	211	if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK;
209	if (inuse > LUAI_MAXSTACK \|\| /* handling stack overflow? */	212	if (L->stacksize > LUAI_MAXSTACK) /* was handling stack overflow? */
		213	luaE_freeCI(L); /* free all CIs (list grew because of an error) */
		214	else
		215	luaE_shrinkCI(L); /* shrink list */
		216	if (inuse > LUAI_MAXSTACK \|\| /* still handling stack overflow? */
210	goodsize >= L->stacksize) /* would grow instead of shrink? */	217	goodsize >= L->stacksize) /* would grow instead of shrink? */
211	condmovestack(L); /* don't change stack (change only for debugging) */	218	condmovestack(L); /* don't change stack (change only for debugging) */
212	else	219	else
@@ -534,6 +541,7 @@ static void resume (lua_State L, void ud) { · 321 unmodified lines
534		541
535	LUA_API int lua_resume (lua_State L, lua_State from, int nargs) {	542	LUA_API int lua_resume (lua_State L, lua_State from, int nargs) {
536	int status;	543	int status;
		544	int oldnny = L->nny; /* save 'nny' */
537	lua_lock(L);	545	lua_lock(L);
538	luai_userstateresume(L, nargs);	546	luai_userstateresume(L, nargs);
539	L->nCcalls = (from) ? from->nCcalls + 1 : 1;	547	L->nCcalls = (from) ? from->nCcalls + 1 : 1;
@@ -555,7 +563,7 @@ LUA_API int lua_resume (lua_State L, lua_State from, int nargs) { · 15 unmodified lines
555	}	563	}
556	lua_assert(status == L->status);	564	lua_assert(status == L->status);
557	}	565	}
558	L->nny = 1; /* do not allow yields */	566	L->nny = oldnny; /* restore 'nny' */
559	L->nCcalls--;	567	L->nCcalls--;
560	lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));	568	lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
561	lua_unlock(L);	569	lua_unlock(L);
@@ -637,7 +645,6 @@ static void checkmode (lua_State L, const char mode, const char *x) { · 75 unmodified lines
637		645
638		646
639	static void f_parser (lua_State L, void ud) {	647	static void f_parser (lua_State L, void ud) {
640	int i;
641	Closure *cl;	648	Closure *cl;
642	struct SParser p = cast(struct SParser , ud);	649	struct SParser p = cast(struct SParser , ud);
643	int c = zgetc(p->z); /* read first character */	650	int c = zgetc(p->z); /* read first character */
@@ -650,11 +657,7 @@ static void f_parser (lua_State L, void ud) { · 6 unmodified lines
650	cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);	657	cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
651	}	658	}
652	lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);	659	lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
653	for (i = 0; i < cl->l.nupvalues; i++) { /* initialize upvalues */	660	luaF_initupvals(L, &cl->l);
654	UpVal *up = luaF_newupval(L);
655	cl->l.upvals[i] = up;
656	luaC_objbarrier(L, cl, up);
657	}
658	}	661	}
659		662
660		663

src/ldump.c+154−133

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldump.c,v 2.19 2013/04/26 18:48:35 roberto Exp $	2	** $Id: ldump.c,v 2.27 2014/03/11 18:56:27 roberto Exp $
3	** save precompiled Lua chunks	3	** save precompiled Lua chunks
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -15,167 +15,188 @@ · 9 unmodified lines
15	#include "lstate.h"	15	#include "lstate.h"
16	#include "lundump.h"	16	#include "lundump.h"
17		17
		18
18	typedef struct {	19	typedef struct {
19	lua_State* L;	20	lua_State *L;
20	lua_Writer writer;	21	lua_Writer writer;
21	void* data;	22	void *data;
22	int strip;	23	int strip;
23	int status;	24	int status;
24	} DumpState;	25	} DumpState;
25		26
26	#define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D)	27
27	#define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D)	28	/*
28		29	** All high-level dumps go through DumpVector; you can change it to
29	static void DumpBlock(const void* b, size_t size, DumpState* D)	30	** change the endianess of the result
30	{	31	*/
31	if (D->status==0)	32	#define DumpVector(v,n,D) DumpBlock(v,(n)*sizeof((v)[0]),D)
32	{	33
33	lua_unlock(D->L);	34	#define DumpLiteral(s,D) DumpBlock(s, sizeof(s) - sizeof(char), D)
34	D->status=(*D->writer)(D->L,b,size,D->data);	35
35	lua_lock(D->L);	36
36	}	37	static void DumpBlock (const void b, size_t size, DumpState D) {
		38	if (D->status == 0) {
		39	lua_unlock(D->L);
		40	D->status = (*D->writer)(D->L, b, size, D->data);
		41	lua_lock(D->L);
		42	}
37	}	43	}
38		44
39	static void DumpChar(int y, DumpState* D)	45
40	{	46	#define DumpVar(x,D) DumpVector(&x,1,D)
41	char x=(char)y;	47
42	DumpVar(x,D);	48
		49	static void DumpByte (int y, DumpState *D) {
		50	lu_byte x = (lu_byte)y;
		51	DumpVar(x, D);
43	}	52	}
44		53
45	static void DumpInt(int x, DumpState* D)	54
46	{	55	static void DumpInt (int x, DumpState *D) {
47	DumpVar(x,D);	56	DumpVar(x, D);
48	}	57	}
49		58
50	static void DumpNumber(lua_Number x, DumpState* D)	59
51	{	60	static void DumpNumber (lua_Number x, DumpState *D) {
52	DumpVar(x,D);	61	DumpVar(x, D);
53	}	62	}
54		63
55	static void DumpInteger(lua_Integer x, DumpState* D)	64
56	{	65	static void DumpInteger (lua_Integer x, DumpState *D) {
57	DumpVar(x,D);	66	DumpVar(x, D);
58	}	67	}
59		68
60	static void DumpVector(const void* b, int n, size_t size, DumpState* D)	69
61	{	70	static void DumpString (const TString s, DumpState D) {
62	DumpInt(n,D);	71	if (s == NULL)
63	DumpMem(b,n,size,D);	72	DumpByte(0, D);
		73	else {
		74	size_t size = s->tsv.len + 1; /* include trailing '\0' */
		75	if (size < 0xFF)
		76	DumpByte(size, D);
		77	else {
		78	DumpByte(0xFF, D);
		79	DumpVar(size, D);
		80	}
		81	DumpVector(getstr(s), size - 1, D); /* no need to save '\0' */
		82	}
64	}	83	}
65		84
66	static void DumpString(const TString* s, DumpState* D)	85
67	{	86	static void DumpCode (const Proto f, DumpState D) {
68	if (s==NULL)	87	DumpInt(f->sizecode, D);
69	{	88	DumpVector(f->code, f->sizecode, D);
70	size_t size=0;
71	DumpVar(size,D);
72	}
73	else
74	{
75	size_t size=s->tsv.len+1; /* include trailing '\0' */
76	DumpVar(size,D);
77	DumpBlock(getstr(s),size*sizeof(char),D);
78	}
79	}	89	}
80		90
81	#define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D)	91
82		92	static void DumpFunction(const Proto f, DumpState D);
83	static void DumpFunction(const Proto* f, DumpState* D);	93
84		94	static void DumpConstants (const Proto f, DumpState D) {
85	static void DumpConstants(const Proto* f, DumpState* D)	95	int i;
86	{	96	int n = f->sizek;
87	int i,n=f->sizek;	97	DumpInt(n, D);
88	DumpInt(n,D);	98	for (i = 0; i < n; i++) {
89	for (i=0; i<n; i++)	99	const TValue *o = &f->k[i];
90	{	100	DumpByte(ttype(o), D);
91	const TValue* o=&f->k[i];	101	switch (ttype(o)) {
92	DumpChar(ttype(o),D);	102	case LUA_TNIL:
93	switch (ttype(o))	103	break;
94	{	104	case LUA_TBOOLEAN:
95	case LUA_TNIL:	105	DumpByte(bvalue(o), D);
96	break;	106	break;
97	case LUA_TBOOLEAN:	107	case LUA_TNUMFLT:
98	DumpChar(bvalue(o),D);	108	DumpNumber(fltvalue(o), D);
99	break;	109	break;
100	case LUA_TNUMFLT:	110	case LUA_TNUMINT:
101	DumpNumber(fltvalue(o),D);	111	DumpInteger(ivalue(o), D);
102	break;	112	break;
103	case LUA_TNUMINT:	113	case LUA_TSHRSTR:
104	DumpInteger(ivalue(o),D);	114	case LUA_TLNGSTR:
105	break;	115	DumpString(rawtsvalue(o), D);
106	case LUA_TSHRSTR: case LUA_TLNGSTR:	116	break;
107	DumpString(rawtsvalue(o),D);	117	default:
108	break;	118	lua_assert(0);
109	default: lua_assert(0);	119	}
110	}	120	}
111	}	121	n = f->sizep;
112	n=f->sizep;	122	DumpInt(n, D);
113	DumpInt(n,D);	123	for (i = 0; i < n; i++)
114	for (i=0; i<n; i++) DumpFunction(f->p[i],D);	124	DumpFunction(f->p[i], D);
115	}	125	}
116		126
117	static void DumpUpvalues(const Proto* f, DumpState* D)	127
118	{	128	static void DumpUpvalues (const Proto f, DumpState D) {
119	int i,n=f->sizeupvalues;	129	int i, n = f->sizeupvalues;
120	DumpInt(n,D);	130	DumpInt(n, D);
121	for (i=0; i<n; i++)	131	for (i = 0; i < n; i++) {
122	{	132	DumpByte(f->upvalues[i].instack, D);
123	DumpChar(f->upvalues[i].instack,D);	133	DumpByte(f->upvalues[i].idx, D);
124	DumpChar(f->upvalues[i].idx,D);	134	}
125	}
126	}	135	}
127		136
128	static void DumpDebug(const Proto* f, DumpState* D)	137
129	{	138	static void DumpDebug (const Proto f, DumpState D) {
130	int i,n;	139	int i, n;
131	DumpString((D->strip) ? NULL : f->source,D);	140	DumpString((D->strip) ? NULL : f->source, D);
132	n= (D->strip) ? 0 : f->sizelineinfo;	141	n = (D->strip) ? 0 : f->sizelineinfo;
133	DumpVector(f->lineinfo,n,sizeof(int),D);	142	DumpInt(n, D);
134	n= (D->strip) ? 0 : f->sizelocvars;	143	DumpVector(f->lineinfo, n, D);
135	DumpInt(n,D);	144	n = (D->strip) ? 0 : f->sizelocvars;
136	for (i=0; i<n; i++)	145	DumpInt(n, D);
137	{	146	for (i = 0; i < n; i++) {
138	DumpString(f->locvars[i].varname,D);	147	DumpString(f->locvars[i].varname, D);
139	DumpInt(f->locvars[i].startpc,D);	148	DumpInt(f->locvars[i].startpc, D);
140	DumpInt(f->locvars[i].endpc,D);	149	DumpInt(f->locvars[i].endpc, D);
141	}	150	}
142	n= (D->strip) ? 0 : f->sizeupvalues;	151	n = (D->strip) ? 0 : f->sizeupvalues;
143	DumpInt(n,D);	152	DumpInt(n, D);
144	for (i=0; i<n; i++) DumpString(f->upvalues[i].name,D);	153	for (i = 0; i < n; i++)
		154	DumpString(f->upvalues[i].name, D);
145	}	155	}
146		156
147	static void DumpFunction(const Proto* f, DumpState* D)	157
148	{	158	static void DumpFunction (const Proto f, DumpState D) {
149	DumpInt(f->linedefined,D);	159	DumpInt(f->linedefined, D);
150	DumpInt(f->lastlinedefined,D);	160	DumpInt(f->lastlinedefined, D);
151	DumpChar(f->numparams,D);	161	DumpByte(f->numparams, D);
152	DumpChar(f->is_vararg,D);	162	DumpByte(f->is_vararg, D);
153	DumpChar(f->maxstacksize,D);	163	DumpByte(f->maxstacksize, D);
154	DumpCode(f,D);	164	DumpCode(f, D);
155	DumpConstants(f,D);	165	DumpConstants(f, D);
156	DumpUpvalues(f,D);	166	DumpUpvalues(f, D);
157	DumpDebug(f,D);	167	DumpDebug(f, D);
158	}	168	}
159		169
160	static void DumpHeader(DumpState* D)	170
161	{	171	static void DumpHeader (DumpState *D) {
162	lu_byte h[LUAC_HEADERSIZE];	172	DumpLiteral(LUA_SIGNATURE, D);
163	luaU_header(h);	173	DumpByte(LUAC_VERSION, D);
164	DumpBlock(h,LUAC_HEADERSIZE,D);	174	DumpByte(LUAC_FORMAT, D);
		175	DumpLiteral(LUAC_DATA, D);
		176	DumpByte(sizeof(int), D);
		177	DumpByte(sizeof(size_t), D);
		178	DumpByte(sizeof(Instruction), D);
		179	DumpByte(sizeof(lua_Integer), D);
		180	DumpByte(sizeof(lua_Number), D);
		181	DumpInteger(LUAC_INT, D);
		182	DumpNumber(LUAC_NUM, D);
165	}	183	}
166		184
		185
167	/*	186	/*
168	** dump Lua function as precompiled chunk	187	** dump Lua function as precompiled chunk
169	*/	188	*/
170	int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)	189	int luaU_dump(lua_State L, const Proto f, lua_Writer w, void *data,
171	{	190	int strip) {
172	DumpState D;	191	DumpState D;
173	D.L=L;	192	D.L = L;
174	D.writer=w;	193	D.writer = w;
175	D.data=data;	194	D.data = data;
176	D.strip=strip;	195	D.strip = strip;
177	D.status=0;	196	D.status = 0;
178	DumpHeader(&D);	197	DumpHeader(&D);
179	DumpFunction(f,&D);	198	DumpByte(f->sizeupvalues, &D);
180	return D.status;	199	DumpFunction(f, &D);
		200	return D.status;
181	}	201	}
		202

src/lfunc.c+39−54

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lfunc.c,v 2.30 2012/10/03 12:36:46 roberto Exp $	2	** $Id: lfunc.c,v 2.41 2014/02/18 13:39:37 roberto Exp $
3	** Auxiliary functions to manipulate prototypes and closures	3	** Auxiliary functions to manipulate prototypes and closures
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -21,94 +21,79 @@ · 15 unmodified lines
21		21
22		22
23	Closure luaF_newCclosure (lua_State L, int n) {	23	Closure luaF_newCclosure (lua_State L, int n) {
24	Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n), NULL, 0)->cl;	24	Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n))->cl;
25	c->c.nupvalues = cast_byte(n);	25	c->c.nupvalues = cast_byte(n);
26	return c;	26	return c;
27	}	27	}
28		28
29		29
30	Closure luaF_newLclosure (lua_State L, int n) {	30	Closure luaF_newLclosure (lua_State L, int n) {
31	Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl;	31	Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n))->cl;
32	c->l.p = NULL;	32	c->l.p = NULL;
33	c->l.nupvalues = cast_byte(n);	33	c->l.nupvalues = cast_byte(n);
34	while (n--) c->l.upvals[n] = NULL;	34	while (n--) c->l.upvals[n] = NULL;
35	return c;	35	return c;
36	}	36	}
37		37
38		38	/*
39	UpVal luaF_newupval (lua_State L) {	39	** fill a closure with new closed upvalues
40	UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;	40	*/
41	uv->v = &uv->u.value;	41	void luaF_initupvals (lua_State L, LClosure cl) {
42	setnilvalue(uv->v);	42	int i;
43	return uv;	43	for (i = 0; i < cl->nupvalues; i++) {
		44	UpVal *uv = luaM_new(L, UpVal);
		45	uv->refcount = 1;
		46	uv->v = &uv->u.value; /* make it closed */
		47	setnilvalue(uv->v);
		48	cl->upvals[i] = uv;
		49	}
44	}	50	}
45		51
46		52
47	UpVal luaF_findupval (lua_State L, StkId level) {	53	UpVal luaF_findupval (lua_State L, StkId level) {
48	global_State *g = G(L);	54	UpVal **pp = &L->openupval;
49	GCObject **pp = &L->openupval;
50	UpVal *p;	55	UpVal *p;
51	UpVal *uv;	56	UpVal *uv;
52	while (pp != NULL && (p = gco2uv(pp))->v >= level) {	57	lua_assert(isintwups(L) \|\| L->openupval == NULL);
53	GCObject *o = obj2gco(p);	58	while (pp != NULL && (p = pp)->v >= level) {
54	lua_assert(p->v != &p->u.value);	59	lua_assert(upisopen(p));
55	lua_assert(!isold(o) \|\| isold(obj2gco(L)));	60	if (p->v == level) /* found a corresponding upvalue? */
56	if (p->v == level) { /* found a corresponding upvalue? */	61	return p; /* return it */
57	if (isdead(g, o)) /* is it dead? */	62	pp = &p->u.open.next;
58	changewhite(o); /* resurrect it */
59	return p;
60	}
61	pp = &p->next;
62	}	63	}
63	/* not found: create a new one */	64	/* not found: create a new upvalue */
64	uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv;	65	uv = luaM_new(L, UpVal);
		66	uv->refcount = 0;
		67	uv->u.open.next = pp; / link it to list of open upvalues */
		68	uv->u.open.touched = 1;
		69	*pp = uv;
65	uv->v = level; /* current value lives in the stack */	70	uv->v = level; /* current value lives in the stack */
66	uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */	71	if (!isintwups(L)) { /* thread not in list of threads with upvalues? */
67	uv->u.l.next = g->uvhead.u.l.next;	72	L->twups = G(L)->twups; /* link it to the list */
68	uv->u.l.next->u.l.prev = uv;	73	G(L)->twups = L;
69	g->uvhead.u.l.next = uv;	74	}
70	lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
71	return uv;	75	return uv;
72	}	76	}
73		77
74		78
75	static void unlinkupval (UpVal *uv) {
76	lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
77	uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */
78	uv->u.l.prev->u.l.next = uv->u.l.next;
79	}
80
81
82	void luaF_freeupval (lua_State L, UpVal uv) {
83	if (uv->v != &uv->u.value) /* is it open? */
84	unlinkupval(uv); /* remove from open list */
85	luaM_free(L, uv); /* free upvalue */
86	}
87
88
89	void luaF_close (lua_State *L, StkId level) {	79	void luaF_close (lua_State *L, StkId level) {
90	UpVal *uv;	80	UpVal *uv;
91	global_State *g = G(L);	81	while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
92	while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) {	82	lua_assert(upisopen(uv));
93	GCObject *o = obj2gco(uv);	83	L->openupval = uv->u.open.next; /* remove from `open' list */
94	lua_assert(!isblack(o) && uv->v != &uv->u.value);	84	if (uv->refcount == 0) /* no references? */
95	L->openupval = uv->next; /* remove from `open' list */	85	luaM_free(L, uv); /* free upvalue */
96	if (isdead(g, o))
97	luaF_freeupval(L, uv); /* free upvalue */
98	else {	86	else {
99	unlinkupval(uv); /* remove upvalue from 'uvhead' list */
100	setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */	87	setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */
101	uv->v = &uv->u.value; /* now current value lives here */	88	uv->v = &uv->u.value; /* now current value lives here */
102	gch(o)->next = g->allgc; /* link upvalue into 'allgc' list */	89	luaC_upvalbarrier(L, uv);
103	g->allgc = o;
104	luaC_checkupvalcolor(g, uv);
105	}	90	}
106	}	91	}
107	}	92	}
108		93
109		94
110	Proto luaF_newproto (lua_State L) {	95	Proto luaF_newproto (lua_State L) {
111	Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto), NULL, 0)->p;	96	Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto))->p;
112	f->k = NULL;	97	f->k = NULL;
113	f->sizek = 0;	98	f->sizek = 0;
114	f->p = NULL;	99	f->p = NULL;

src/lfunc.h+24−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lfunc.h,v 2.8 2012/05/08 13:53:33 roberto Exp $	2	** $Id: lfunc.h,v 2.13 2014/02/18 13:39:37 roberto Exp $
3	** Auxiliary functions to manipulate prototypes and closures	3	** Auxiliary functions to manipulate prototypes and closures
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -18,14 +18,35 @@ · 12 unmodified lines
18	cast(int, sizeof(TValue )((n)-1)))	18	cast(int, sizeof(TValue )((n)-1)))
19		19
20		20
		21	/* test whether thread is in 'twups' list */
		22	#define isintwups(L) (L->twups != L)
		23
		24
		25	/*
		26	** Upvalues for Lua closures
		27	*/
		28	struct UpVal {
		29	TValue v; / points to stack or to its own value */
		30	lu_mem refcount; /* reference counter */
		31	union {
		32	struct { /* (when open) */
		33	UpVal next; / linked list */
		34	int touched; /* mark to avoid cycles with dead threads */
		35	} open;
		36	TValue value; /* the value (when closed) */
		37	} u;
		38	};
		39
		40	#define upisopen(up) ((up)->v != &(up)->u.value)
		41
		42
21	LUAI_FUNC Proto luaF_newproto (lua_State L);	43	LUAI_FUNC Proto luaF_newproto (lua_State L);
22	LUAI_FUNC Closure luaF_newCclosure (lua_State L, int nelems);	44	LUAI_FUNC Closure luaF_newCclosure (lua_State L, int nelems);
23	LUAI_FUNC Closure luaF_newLclosure (lua_State L, int nelems);	45	LUAI_FUNC Closure luaF_newLclosure (lua_State L, int nelems);
24	LUAI_FUNC UpVal luaF_newupval (lua_State L);	46	LUAI_FUNC void luaF_initupvals (lua_State L, LClosure cl);
25	LUAI_FUNC UpVal luaF_findupval (lua_State L, StkId level);	47	LUAI_FUNC UpVal luaF_findupval (lua_State L, StkId level);
26	LUAI_FUNC void luaF_close (lua_State *L, StkId level);	48	LUAI_FUNC void luaF_close (lua_State *L, StkId level);
27	LUAI_FUNC void luaF_freeproto (lua_State L, Proto f);	49	LUAI_FUNC void luaF_freeproto (lua_State L, Proto f);
28	LUAI_FUNC void luaF_freeupval (lua_State L, UpVal uv);
29	LUAI_FUNC const char luaF_getlocalname (const Proto func, int local_number,	50	LUAI_FUNC const char luaF_getlocalname (const Proto func, int local_number,
30	int pc);	51	int pc);
31		52

src/lgc.c+287−336

 /*
-** $Id: lgc.c,v 2.141 2013/04/26 18:26:49 roberto Exp $
+** $Id: lgc.c,v 2.179 2014/03/21 13:52:33 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 #include "ltm.h"
+/*
+** internal state for collector while inside the atomic phase. The
+** collector should never be in this state while running regular code.
+*/
+#define GCSinsideatomic		(GCSpause + 1)
 /*
 ** cost of sweeping one element (the size of a small object divided
 /* maximum number of elements to sweep in each single step */
 #define GCSWEEPMAX	(cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))
-/* maximum number of finalizers to call in each GC step */
+/* cost of calling one finalizer */
-#define GCFINALIZENUM	4
+#define GCFINALIZECOST	GCSWEEPCOST
 /*
 /*
-** 'makewhite' erases all color bits plus the old bit and then
+** 'makewhite' erases all color bits then sets only the current white
-** sets only the current white bit
+** bit
 */
-#define maskcolors	(~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS))
+#define maskcolors	(~(bitmask(BLACKBIT) | WHITEBITS))
 #define makewhite(g,x)	\
  (gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g)))
 #define black2gray(x)	resetbit(gch(x)->marked, BLACKBIT)
-#define isfinalized(x)		testbit(gch(x)->marked, FINALIZEDBIT)
+#define valiswhite(x)   (iscollectable(x) && iswhite(gcvalue(x)))
 #define checkdeadkey(n)	lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n)))
 #define markvalue(g,o) { checkconsistency(o); \
   if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
-#define markobject(g,t) { if ((t) && iswhite(obj2gco(t))) \
+#define markobject(g,t) \
-		reallymarkobject(g, obj2gco(t)); }
+  { if ((t) && iswhite(obj2gco(t))) reallymarkobject(g, obj2gco(t)); }
 static void reallymarkobject (global_State *g, GCObject *o);
   global_State *g = G(L);
   lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
   lua_assert(g->gcstate != GCSpause);
-  lua_assert(gch(o)->tt != LUA_TTABLE);
+  lua_assert(gch(o)->tt != LUA_TTABLE);  /* tables use a back barrier */
-  if (keepinvariantout(g))  /* must keep invariant? */
+  if (keepinvariant(g))  /* must keep invariant? */
     reallymarkobject(g, v);  /* restore invariant */
   else {  /* sweep phase */
     lua_assert(issweepphase(g));
 /*
-** barrier for prototypes. When creating first closure (cache is
+** barrier for assignments to closed upvalues. Because upvalues are
-** NULL), use a forward barrier; this may be the only closure of the
+** shared among closures, it is impossible to know the color of all
-** prototype (if it is a "regular" function, with a single instance)
+** closures pointing to it. So, we assume that the object being assigned
-** and the prototype may be big, so it is better to avoid traversing
+** must be marked.
-** it again. Otherwise, use a backward barrier, to avoid marking all
-** possible instances.
 */
-LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c) {
+LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
   global_State *g = G(L);
-  lua_assert(isblack(obj2gco(p)));
+  GCObject *o = gcvalue(uv->v);
-  if (p->cache == NULL) {  /* first time? */
+  lua_assert(!upisopen(uv));  /* ensured by macro luaC_upvalbarrier */
-    luaC_objbarrier(L, p, c);
+  if (keepinvariant(g))
-  }
+    markobject(g, o);
-  else {  /* use a backward barrier */
-    black2gray(obj2gco(p));  /* make prototype gray (again) */
-    p->gclist = g->grayagain;
-    g->grayagain = obj2gco(p);
-  }
 }
-/*
+void luaC_fix (lua_State *L, GCObject *o) {
-** check color (and invariants) for an upvalue that was closed,
+  global_State *g = G(L);
-** i.e., moved into the 'allgc' list
+  lua_assert(g->allgc == o);  /* object must be 1st in 'allgc' list! */
-*/
+  white2gray(o);  /* they will be gray forever */
-void luaC_checkupvalcolor (global_State *g, UpVal *uv) {
+  g->allgc = o->gch.next;  /* remove object from 'allgc' list */
-  GCObject *o = obj2gco(uv);
+  o->gch.next = g->fixedgc;  /* link it to 'fixedgc' list */
-  lua_assert(!isblack(o));  /* open upvalues are never black */
+  g->fixedgc = o;
-  if (isgray(o)) {
-    if (keepinvariant(g)) {
-      resetoldbit(o);  /* see MOVE OLD rule */
-      gray2black(o);  /* it is being visited now */
-      markvalue(g, uv->v);
-    }
-    else {
-      lua_assert(issweepphase(g));
-      makewhite(g, o);
-    }
-  }
 }
 /*
 ** create a new collectable object (with given type and size) and link
-** it to '*list'. 'offset' tells how many bytes to allocate before the
+** it to 'allgc' list.
-** object itself (used only by states).
 */
-GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, GCObject **list,
+GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
-                       int offset) {
   global_State *g = G(L);
-  char *raw = cast(char *, luaM_newobject(L, novariant(tt), sz));
+  GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
-  GCObject *o = obj2gco(raw + offset);
-  if (list == NULL)
-    list = &g->allgc;  /* standard list for collectable objects */
   gch(o)->marked = luaC_white(g);
   gch(o)->tt = tt;
-  gch(o)->next = *list;
+  gch(o)->next = g->allgc;
-  *list = o;
+  g->allgc = o;
   return o;
 }
 ** upvalues are already linked in 'headuv' list.)
 */
 static void reallymarkobject (global_State *g, GCObject *o) {
-  lu_mem size;
+ reentry:
   white2gray(o);
   switch (gch(o)->tt) {
     case LUA_TSHRSTR:
     case LUA_TLNGSTR: {
-      size = sizestring(gco2ts(o));
+      gray2black(o);
-      break;  /* nothing else to mark; make it black */
+      g->GCmemtrav += sizestring(gco2ts(o));
-    }
-    case LUA_TUSERDATA: {
-      Table *mt = gco2u(o)->metatable;
-      markobject(g, mt);
-      markobject(g, gco2u(o)->env);
-      size = sizeudata(gco2u(o));
       break;
     }
-    case LUA_TUPVAL: {
+    case LUA_TUSERDATA: {
-      UpVal *uv = gco2uv(o);
+      TValue uvalue;
-      markvalue(g, uv->v);
+      markobject(g, gco2u(o)->metatable);  /* mark its metatable */
-      if (uv->v != &uv->u.value)  /* open? */
+      gray2black(o);
-        return;  /* open upvalues remain gray */
+      g->GCmemtrav += sizeudata(gco2u(o));
-      size = sizeof(UpVal);
+      getuservalue(g->mainthread, rawgco2u(o), &uvalue);
+      if (valiswhite(&uvalue)) {  /* markvalue(g, &uvalue); */
+        o = gcvalue(&uvalue);
+        goto reentry;
+      }
       break;
     }
     case LUA_TLCL: {
       gco2lcl(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
     case LUA_TCCL: {
       gco2ccl(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
     case LUA_TTABLE: {
       linktable(gco2t(o), &g->gray);
-      return;
+      break;
     }
     case LUA_TTHREAD: {
       gco2th(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
     case LUA_TPROTO: {
       gco2p(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
-    default: lua_assert(0); return;
+    default: lua_assert(0); break;
   }
-  gray2black(o);
-  g->GCmemtrav += size;
 }
 */
 static void markbeingfnz (global_State *g) {
   GCObject *o;
-  for (o = g->tobefnz; o != NULL; o = gch(o)->next) {
+  for (o = g->tobefnz; o != NULL; o = gch(o)->next)
-    makewhite(g, o);
+    markobject(g, o);
-    reallymarkobject(g, o);
-  }
 }
 /*
-** mark all values stored in marked open upvalues. (See comment in
+** Mark all values stored in marked open upvalues from non-marked threads.
-** 'lstate.h'.)
+** (Values from marked threads were already marked when traversing the
+** thread.) Remove from the list threads that no longer have upvalues and
+** not-marked threads.
 */
 static void remarkupvals (global_State *g) {
-  UpVal *uv;
+  lua_State *thread;
-  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
+  lua_State **p = &g->twups;
-    if (isgray(obj2gco(uv)))
+  while ((thread = *p) != NULL) {
-      markvalue(g, uv->v);
+    lua_assert(!isblack(obj2gco(thread)));  /* threads are never black */
+    if (isgray(obj2gco(thread)) && thread->openupval != NULL)
+      p = &thread->twups;  /* keep marked thread with upvalues in the list */
+    else {  /* thread is not marked or without upvalues */
+      UpVal *uv;
+      *p = thread->twups;  /* remove thread from the list */
+      thread->twups = thread;  /* mark that it is out of list */
+      for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) {
+        if (uv->u.open.touched) {
+          markvalue(g, uv->v);  /* remark upvalue's value */
+          uv->u.open.touched = 0;
+        }
+      }
+    }
   }
 }
 /*
-** mark root set and reset all gray lists, to start a new
+** mark root set and reset all gray lists, to start a new collection
-** incremental (or full) collection
 */
 static void restartcollection (global_State *g) {
   g->gray = g->grayagain = NULL;
   return sizeCclosure(cl->nupvalues);
 }
+/*
+** open upvalues point to values in a thread, so those values should
+** be marked when the thread is traversed except in the atomic phase
+** (because then the value cannot be changed by the thread and the
+** thread may not be traversed again)
+*/
 static lu_mem traverseLclosure (global_State *g, LClosure *cl) {
   int i;
   markobject(g, cl->p);  /* mark its prototype */
-  for (i = 0; i < cl->nupvalues; i++)  /* mark its upvalues */
+  for (i = 0; i < cl->nupvalues; i++) {  /* mark its upvalues */
-    markobject(g, cl->upvals[i]);
+    UpVal *uv = cl->upvals[i];
+    if (uv != NULL) {
+      if (upisopen(uv) && g->gcstate != GCSinsideatomic)
+        uv->u.open.touched = 1;  /* can be marked in 'remarkupvals' */
+      else
+        markvalue(g, uv->v);
+    }
+  }
   return sizeLclosure(cl->nupvalues);
 }
   StkId o = th->stack;
   if (o == NULL)
     return 1;  /* stack not completely built yet */
+  lua_assert(g->gcstate == GCSinsideatomic ||
+             th->openupval == NULL || isintwups(th));
   for (; o < th->top; o++)  /* mark live elements in the stack */
     markvalue(g, o);
-  if (g->gcstate == GCSatomic) {  /* final traversal? */
+  if (g->gcstate == GCSinsideatomic) {  /* final traversal? */
     StkId lim = th->stack + th->stacksize;  /* real end of stack */
     for (; o < lim; o++)  /* clear not-marked stack slice */
       setnilvalue(o);
+    /* 'remarkupvals' may have removed thread from 'twups' list */
+    if (!isintwups(th) && th->openupval != NULL) {
+      th->twups = g->twups;  /* link it back to the list */
+      g->twups = th;
+    }
   }
-  else {  /* count call infos to compute size */
+  else {
     CallInfo *ci;
     for (ci = &th->base_ci; ci != th->ci; ci = ci->next)
-      n++;
+      n++;  /* count call infos to compute size */
+    /* should not change the stack during an emergency gc cycle */
+    if (g->gckind != KGC_EMERGENCY)
+      luaD_shrinkstack(th);
   }
   return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
          sizeof(CallInfo) * n;
 }
+void luaC_upvdeccount (lua_State *L, UpVal *uv) {
+  lua_assert(uv->refcount > 0);
+  uv->refcount--;
+  if (uv->refcount == 0 && !upisopen(uv))
+    luaM_free(L, uv);
+}
+static void freeLclosure (lua_State *L, LClosure *cl) {
+  int i;
+  for (i = 0; i < cl->nupvalues; i++) {
+    UpVal *uv = cl->upvals[i];
+    if (uv)
+      luaC_upvdeccount(L, uv);
+  }
+  luaM_freemem(L, cl, sizeLclosure(cl->nupvalues));
+}
 static void freeobj (lua_State *L, GCObject *o) {
   switch (gch(o)->tt) {
     case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
     case LUA_TLCL: {
-      luaM_freemem(L, o, sizeLclosure(gco2lcl(o)->nupvalues));
+      freeLclosure(L, gco2lcl(o));
       break;
     }
     case LUA_TCCL: {
       luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues));
       break;
     }
-    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
     case LUA_TTABLE: luaH_free(L, gco2t(o)); break;
     case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break;
     case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break;
     case LUA_TSHRSTR:
-      G(L)->strt.nuse--;
+      luaS_remove(L, rawgco2ts(o));  /* remove it from hash table */
       /* go through */
     case LUA_TLNGSTR: {
       luaM_freemem(L, o, sizestring(gco2ts(o)));
 static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count);
-/*
-** sweep the (open) upvalues of a thread and resize its stack and
-** list of call-info structures.
-*/
-static void sweepthread (lua_State *L, lua_State *L1) {
-  if (L1->stack == NULL) return;  /* stack not completely built yet */
-  sweepwholelist(L, &L1->openupval);  /* sweep open upvalues */
-  luaE_freeCI(L1);  /* free extra CallInfo slots */
-  /* should not change the stack during an emergency gc cycle */
-  if (G(L)->gckind != KGC_EMERGENCY)
-    luaD_shrinkstack(L1);
-}
 /*
 ** sweep at most 'count' elements from a list of GCObjects erasing dead
 ** objects, where a dead (not alive) object is one marked with the "old"
-** (non current) white and not fixed.
+** (non current) white and not fixed; change all non-dead objects back
-** In non-generational mode, change all non-dead objects back to white,
+** to white, preparing for next collection cycle.
-** preparing for next collection cycle.
-** In generational mode, keep black objects black, and also mark them as
-** old; stop when hitting an old object, as all objects after that
-** one will be old too.
 ** When object is a thread, sweep its list of open upvalues too.
 */
 static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
   global_State *g = G(L);
   int ow = otherwhite(g);
-  int toclear, toset;  /* bits to clear and to set in all live objects */
+  int white = luaC_white(g);  /* current white */
-  int tostop;  /* stop sweep when this is true */
-  if (isgenerational(g)) {  /* generational mode? */
-    toclear = ~0;  /* clear nothing */
-    toset = bitmask(OLDBIT);  /* set the old bit of all surviving objects */
-    tostop = bitmask(OLDBIT);  /* do not sweep old generation */
-  }
-  else {  /* normal mode */
-    toclear = maskcolors;  /* clear all color bits + old bit */
-    toset = luaC_white(g);  /* make object white */
-    tostop = 0;  /* do not stop */
-  }
   while (*p != NULL && count-- > 0) {
     GCObject *curr = *p;
     int marked = gch(curr)->marked;
       *p = gch(curr)->next;  /* remove 'curr' from list */
       freeobj(L, curr);  /* erase 'curr' */
     }
-    else {
+    else {  /* update marks */
-      if (testbits(marked, tostop))
+      gch(curr)->marked = cast_byte((marked & maskcolors) | white);
-        return NULL;  /* stop sweeping this list */
-      if (gch(curr)->tt == LUA_TTHREAD)
-        sweepthread(L, gco2th(curr));  /* sweep thread's upvalues */
-      /* update marks */
-      gch(curr)->marked = cast_byte((marked & toclear) | toset);
       p = &gch(curr)->next;  /* go to next element */
     }
   }
 ** sweep a list until a live object (or end of list)
 */
 static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) {
-  GCObject ** old = p;
+  GCObject **old = p;
   int i = 0;
   do {
     i++;
 ** =======================================================
 */
-static void checkSizes (lua_State *L) {
+/*
-  global_State *g = G(L);
+** If possible, free concatenation buffer and shrink string table
-  if (g->gckind != KGC_EMERGENCY) {  /* do not change sizes in emergency */
+*/
-    int hs = g->strt.size / 2;  /* half the size of the string table */
+static void checkSizes (lua_State *L, global_State *g) {
-    if (g->strt.nuse < cast(lu_int32, hs))  /* using less than that half? */
+  if (g->gckind != KGC_EMERGENCY) {
-      luaS_resize(L, hs);  /* halve its size */
     luaZ_freebuffer(L, &g->buff);  /* free concatenation buffer */
+    if (g->strt.nuse < g->strt.size / 4)  /* string table too big? */
+      luaS_resize(L, g->strt.size / 2);  /* shrink it a little */
   }
 }
 static GCObject *udata2finalize (global_State *g) {
   GCObject *o = g->tobefnz;  /* get first element */
-  lua_assert(isfinalized(o));
+  lua_assert(tofinalize(o));
   g->tobefnz = gch(o)->next;  /* remove it from 'tobefnz' list */
   gch(o)->next = g->allgc;  /* return it to 'allgc' list */
   g->allgc = o;
-  resetbit(gch(o)->marked, SEPARATED);  /* mark that it is not in 'tobefnz' */
+  resetbit(gch(o)->marked, FINALIZEDBIT);  /* object is "normal" again */
-  lua_assert(!isold(o));  /* see MOVE OLD rule */
+  if (issweepphase(g))
-  if (!keepinvariantout(g))  /* not keeping invariant? */
     makewhite(g, o);  /* "sweep" object */
   return o;
 }
 /*
-** move all unreachable objects (or 'all' objects) that need
+** call all pending finalizers
-** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
 */
-static void separatetobefnz (lua_State *L, int all) {
+static void callallpendingfinalizers (lua_State *L, int propagateerrors) {
   global_State *g = G(L);
-  GCObject **p = &g->finobj;
+  while (g->tobefnz)
+    GCTM(L, propagateerrors);
+}
+/*
+** find last 'next' field in list 'p' list (to add elements in its end)
+*/
+static GCObject **findlast (GCObject **p) {
+  while (*p != NULL)
+    p = &gch(*p)->next;
+  return p;
+}
+/*
+** move all unreachable objects (or 'all' objects) that need
+** finalization from list 'p' to list 'tobefnz' (to be finalized)
+*/
+static void separatetobefnz (global_State *g, int all) {
   GCObject *curr;
-  GCObject **lastnext = &g->tobefnz;
+  GCObject **p = &g->finobj;
-  /* find last 'next' field in 'tobefnz' list (to add elements in its end) */
+  GCObject **lastnext = findlast(&g->tobefnz);
-  while (*lastnext != NULL)
-    lastnext = &gch(*lastnext)->next;
   while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
-    lua_assert(!isfinalized(curr));
+    lua_assert(tofinalize(curr));
-    lua_assert(testbit(gch(curr)->marked, SEPARATED));
     if (!(iswhite(curr) || all))  /* not being collected? */
       p = &gch(curr)->next;  /* don't bother with it */
     else {
-      l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */
+      *p = gch(curr)->next;  /* remove 'curr' from "fin" list */
-      *p = gch(curr)->next;  /* remove 'curr' from 'finobj' list */
       gch(curr)->next = *lastnext;  /* link at the end of 'tobefnz' list */
       *lastnext = curr;
       lastnext = &gch(curr)->next;
 */
 void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
   global_State *g = G(L);
-  if (testbit(gch(o)->marked, SEPARATED) || /* obj. is already separated... */
+  if (tofinalize(o) ||                 /* obj. is already marked... */
-      isfinalized(o) ||                           /* ... or is finalized... */
+      gfasttm(g, mt, TM_GC) == NULL)   /* or has no finalizer? */
-      gfasttm(g, mt, TM_GC) == NULL)                /* or has no finalizer? */
     return;  /* nothing to be done */
   else {  /* move 'o' to 'finobj' list */
     GCObject **p;
-    GCheader *ho = gch(o);
+    if (g->sweepgc == &o->gch.next) {  /* avoid removing current sweep object */
-    if (g->sweepgc == &ho->next) {  /* avoid removing current sweep object */
       lua_assert(issweepphase(g));
       g->sweepgc = sweeptolive(L, g->sweepgc, NULL);
     }
     /* search for pointer pointing to 'o' */
     for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ }
-    *p = ho->next;  /* remove 'o' from root list */
+    *p = o->gch.next;  /* remove 'o' from its list */
-    ho->next = g->finobj;  /* link it in list 'finobj' */
+    o->gch.next = g->finobj;  /* link it in "fin" list */
     g->finobj = o;
-    l_setbit(ho->marked, SEPARATED);  /* mark it as such */
+    l_setbit(o->gch.marked, FINALIZEDBIT);  /* mark it as such */
-    if (!keepinvariantout(g))  /* not keeping invariant? */
+    if (issweepphase(g))
       makewhite(g, o);  /* "sweep" object */
-    else
-      resetoldbit(o);  /* see MOVE OLD rule */
   }
 }
 /* }====================================================== */
 /*
 ** {======================================================
 ** GC control
 ** cycle will start when memory use hits threshold
 */
 static void setpause (global_State *g, l_mem estimate) {
-  l_mem debt, threshold;
+  l_mem threshold, debt;
   estimate = estimate / PAUSEADJ;  /* adjust 'estimate' */
   threshold = (g->gcpause < MAX_LMEM / estimate)  /* overflow? */
             ? estimate * g->gcpause  /* no overflow */
             : MAX_LMEM;  /* overflow; truncate to maximum */
-  debt = -cast(l_mem, threshold - gettotalbytes(g));
+  debt = gettotalbytes(g) - threshold;
   luaE_setdebt(g, debt);
 }
-#define sweepphases  \
-	(bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep))
 /*
-** enter first sweep phase (strings) and prepare pointers for other
+** Enter first sweep phase.
-** sweep phases.  The calls to 'sweeptolive' make pointers point to an
+** The call to 'sweeptolive' makes pointer point to an object inside
-** object inside the list (instead of to the header), so that the real
+** the list (instead of to the header), so that the real sweep do not
-** sweep do not need to skip objects created between "now" and the start
+** need to skip objects created between "now" and the start of the real
-** of the real sweep.
+** sweep.
 ** Returns how many objects it swept.
 */
 static int entersweep (lua_State *L) {
   global_State *g = G(L);
   int n = 0;
-  g->gcstate = GCSsweepstring;
+  g->gcstate = GCSswpallgc;
-  lua_assert(g->sweepgc == NULL && g->sweepfin == NULL);
+  lua_assert(g->sweepgc == NULL);
-  /* prepare to sweep strings, finalizable objects, and regular objects */
-  g->sweepstrgc = 0;
-  g->sweepfin = sweeptolive(L, &g->finobj, &n);
   g->sweepgc = sweeptolive(L, &g->allgc, &n);
   return n;
 }
-/*
-** change GC mode
-*/
-void luaC_changemode (lua_State *L, int mode) {
-  global_State *g = G(L);
-  if (mode == g->gckind) return;  /* nothing to change */
-  if (mode == KGC_GEN) {  /* change to generational mode */
-    /* make sure gray lists are consistent */
-    luaC_runtilstate(L, bitmask(GCSpropagate));
-    g->GCestimate = gettotalbytes(g);
-    g->gckind = KGC_GEN;
-  }
-  else {  /* change to incremental mode */
-    /* sweep all objects to turn them back to white
-       (as white has not changed, nothing extra will be collected) */
-    g->gckind = KGC_NORMAL;
-    entersweep(L);
-    luaC_runtilstate(L, ~sweepphases);
-  }
-}
-/*
-** call all pending finalizers
-*/
-static void callallpendingfinalizers (lua_State *L, int propagateerrors) {
-  global_State *g = G(L);
-  while (g->tobefnz) {
-    resetoldbit(g->tobefnz);
-    GCTM(L, propagateerrors);
-  }
-}
 void luaC_freeallobjects (lua_State *L) {
   global_State *g = G(L);
-  int i;
+  separatetobefnz(g, 1);  /* separate all objects with finalizers */
-  separatetobefnz(L, 1);  /* separate all objects with finalizers */
   lua_assert(g->finobj == NULL);
   callallpendingfinalizers(L, 0);
+  lua_assert(g->tobefnz == NULL);
   g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
   g->gckind = KGC_NORMAL;
-  sweepwholelist(L, &g->finobj);  /* finalizers can create objs. in 'finobj' */
+  sweepwholelist(L, &g->finobj);
   sweepwholelist(L, &g->allgc);
-  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
+  sweepwholelist(L, &g->fixedgc);  /* collect fixed objects */
-    sweepwholelist(L, &g->strt.hash[i]);
   lua_assert(g->strt.nuse == 0);
 }
   l_mem work = -cast(l_mem, g->GCmemtrav);  /* start counting work */
   GCObject *origweak, *origall;
   lua_assert(!iswhite(obj2gco(g->mainthread)));
+  g->gcstate = GCSinsideatomic;
   markobject(g, L);  /* mark running thread */
   /* registry and global metatables may be changed by API */
   markvalue(g, &g->l_registry);
   work -= g->GCmemtrav;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all strongly accessible objects are marked. */
-  /* clear values from weak tables, before checking finalizers */
+  /* Clear values from weak tables, before checking finalizers */
   clearvalues(g, g->weak, NULL);
   clearvalues(g, g->allweak, NULL);
   origweak = g->weak; origall = g->allweak;
   work += g->GCmemtrav;  /* stop counting (objects being finalized) */
-  separatetobefnz(L, 0);  /* separate objects to be finalized */
+  separatetobefnz(g, 0);  /* separate objects to be finalized */
+  g->gcfinnum = 1;  /* there may be objects to be finalized */
   markbeingfnz(g);  /* mark objects that will be finalized */
-  propagateall(g);  /* remark, to propagate `preserveness' */
+  propagateall(g);  /* remark, to propagate 'resurrection' */
   work -= g->GCmemtrav;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all resurrected objects are marked. */
 }
+static lu_mem sweepstep (lua_State *L, global_State *g,
+                         int nextstate, GCObject **nextlist) {
+  if (g->sweepgc) {
+    g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+    if (g->sweepgc)  /* is there still something to sweep? */
+      return (GCSWEEPMAX * GCSWEEPCOST);
+  }
+  /* else enter next state */
+  g->gcstate = nextstate;
+  g->sweepgc = nextlist;
+  return 0;
+}
 static lu_mem singlestep (lua_State *L) {
   global_State *g = G(L);
   switch (g->gcstate) {
     case GCSpause: {
       /* start to count memory traversed */
       g->GCmemtrav = g->strt.size * sizeof(GCObject*);
-      lua_assert(!isgenerational(g));
       restartcollection(g);
       g->gcstate = GCSpropagate;
       return g->GCmemtrav;
     }
     case GCSpropagate: {
-      if (g->gray) {
+      lu_mem oldtrav = g->GCmemtrav;
-        lu_mem oldtrav = g->GCmemtrav;
+      lua_assert(g->gray);
-        propagatemark(g);
+      propagatemark(g);
-        return g->GCmemtrav - oldtrav;  /* memory traversed in this step */
+       if (g->gray == NULL)  /* no more `gray' objects? */
-      }
+        g->gcstate = GCSatomic;  /* finish propagate phase */
-      else {  /* no more `gray' objects */
+      return g->GCmemtrav - oldtrav;  /* memory traversed in this step */
-        lu_mem work;
-        int sw;
-        g->gcstate = GCSatomic;  /* finish mark phase */
-        g->GCestimate = g->GCmemtrav;  /* save what was counted */;
-        work = atomic(L);  /* add what was traversed by 'atomic' */
-        g->GCestimate += work;  /* estimate of total memory traversed */
-        sw = entersweep(L);
-        return work + sw * GCSWEEPCOST;
-      }
     }
-    case GCSsweepstring: {
+    case GCSatomic: {
-      int i;
+      lu_mem work;
-      for (i = 0; i < GCSWEEPMAX && g->sweepstrgc + i < g->strt.size; i++)
+      int sw;
-        sweepwholelist(L, &g->strt.hash[g->sweepstrgc + i]);
+      propagateall(g);  /* make sure gray list is empty */
-      g->sweepstrgc += i;
+      g->GCestimate = g->GCmemtrav;  /* save what was counted */;
-      if (g->sweepstrgc >= g->strt.size)  /* no more strings to sweep? */
+      work = atomic(L);  /* work is what was traversed by 'atomic' */
-        g->gcstate = GCSsweepudata;
+      g->GCestimate += work;  /* estimate of total memory traversed */
-      return i * GCSWEEPCOST;
+      sw = entersweep(L);
+      return work + sw * GCSWEEPCOST;
     }
-    case GCSsweepudata: {
+    case GCSswpallgc: {  /* sweep "regular" objects */
-      if (g->sweepfin) {
+      return sweepstep(L, g, GCSswpfinobj, &g->finobj);
-        g->sweepfin = sweeplist(L, g->sweepfin, GCSWEEPMAX);
-        return GCSWEEPMAX*GCSWEEPCOST;
-      }
-      else {
-        g->gcstate = GCSsweep;
-        return 0;
-      }
     }
-    case GCSsweep: {
+    case GCSswpfinobj: {  /* sweep objects with finalizers */
-      if (g->sweepgc) {
+      return sweepstep(L, g, GCSswptobefnz, &g->tobefnz);
-        g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+    }
-        return GCSWEEPMAX*GCSWEEPCOST;
+    case GCSswptobefnz: {  /* sweep objects to be finalized */
-      }
+      return sweepstep(L, g, GCSswpend, NULL);
-      else {
+    }
-        /* sweep main thread */
+    case GCSswpend: {  /* finish sweeps */
-        GCObject *mt = obj2gco(g->mainthread);
+      makewhite(g, obj2gco(g->mainthread));  /* sweep main thread */
-        sweeplist(L, &mt, 1);
+      checkSizes(L, g);
-        checkSizes(L);
+      g->gcstate = GCScallfin;
-        g->gcstate = GCSpause;  /* finish collection */
+      return 0;
-        return GCSWEEPCOST;
+    }
-      }
+    case GCScallfin: {  /* state to finish calling finalizers */
+      /* do nothing here; should be handled by 'luaC_forcestep' */
+      g->gcstate = GCSpause;  /* finish collection */
+      return 0;
     }
     default: lua_assert(0); return 0;
   }
 }
-static void generationalcollection (lua_State *L) {
+/*
+** run a few (up to 'g->gcfinnum') finalizers
+*/
+static int runafewfinalizers (lua_State *L) {
   global_State *g = G(L);
-  lua_assert(g->gcstate == GCSpropagate);
+  unsigned int i;
-  if (g->GCestimate == 0) {  /* signal for another major collection? */
+  lua_assert(!g->tobefnz || g->gcfinnum > 0);
-    luaC_fullgc(L, 0);  /* perform a full regular collection */
+  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
-    g->GCestimate = gettotalbytes(g);  /* update control */
+    GCTM(L, 1);  /* call one finalizer */
-  }
+  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
-  else {
+                    : g->gcfinnum * 2;  /* else call a few more next time */
-    lu_mem estimate = g->GCestimate;
+  return i;
-    luaC_runtilstate(L, bitmask(GCSpause));  /* run complete (minor) cycle */
-    g->gcstate = GCSpropagate;  /* skip restart */
-    if (gettotalbytes(g) > (estimate / 100) * g->gcmajorinc)
-      g->GCestimate = 0;  /* signal for a major collection */
-    else
-      g->GCestimate = estimate;  /* keep estimate from last major coll. */
-  }
-  setpause(g, gettotalbytes(g));
-  lua_assert(g->gcstate == GCSpropagate);
 }
-static void incstep (lua_State *L) {
+/*
-  global_State *g = G(L);
+** get GC debt and convert it from Kb to 'work units' (avoid zero debt
+** and overflows)
+*/
+static l_mem getdebt (global_State *g) {
   l_mem debt = g->GCdebt;
   int stepmul = g->gcstepmul;
-  if (stepmul < 40) stepmul = 40;  /* avoid ridiculous low values (and 0) */
-  /* convert debt from Kb to 'work units' (avoid zero debt and overflows) */
   debt = (debt / STEPMULADJ) + 1;
   debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
-  do {  /* always perform at least one single step */
+  return debt;
-    lu_mem work = singlestep(L);  /* do some work */
-    debt -= work;
-  } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
-  if (g->gcstate == GCSpause)
-    setpause(g, g->GCestimate);  /* pause until next cycle */
-  else {
-    debt = (debt / stepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
-    luaE_setdebt(g, debt);
-  }
 }
 /*
-** performs a basic GC step
+** performs a basic GC step when collector is running
-*/
-void luaC_forcestep (lua_State *L) {
-  global_State *g = G(L);
-  int i;
-  if (isgenerational(g)) generationalcollection(L);
-  else incstep(L);
-  /* run a few finalizers (or all of them at the end of a collect cycle) */
-  for (i = 0; g->tobefnz && (i < GCFINALIZENUM || g->gcstate == GCSpause); i++)
-    GCTM(L, 1);  /* call one finalizer */
-}
-/*
-** performs a basic GC step only if collector is running
 */
 void luaC_step (lua_State *L) {
   global_State *g = G(L);
-  if (g->gcrunning) luaC_forcestep(L);
+  l_mem debt = getdebt(g);
-  else luaE_setdebt(g, -GCSTEPSIZE);  /* avoid being called too often */
+  if (!g->gcrunning) {  /* not running? */
+    luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
+    return;
+  }
+  do {
+    if (g->gcstate == GCScallfin && g->tobefnz) {
+      unsigned int n = runafewfinalizers(L);
+      debt -= (n * GCFINALIZECOST);
+    }
+    else {  /* perform one single step */
+      lu_mem work = singlestep(L);
+      debt -= work;
+    }
+  } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
+  if (g->gcstate == GCSpause)
+    setpause(g, g->GCestimate);  /* pause until next cycle */
+  else {
+    debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
+    luaE_setdebt(g, debt);
+    runafewfinalizers(L);
+  }
 }
 /*
 ** performs a full GC cycle; if "isemergency", does not call
 ** finalizers (which could change stack positions)
 */
 void luaC_fullgc (lua_State *L, int isemergency) {
   global_State *g = G(L);
-  int origkind = g->gckind;
+  lua_assert(g->gckind == KGC_NORMAL);
-  lua_assert(origkind != KGC_EMERGENCY);
   if (isemergency)  /* do not run finalizers during emergency GC */
     g->gckind = KGC_EMERGENCY;
-  else {
+  else
-    g->gckind = KGC_NORMAL;
     callallpendingfinalizers(L, 1);
-  }
   if (keepinvariant(g)) {  /* may there be some black objects? */
     /* must sweep all objects to turn them back to white
        (as white has not changed, nothing will be collected) */
   luaC_runtilstate(L, bitmask(GCSpause));
   luaC_runtilstate(L, ~bitmask(GCSpause));  /* start new collection */
   luaC_runtilstate(L, bitmask(GCSpause));  /* run entire collection */
-  if (origkind == KGC_GEN) {  /* generational mode? */
+  g->gckind = KGC_NORMAL;
-    /* generational mode must be kept in propagate phase */
-    luaC_runtilstate(L, bitmask(GCSpropagate));
-  }
-  g->gckind = origkind;
   setpause(g, gettotalbytes(g));
   if (!isemergency)   /* do not run finalizers during emergency GC */
     callallpendingfinalizers(L, 1);

src/lgc.h+30−49

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lgc.h,v 2.58 2012/09/11 12:53:08 roberto Exp $	2	** $Id: lgc.h,v 2.82 2014/03/19 18:51:16 roberto Exp $
3	** Garbage Collector	3	** Garbage Collector
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -38,36 +38,27 @@ · 32 unmodified lines
38	*/	38	*/
39	#define GCSpropagate 0	39	#define GCSpropagate 0
40	#define GCSatomic 1	40	#define GCSatomic 1
41	#define GCSsweepstring 2	41	#define GCSswpallgc 2
42	#define GCSsweepudata 3	42	#define GCSswpfinobj 3
43	#define GCSsweep 4	43	#define GCSswptobefnz 4
44	#define GCSpause 5	44	#define GCSswpend 5
		45	#define GCScallfin 6
		46	#define GCSpause 7
45		47
46		48
47	#define issweepphase(g) \	49	#define issweepphase(g) \
48	(GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep)	50	(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
49		51
50	#define isgenerational(g) ((g)->gckind == KGC_GEN)
51		52
52	/*	53	/*
53	** macros to tell when main invariant (white objects cannot point to black	54	** macro to tell when main invariant (white objects cannot point to black
54	** ones) must be kept. During a non-generational collection, the sweep	55	** ones) must be kept. During a collection, the sweep
55	** phase may break the invariant, as objects turned white may point to	56	** phase may break the invariant, as objects turned white may point to
56	** still-black objects. The invariant is restored when sweep ends and	57	** still-black objects. The invariant is restored when sweep ends and
57	** all objects are white again. During a generational collection, the	58	** all objects are white again.
58	** invariant must be kept all times.
59	*/	59	*/
60		60
61	#define keepinvariant(g) (isgenerational(g) \|\| g->gcstate <= GCSatomic)	61	#define keepinvariant(g) ((g)->gcstate <= GCSatomic)
62
63
64	/*
65	** Outside the collector, the state in generational mode is kept in
66	** 'propagate', so 'keepinvariant' is always true.
67	*/
68	#define keepinvariantout(g) \
69	check_exp(g->gcstate == GCSpropagate \|\| !isgenerational(g), \
70	g->gcstate <= GCSatomic)
71		62
72		63
73	/*	64	/*
@@ -87,10 +78,7 @@ · 13 unmodified lines
87	#define WHITE0BIT 0 /* object is white (type 0) */	78	#define WHITE0BIT 0 /* object is white (type 0) */
88	#define WHITE1BIT 1 /* object is white (type 1) */	79	#define WHITE1BIT 1 /* object is white (type 1) */
89	#define BLACKBIT 2 /* object is black */	80	#define BLACKBIT 2 /* object is black */
90	#define FINALIZEDBIT 3 /* object has been separated for finalization */	81	#define FINALIZEDBIT 3 /* object has been marked for finalization */
91	#define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */
92	#define FIXEDBIT 5 /* object is fixed (should not be collected) */
93	#define OLDBIT 6 /* object is old (only in generational mode) */
94	/* bit 7 is currently used by tests (luaL_checkmemory) */	82	/* bit 7 is currently used by tests (luaL_checkmemory) */
95		83
96	#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)	84	#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
@@ -101,21 +89,15 @@ · 4 unmodified lines
101	#define isgray(x) /* neither white nor black */ \	89	#define isgray(x) /* neither white nor black */ \
102	(!testbits((x)->gch.marked, WHITEBITS \| bitmask(BLACKBIT)))	90	(!testbits((x)->gch.marked, WHITEBITS \| bitmask(BLACKBIT)))
103		91
104	#define isold(x) testbit((x)->gch.marked, OLDBIT)	92	#define tofinalize(x) testbit((x)->gch.marked, FINALIZEDBIT)
105		93
106	/* MOVE OLD rule: whenever an object is moved to the beginning of	94	#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS)
107	a GC list, its old bit must be cleared */
108	#define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT)
109
110	#define otherwhite(g) (g->currentwhite ^ WHITEBITS)
111	#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))	95	#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))
112	#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)	96	#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)
113		97
114	#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)	98	#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
115	#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)	99	#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)
116		100
117	#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x)))
118
119	#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)	101	#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
120		102
121		103
@@ -124,34 +106,33 @@ · 2 unmodified lines
124	#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)	106	#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)
125		107
126		108
127	#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \	109	#define luaC_barrier(L,p,v) { \
		110	if (iscollectable(v) && isblack(obj2gco(p)) && iswhite(gcvalue(v))) \
128	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }	111	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }
129		112
130	#define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \	113	#define luaC_barrierback(L,p,v) { \
131	luaC_barrierback_(L,p); }	114	if (iscollectable(v) && isblack(obj2gco(p)) && iswhite(gcvalue(v))) \
		115	luaC_barrierback_(L,obj2gco(p)); }
132		116
133	#define luaC_objbarrier(L,p,o) \	117	#define luaC_objbarrier(L,p,o) { \
134	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \	118	if (isblack(obj2gco(p)) && iswhite(obj2gco(o))) \
135	luaC_barrier_(L,obj2gco(p),obj2gco(o)); }	119	luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
136		120
137	#define luaC_objbarrierback(L,p,o) \	121	#define luaC_upvalbarrier(L,uv) \
138	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); }	122	{ if (iscollectable((uv)->v) && !upisopen(uv)) \
139		123	luaC_upvalbarrier_(L,uv); }
140	#define luaC_barrierproto(L,p,c) \
141	{ if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); }
142		124
		125	LUAI_FUNC void luaC_fix (lua_State L, GCObject o);
143	LUAI_FUNC void luaC_freeallobjects (lua_State *L);	126	LUAI_FUNC void luaC_freeallobjects (lua_State *L);
144	LUAI_FUNC void luaC_step (lua_State *L);	127	LUAI_FUNC void luaC_step (lua_State *L);
145	LUAI_FUNC void luaC_forcestep (lua_State *L);
146	LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);	128	LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
147	LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);	129	LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
148	LUAI_FUNC GCObject luaC_newobj (lua_State L, int tt, size_t sz,	130	LUAI_FUNC GCObject luaC_newobj (lua_State L, int tt, size_t sz);
149	GCObject **list, int offset);
150	LUAI_FUNC void luaC_barrier_ (lua_State L, GCObject o, GCObject *v);	131	LUAI_FUNC void luaC_barrier_ (lua_State L, GCObject o, GCObject *v);
151	LUAI_FUNC void luaC_barrierback_ (lua_State L, GCObject o);	132	LUAI_FUNC void luaC_barrierback_ (lua_State L, GCObject o);
152	LUAI_FUNC void luaC_barrierproto_ (lua_State L, Proto p, Closure *c);	133	LUAI_FUNC void luaC_upvalbarrier_ (lua_State L, UpVal uv);
153	LUAI_FUNC void luaC_checkfinalizer (lua_State L, GCObject o, Table *mt);	134	LUAI_FUNC void luaC_checkfinalizer (lua_State L, GCObject o, Table *mt);
154	LUAI_FUNC void luaC_checkupvalcolor (global_State g, UpVal uv);	135	LUAI_FUNC void luaC_upvdeccount (lua_State L, UpVal uv);
155	LUAI_FUNC void luaC_changemode (lua_State *L, int mode);	136
156		137
157	#endif	138	#endif

src/linit.c+2−1

 /*
-** $Id: linit.c,v 1.32 2011/04/08 19:17:36 roberto Exp $
+** $Id: linit.c,v 1.33 2014/02/06 17:32:33 roberto Exp $
 ** Initialization of libraries for lua.c and other clients
 ** See Copyright Notice in lua.h
 */
   {LUA_IOLIBNAME, luaopen_io},
   {LUA_OSLIBNAME, luaopen_os},
   {LUA_STRLIBNAME, luaopen_string},
+  {LUA_UTF8LIBNAME, luaopen_utf8},
   {LUA_BITLIBNAME, luaopen_bit32},
   {LUA_MATHLIBNAME, luaopen_math},
   {LUA_DBLIBNAME, luaopen_debug},

src/liolib.c+61−58

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: liolib.c,v 2.114 2013/06/07 19:01:35 roberto Exp $	2	** $Id: liolib.c,v 2.120 2014/03/19 18:57:42 roberto Exp $
3	** Standard I/O (and system) library	3	** Standard I/O (and system) library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -29,14 +29,14 @@ · 23 unmodified lines
29	#include "lualib.h"	29	#include "lualib.h"
30		30
31		31
32	#if !defined(lua_checkmode)	32	#if !defined(l_checkmode)
33		33
34	/*	34	/*
35	** Check whether 'mode' matches '[rwa]%+?b?'.	35	** Check whether 'mode' matches '[rwa]%+?b?'.
36	** Change this macro to accept other modes for 'fopen' besides	36	** Change this macro to accept other modes for 'fopen' besides
37	** the standard ones.	37	** the standard ones.
38	*/	38	*/
39	#define lua_checkmode(mode) \	39	#define l_checkmode(mode) \
40	(mode != '\0' && strchr("rwa", (mode++)) != NULL && \	40	(mode != '\0' && strchr("rwa", (mode++)) != NULL && \
41	(mode != '+' \|\| ++mode) && / skip if char is '+' */ \	41	(mode != '+' \|\| ++mode) && / skip if char is '+' */ \
42	(mode != 'b' \|\| ++mode) && / skip if char is 'b' */ \	42	(mode != 'b' \|\| ++mode) && / skip if char is 'b' */ \
@@ -46,45 +46,61 @@ · 3 unmodified lines
46		46
47	/*	47	/*
48	** {======================================================	48	** {======================================================
49	** lua_popen spawns a new process connected to the current	49	** l_popen spawns a new process connected to the current
50	** one through the file streams.	50	** one through the file streams.
51	** =======================================================	51	** =======================================================
52	*/	52	*/
53		53
54	#if !defined(lua_popen) /* { */	54	#if !defined(l_popen) /* { */
55		55
56	#if defined(LUA_USE_POPEN) /* { */	56	#if defined(LUA_USE_POSIX) /* { */
57		57
58	#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m))	58	#define l_popen(L,c,m) (fflush(NULL), popen(c,m))
59	#define lua_pclose(L,file) ((void)L, pclose(file))	59	#define l_pclose(L,file) (pclose(file))
60		60
61	#elif defined(LUA_WIN) /* }{ */	61	#elif defined(LUA_WIN) /* }{ */
62		62
63	#define lua_popen(L,c,m) ((void)L, _popen(c,m))	63	#define l_popen(L,c,m) (_popen(c,m))
64	#define lua_pclose(L,file) ((void)L, _pclose(file))	64	#define l_pclose(L,file) (_pclose(file))
65
66		65
67	#else /* }{ */	66	#else /* }{ */
68		67
69	#define lua_popen(L,c,m) ((void)((void)c, m), \	68	/* ANSI definitions */
70	luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)	69	#define l_popen(L,c,m) \
71	#define lua_pclose(L,file) ((void)((void)L, file), -1)	70	((void)((void)c, m), \
72		71	luaL_error(L, LUA_QL("popen") " not supported"), \
		72	(FILE*)0)
		73	#define l_pclose(L,file) ((void)L, (void)file, -1)
73		74
74	#endif /* } */	75	#endif /* } */
75		76
76	#endif /* } */	77	#endif /* } */
77		78
78	/* }====================================================== */	79	/* }====================================================== */
79		80
80		81
		82	#if !defined(l_getc) /* { */
		83
		84	#if defined(LUA_USE_POSIX)
		85	#define l_getc(f) getc_unlocked(f)
		86	#define l_lockfile(f) flockfile(f)
		87	#define l_unlockfile(f) funlockfile(f)
		88	#else
		89	#define l_getc(f) getc(f)
		90	#define l_lockfile(f) ((void)0)
		91	#define l_unlockfile(f) ((void)0)
		92	#endif
		93
		94	#endif /* } */
		95
		96
81	/*	97	/*
82	** {======================================================	98	** {======================================================
83	** lua_fseek: configuration for longer offsets	99	** l_fseek: configuration for longer offsets
84	** =======================================================	100	** =======================================================
85	*/	101	*/
86		102
87	#if !defined(lua_fseek) && !defined(LUA_ANSI) /* { */	103	#if !defined(l_fseek) /* { */
88		104
89	#if defined(LUA_USE_POSIX) /* { */	105	#if defined(LUA_USE_POSIX) /* { */
90		106
@@ -94,22 +110,22 @@ · 3 unmodified lines
94		110
95	#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \	111	#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \
96	&& defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */	112	&& defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */
97	/* Windows (but not DDK) and Visual C++ 2005 or higher */
98		113
		114	/* Windows (but not DDK) and Visual C++ 2005 or higher */
99	#define l_fseek(f,o,w) _fseeki64(f,o,w)	115	#define l_fseek(f,o,w) _fseeki64(f,o,w)
100	#define l_ftell(f) _ftelli64(f)	116	#define l_ftell(f) _ftelli64(f)
101	#define l_seeknum __int64	117	#define l_seeknum __int64
102		118
103	#endif /* } */	119	#else /* }{ */
104
105	#endif /* } */
106
107		120
108	#if !defined(l_fseek) /* default definitions */	121	/* ANSI definitions */
109	#define l_fseek(f,o,w) fseek(f,o,w)	122	#define l_fseek(f,o,w) fseek(f,o,w)
110	#define l_ftell(f) ftell(f)	123	#define l_ftell(f) ftell(f)
111	#define l_seeknum long	124	#define l_seeknum long
112	#endif	125
		126	#endif /* } */
		127
		128	#endif /* } */
113		129
114	/* }====================================================== */	130	/* }====================================================== */
115		131
@@ -228,7 +244,7 @@ static int io_open (lua_State *L) { · 112 unmodified lines
228	const char *mode = luaL_optstring(L, 2, "r");	244	const char *mode = luaL_optstring(L, 2, "r");
229	LStream *p = newfile(L);	245	LStream *p = newfile(L);
230	const char md = mode; / to traverse/check mode */	246	const char md = mode; / to traverse/check mode */
231	luaL_argcheck(L, lua_checkmode(md), 2, "invalid mode");	247	luaL_argcheck(L, l_checkmode(md), 2, "invalid mode");
232	p->f = fopen(filename, mode);	248	p->f = fopen(filename, mode);
233	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;	249	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
234	}	250	}
@@ -239,7 +255,7 @@ static int io_open (lua_State *L) { · 4 unmodified lines
239	*/	255	*/
240	static int io_pclose (lua_State *L) {	256	static int io_pclose (lua_State *L) {
241	LStream *p = tolstream(L);	257	LStream *p = tolstream(L);
242	return luaL_execresult(L, lua_pclose(L, p->f));	258	return luaL_execresult(L, l_pclose(L, p->f));
243	}	259	}
244		260
245		261
@@ -247,7 +263,7 @@ static int io_popen (lua_State *L) { · 1 unmodified line
247	const char *filename = luaL_checkstring(L, 1);	263	const char *filename = luaL_checkstring(L, 1);
248	const char *mode = luaL_optstring(L, 2, "r");	264	const char *mode = luaL_optstring(L, 2, "r");
249	LStream *p = newprefile(L);	265	LStream *p = newprefile(L);
250	p->f = lua_popen(L, filename, mode);	266	p->f = l_popen(L, filename, mode);
251	p->closef = &io_pclose;	267	p->closef = &io_pclose;
252	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;	268	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
253	}	269	}
@@ -375,7 +391,7 @@ static int read_number (lua_State L, FILE f) { · 121 unmodified lines
375		391
376	static int test_eof (lua_State L, FILE f) {	392	static int test_eof (lua_State L, FILE f) {
377	int c = getc(f);	393	int c = getc(f);
378	ungetc(c, f);	394	ungetc(c, f); /* no-op when c == EOF */
379	lua_pushlstring(L, NULL, 0);	395	lua_pushlstring(L, NULL, 0);
380	return (c != EOF);	396	return (c != EOF);
381	}	397	}
@@ -383,40 +399,27 @@ static int test_eof (lua_State L, FILE f) { · 1 unmodified line
383		399
384	static int read_line (lua_State L, FILE f, int chop) {	400	static int read_line (lua_State L, FILE f, int chop) {
385	luaL_Buffer b;	401	luaL_Buffer b;
		402	int c;
386	luaL_buffinit(L, &b);	403	luaL_buffinit(L, &b);
387	for (;;) {	404	l_lockfile(f);
388	size_t l;	405	while ((c = l_getc(f)) != EOF && c != '\n')
389	char *p = luaL_prepbuffer(&b);	406	luaL_addchar(&b, c);
390	if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */	407	l_unlockfile(f);
391	luaL_pushresult(&b); /* close buffer */	408	if (!chop && c == '\n') luaL_addchar(&b, c);
392	return (lua_rawlen(L, -1) > 0); /* check whether read something */	409	luaL_pushresult(&b); /* close buffer */
393	}	410	return (c == '\n' \|\| lua_rawlen(L, -1) > 0);
394	l = strlen(p);
395	if (l == 0 \|\| p[l-1] != '\n')
396	luaL_addsize(&b, l);
397	else {
398	luaL_addsize(&b, l - chop); /* chop 'eol' if needed */
399	luaL_pushresult(&b); /* close buffer */
400	return 1; /* read at least an `eol' */
401	}
402	}
403	}	411	}
404		412
405		413
406	#define MAX_SIZE_T (~(size_t)0)
407
408	static void read_all (lua_State L, FILE f) {	414	static void read_all (lua_State L, FILE f) {
409	size_t rlen = LUAL_BUFFERSIZE; /* how much to read in each cycle */	415	size_t nr;
410	luaL_Buffer b;	416	luaL_Buffer b;
411	luaL_buffinit(L, &b);	417	luaL_buffinit(L, &b);
412	for (;;) {	418	do { /* read file in chunks of LUAL_BUFFERSIZE bytes */
413	char *p = luaL_prepbuffsize(&b, rlen);	419	char *p = luaL_prepbuffsize(&b, LUAL_BUFFERSIZE);
414	size_t nr = fread(p, sizeof(char), rlen, f);	420	nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
415	luaL_addsize(&b, nr);	421	luaL_addsize(&b, nr);
416	if (nr < rlen) break; /* eof? */	422	} while (nr == LUAL_BUFFERSIZE);
417	else if (rlen <= (MAX_SIZE_T / 4)) /* avoid buffers too large */
418	rlen = 2; / double buffer size at each iteration */
419	}
420	luaL_pushresult(&b); /* close buffer */	423	luaL_pushresult(&b); /* close buffer */
421	}	424	}
422		425
@@ -566,15 +569,15 @@ static int f_seek (lua_State *L) { · 143 unmodified lines
566	static const char *const modenames[] = {"set", "cur", "end", NULL};	569	static const char *const modenames[] = {"set", "cur", "end", NULL};
567	FILE *f = tofile(L);	570	FILE *f = tofile(L);
568	int op = luaL_checkoption(L, 2, "cur", modenames);	571	int op = luaL_checkoption(L, 2, "cur", modenames);
569	lua_Number p3 = luaL_optnumber(L, 3, 0);	572	lua_Integer p3 = luaL_optinteger(L, 3, 0);
570	l_seeknum offset = (l_seeknum)p3;	573	l_seeknum offset = (l_seeknum)p3;
571	luaL_argcheck(L, (lua_Number)offset == p3, 3,	574	luaL_argcheck(L, (lua_Integer)offset == p3, 3,
572	"not an integer in proper range");	575	"not an integer in proper range");
573	op = l_fseek(f, offset, mode[op]);	576	op = l_fseek(f, offset, mode[op]);
574	if (op)	577	if (op)
575	return luaL_fileresult(L, 0, NULL); /* error */	578	return luaL_fileresult(L, 0, NULL); /* error */
576	else {	579	else {
577	lua_pushnumber(L, (lua_Number)l_ftell(f));	580	lua_pushinteger(L, (lua_Integer)l_ftell(f));
578	return 1;	581	return 1;
579	}	582	}
580	}	583	}

src/llex.c+80−42

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llex.c,v 2.67 2013/06/19 14:27:00 roberto Exp $	2	** $Id: llex.c,v 2.74 2014/02/14 15:23:51 roberto Exp $
3	** Lexical Analyzer	3	** Lexical Analyzer
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -15,6 +15,7 @@ · 9 unmodified lines
15		15
16	#include "lctype.h"	16	#include "lctype.h"
17	#include "ldo.h"	17	#include "ldo.h"
		18	#include "lgc.h"
18	#include "llex.h"	19	#include "llex.h"
19	#include "lobject.h"	20	#include "lobject.h"
20	#include "lparser.h"	21	#include "lparser.h"
@@ -38,7 +39,8 @@ static const char *const luaX_tokens [] = { · 17 unmodified lines
38	"end", "false", "for", "function", "goto", "if",	39	"end", "false", "for", "function", "goto", "if",
39	"in", "local", "nil", "not", "or", "repeat",	40	"in", "local", "nil", "not", "or", "repeat",
40	"return", "then", "true", "until", "while",	41	"return", "then", "true", "until", "while",
41	"//", "..", "...", "==", ">=", "<=", "~=", "::", "<eof>",	42	"//", "..", "...", "==", ">=", "<=", "~=",
		43	"<<", ">>", "::", "<eof>",
42	"<number>", "<number>", "<name>", "<string>"	44	"<number>", "<number>", "<name>", "<string>"
43	};	45	};
44		46
@@ -64,9 +66,11 @@ static void save (LexState *ls, int c) { · 19 unmodified lines
64		66
65	void luaX_init (lua_State *L) {	67	void luaX_init (lua_State *L) {
66	int i;	68	int i;
		69	TString e = luaS_new(L, LUA_ENV); / create env name */
		70	luaC_fix(L, obj2gco(e)); /* never collect this name */
67	for (i=0; i<NUM_RESERVED; i++) {	71	for (i=0; i<NUM_RESERVED; i++) {
68	TString *ts = luaS_new(L, luaX_tokens[i]);	72	TString *ts = luaS_new(L, luaX_tokens[i]);
69	luaS_fix(ts); /* reserved words are never collected */	73	luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */
70	ts->tsv.extra = cast_byte(i+1); /* reserved word */	74	ts->tsv.extra = cast_byte(i+1); /* reserved word */
71	}	75	}
72	}	76	}
@@ -116,22 +120,25 @@ l_noret luaX_syntaxerror (LexState ls, const char msg) { · 43 unmodified lines
116		120
117		121
118	/*	122	/*
119	** creates a new string and anchors it in function's table so that	123	** creates a new string and anchors it in scanner's table so that
120	** it will not be collected until the end of the function's compilation	124	** it will not be collected until the end of the compilation
121	** (by that time it should be anchored in function's prototype)	125	** (by that time it should be anchored somewhere)
122	*/	126	*/
123	TString luaX_newstring (LexState ls, const char *str, size_t l) {	127	TString luaX_newstring (LexState ls, const char *str, size_t l) {
124	lua_State *L = ls->L;	128	lua_State *L = ls->L;
125	TValue o; / entry for `str' */	129	TValue o; / entry for `str' */
126	TString ts = luaS_newlstr(L, str, l); / create new string */	130	TString ts = luaS_newlstr(L, str, l); / create new string */
127	setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */	131	setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */
128	o = luaH_set(L, ls->fs->h, L->top - 1);	132	o = luaH_set(L, ls->h, L->top - 1);
129	if (ttisnil(o)) { /* not in use yet? (see 'addK') */	133	if (ttisnil(o)) { /* not in use yet? */
130	/* boolean value does not need GC barrier;	134	/* boolean value does not need GC barrier;
131	table has no metatable, so it does not need to invalidate cache */	135	table has no metatable, so it does not need to invalidate cache */
132	setbvalue(o, 1); /* t[string] = true */	136	setbvalue(o, 1); /* t[string] = true */
133	luaC_checkGC(L);	137	luaC_checkGC(L);
134	}	138	}
		139	else { /* string already present */
		140	ts = rawtsvalue(keyfromval(o)); /* re-use value previously stored */
		141	}
135	L->top--; /* remove string from stack */	142	L->top--; /* remove string from stack */
136	return ts;	143	return ts;
137	}	144	}
@@ -163,8 +170,7 @@ void luaX_setinput (lua_State L, LexState ls, ZIO z, TString source, · 25 unmodified lines
163	ls->linenumber = 1;	170	ls->linenumber = 1;
164	ls->lastline = 1;	171	ls->lastline = 1;
165	ls->source = source;	172	ls->source = source;
166	ls->envn = luaS_new(L, LUA_ENV); /* create env name */	173	ls->envn = luaS_new(L, LUA_ENV); /* get env name */
167	luaS_fix(ls->envn); /* never collect this name */
168	luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */	174	luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
169	}	175	}
170		176
@@ -314,40 +320,65 @@ static void read_long_string (LexState ls, SemInfo seminfo, int sep) { · 143 unmodified lines
314	}	320	}
315		321
316		322
317	static void escerror (LexState ls, int c, int n, const char *msg) {	323	static void esccheck (LexState ls, int c, const char msg) {
318	int i;	324	if (!c) {
319	luaZ_resetbuffer(ls->buff); /* prepare error message */	325	if (ls->current != EOZ)
320	save(ls, '\\');	326	save_and_next(ls); /* add current to buffer for error message */
321	for (i = 0; i < n && c[i] != EOZ; i++)	327	lexerror(ls, msg, TK_STRING);
322	save(ls, c[i]);	328	}
323	lexerror(ls, msg, TK_STRING);	329	}
		330
		331
		332	static int gethexa (LexState *ls) {
		333	save_and_next(ls);
		334	esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected");
		335	return luaO_hexavalue(ls->current);
324	}	336	}
325		337
326		338
327	static int readhexaesc (LexState *ls) {	339	static int readhexaesc (LexState *ls) {
328	int c[3], i; /* keep input for error message */	340	int r = gethexa(ls);
329	int r = 0; /* result accumulator */	341	r = (r << 4) + gethexa(ls);
330	c[0] = 'x'; /* for error message */	342	luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */
331	for (i = 1; i < 3; i++) { /* read two hexadecimal digits */	343	return r;
332	c[i] = next(ls);	344	}
333	if (!lisxdigit(c[i]))	345
334	escerror(ls, c, i + 1, "hexadecimal digit expected");	346
335	r = (r << 4) + luaO_hexavalue(c[i]);	347	static unsigned int readutf8esc (LexState *ls) {
		348	unsigned int r;
		349	int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */
		350	save_and_next(ls); /* skip 'u' */
		351	esccheck(ls, ls->current == '{', "missing '{'");
		352	r = gethexa(ls); /* must have at least one digit */
		353	while ((save_and_next(ls), lisxdigit(ls->current))) {
		354	i++;
		355	r = (r << 4) + luaO_hexavalue(ls->current);
		356	esccheck(ls, r <= 0x10FFFF, "UTF-8 value too large");
336	}	357	}
		358	esccheck(ls, ls->current == '}', "missing '}'");
		359	next(ls); /* skip '}' */
		360	luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */
337	return r;	361	return r;
338	}	362	}
339		363
340		364
		365	static void utf8esc (LexState *ls) {
		366	char buff[UTF8BUFFSZ];
		367	int n = luaO_utf8esc(buff, readutf8esc(ls));
		368	for (; n > 0; n--) /* add 'buff' to string */
		369	save(ls, buff[UTF8BUFFSZ - n]);
		370	}
		371
		372
341	static int readdecesc (LexState *ls) {	373	static int readdecesc (LexState *ls) {
342	int c[3], i;	374	int i;
343	int r = 0; /* result accumulator */	375	int r = 0; /* result accumulator */
344	for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */	376	for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */
345	c[i] = ls->current;	377	r = 10*r + ls->current - '0';
346	r = 10*r + c[i] - '0';	378	save_and_next(ls);
347	next(ls);
348	}	379	}
349	if (r > UCHAR_MAX)	380	esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
350	escerror(ls, c, i, "decimal escape too large");	381	luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */
351	return r;	382	return r;
352	}	383	}
353		384
@@ -365,7 +396,7 @@ static void read_string (LexState ls, int del, SemInfo seminfo) { · 11 unmodified lines
365	break; /* to avoid warnings */	396	break; /* to avoid warnings */
366	case '\\': { /* escape sequences */	397	case '\\': { /* escape sequences */
367	int c; /* final character to be saved */	398	int c; /* final character to be saved */
368	next(ls); /* do not save the `\' */	399	save_and_next(ls); /* keep '\\' for error messages */
369	switch (ls->current) {	400	switch (ls->current) {
370	case 'a': c = '\a'; goto read_save;	401	case 'a': c = '\a'; goto read_save;
371	case 'b': c = '\b'; goto read_save;	402	case 'b': c = '\b'; goto read_save;
@@ -375,12 +406,14 @@ static void read_string (LexState ls, int del, SemInfo seminfo) { · 3 unmodified lines
375	case 't': c = '\t'; goto read_save;	406	case 't': c = '\t'; goto read_save;
376	case 'v': c = '\v'; goto read_save;	407	case 'v': c = '\v'; goto read_save;
377	case 'x': c = readhexaesc(ls); goto read_save;	408	case 'x': c = readhexaesc(ls); goto read_save;
		409	case 'u': utf8esc(ls); goto no_save;
378	case '\n': case '\r':	410	case '\n': case '\r':
379	inclinenumber(ls); c = '\n'; goto only_save;	411	inclinenumber(ls); c = '\n'; goto only_save;
380	case '\\': case '\"': case '\'':	412	case '\\': case '\"': case '\'':
381	c = ls->current; goto read_save;	413	c = ls->current; goto read_save;
382	case EOZ: goto no_save; /* will raise an error next loop */	414	case EOZ: goto no_save; /* will raise an error next loop */
383	case 'z': { /* zap following span of spaces */	415	case 'z': { /* zap following span of spaces */
		416	luaZ_buffremove(ls->buff, 1); /* remove '\\' */
384	next(ls); /* skip the 'z' */	417	next(ls); /* skip the 'z' */
385	while (lisspace(ls->current)) {	418	while (lisspace(ls->current)) {
386	if (currIsNewline(ls)) inclinenumber(ls);	419	if (currIsNewline(ls)) inclinenumber(ls);
@@ -389,15 +422,18 @@ static void read_string (LexState ls, int del, SemInfo seminfo) { · 2 unmodified lines
389	goto no_save;	422	goto no_save;
390	}	423	}
391	default: {	424	default: {
392	if (!lisdigit(ls->current))	425	esccheck(ls, lisdigit(ls->current), "invalid escape sequence");
393	escerror(ls, &ls->current, 1, "invalid escape sequence");	426	c = readdecesc(ls); /* digital escape \ddd */
394	/* digital escape \ddd */
395	c = readdecesc(ls);
396	goto only_save;	427	goto only_save;
397	}	428	}
398	}	429	}
399	read_save: next(ls); /* read next character */	430	read_save:
400	only_save: save(ls, c); /* save 'c' */	431	next(ls);
		432	/* go through */
		433	only_save:
		434	luaZ_buffremove(ls->buff, 1); /* remove '\\' */
		435	save(ls, c);
		436	/* go through */
401	no_save: break;	437	no_save: break;
402	}	438	}
403	default:	439	default:
@@ -457,13 +493,15 @@ static int llex (LexState ls, SemInfo seminfo) { · 53 unmodified lines
457	}	493	}
458	case '<': {	494	case '<': {
459	next(ls);	495	next(ls);
460	if (ls->current != '=') return '<';	496	if (ls->current == '=') { next(ls); return TK_LE; }
461	else { next(ls); return TK_LE; }	497	if (ls->current == '<') { next(ls); return TK_SHL; }
		498	return '<';
462	}	499	}
463	case '>': {	500	case '>': {
464	next(ls);	501	next(ls);
465	if (ls->current != '=') return '>';	502	if (ls->current == '=') { next(ls); return TK_GE; }
466	else { next(ls); return TK_GE; }	503	if (ls->current == '>') { next(ls); return TK_SHR; }
		504	return '>';
467	}	505	}
468	case '/': {	506	case '/': {
469	next(ls);	507	next(ls);

src/llex.h+3−1

 /*
-** $Id: llex.h,v 1.74 2013/04/26 13:07:53 roberto Exp $
+** $Id: llex.h,v 1.76 2013/12/30 20:47:58 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
   /* other terminal symbols */
   TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
+  TK_SHL, TK_SHR,
   TK_DBCOLON, TK_EOS,
   TK_FLT, TK_INT, TK_NAME, TK_STRING
 };
   struct lua_State *L;
   ZIO *z;  /* input stream */
   Mbuffer *buff;  /* buffer for tokens */
+  Table *h;  /* to avoid collection/reuse strings */
   struct Dyndata *dyd;  /* dynamic structures used by the parser */
   TString *source;  /* current source name */
   TString *envn;  /* environment variable name */

src/llimits.h+7−4

 /*
-** $Id: llimits.h,v 1.108 2013/06/19 14:27:00 roberto Exp $
+** $Id: llimits.h,v 1.111 2014/03/07 16:19:00 roberto Exp $
 ** Limits, basic types, and some other `installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
 #define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
+/* maximum value for a lua_Unsigned */
+#define MAX_UINTEGER	(~(lua_Unsigned)0)
 /* minimum and maximum values for lua_Integer */
-#define MAX_INTEGER	((lua_Integer)(~(lua_Unsigned)0 >> 1))
+#define MAX_INTEGER	((lua_Integer)(MAX_UINTEGER >> 1))
 #define MIN_INTEGER	(~MAX_INTEGER)
 /*
 ** conversion of pointer to integer
 ** this is for hashing only; there is no problem if the integer
 #define cast(t, exp)	((t)(exp))
+#define cast_void(i)	cast(void, (i))
 #define cast_byte(i)	cast(lu_byte, (i))
 #define cast_num(i)	cast(lua_Number, (i))
 #define cast_int(i)	cast(int, (i))
 /* minimum size for the string table (must be power of 2) */
 #if !defined(MINSTRTABSIZE)
-#define MINSTRTABSIZE	32
+#define MINSTRTABSIZE	64	/* minimum size for "predefined" strings */
 #endif

src/lmathlib.c+11−4

 /*
-** $Id: lmathlib.c,v 1.90 2013/07/03 17:23:19 roberto Exp $
+** $Id: lmathlib.c,v 1.92 2013/07/22 16:05:53 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
 }
-static int math_isfloat (lua_State *L) {
+static int math_type (lua_State *L) {
   luaL_checkany(L, 1);
-  lua_pushboolean(L, (lua_type(L, 1) == LUA_TNUMBER && !lua_isinteger(L, 1)));
+  if (lua_type(L, 1) == LUA_TNUMBER) {
+      if (lua_isinteger(L, 1))
+        lua_pushliteral(L, "integer");
+      else
+        lua_pushliteral(L, "float");
+  }
+  else
+    lua_pushnil(L);
   return 1;
 }
   {"ifloor", math_ifloor},
   {"fmod",   math_fmod},
   {"frexp", math_frexp},
-  {"isfloat", math_isfloat},
   {"ldexp", math_ldexp},
 #if defined(LUA_COMPAT_LOG10)
   {"log10", math_log10},
   {"sqrt",  math_sqrt},
   {"tanh",   math_tanh},
   {"tan",   math_tan},
+  {"type", math_type},
   {NULL, NULL}
 };

src/loadlib.c+15−19

 /*
-** $Id: loadlib.c,v 1.111 2012/05/30 12:33:44 roberto Exp $
+** $Id: loadlib.c,v 1.113 2014/03/12 20:57:40 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
 /*
-** LUA_PATH and LUA_CPATH are the names of the environment
+** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
 ** variables that Lua check to set its paths.
 */
-#if !defined(LUA_PATH)
+#if !defined(LUA_PATH_VAR)
-#define LUA_PATH	"LUA_PATH"
+#define LUA_PATH_VAR	"LUA_PATH"
 #endif
-#if !defined(LUA_CPATH)
+#if !defined(LUA_CPATH_VAR)
-#define LUA_CPATH	"LUA_CPATH"
+#define LUA_CPATH_VAR	"LUA_CPATH"
 #endif
 #define LUA_PATHSUFFIX		"_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
-#define LUA_PATHVERSION		LUA_PATH LUA_PATHSUFFIX
+#define LUA_PATHVARVERSION		LUA_PATH_VAR LUA_PATHSUFFIX
-#define LUA_CPATHVERSION	LUA_CPATH LUA_PATHSUFFIX
+#define LUA_CPATHVARVERSION		LUA_CPATH_VAR LUA_PATHSUFFIX
 /*
 ** LUA_PATH_SEP is the character that separates templates in a path.
 static int searcher_preload (lua_State *L) {
   const char *name = luaL_checkstring(L, 1);
   lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
-  lua_getfield(L, -1, name);
+  if (lua_getfield(L, -1, name) == LUA_TNIL)  /* not found? */
-  if (lua_isnil(L, -1))  /* not found? */
     lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
   return 1;
 }
     luaL_error(L, LUA_QL("package.searchers") " must be a table");
   /*  iterate over available searchers to find a loader */
   for (i = 1; ; i++) {
-    lua_rawgeti(L, 3, i);  /* get a searcher */
+    if (lua_rawgeti(L, 3, i) == LUA_TNIL) {  /* no more searchers? */
-    if (lua_isnil(L, -1)) {  /* no more searchers? */
       lua_pop(L, 1);  /* remove nil */
       luaL_pushresult(&msg);  /* create error message */
       luaL_error(L, "module " LUA_QS " not found:%s",
   lua_call(L, 2, 1);  /* run loader to load module */
   if (!lua_isnil(L, -1))  /* non-nil return? */
     lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
-  lua_getfield(L, 2, name);
+  if (lua_getfield(L, 2, name) == LUA_TNIL) {   /* module set no value? */
-  if (lua_isnil(L, -1)) {   /* module did not set a value? */
     lua_pushboolean(L, 1);  /* use true as result */
     lua_pushvalue(L, -1);  /* extra copy to be returned */
     lua_setfield(L, 2, name);  /* _LOADED[name] = true */
   int lastarg = lua_gettop(L);  /* last parameter */
   luaL_pushmodule(L, modname, 1);  /* get/create module table */
   /* check whether table already has a _NAME field */
-  lua_getfield(L, -1, "_NAME");
+  if (lua_getfield(L, -1, "_NAME") != LUA_TNIL)
-  if (!lua_isnil(L, -1))  /* is table an initialized module? */
+    lua_pop(L, 1);  /* table is an initialized module */
-    lua_pop(L, 1);
   else {  /* no; initialize it */
     lua_pop(L, 1);
     modinit(L, modname);
 #endif
   lua_setfield(L, -2, "searchers");  /* put it in field 'searchers' */
   /* set field 'path' */
-  setpath(L, "path", LUA_PATHVERSION, LUA_PATH, LUA_PATH_DEFAULT);
+  setpath(L, "path", LUA_PATHVARVERSION, LUA_PATH_VAR, LUA_PATH_DEFAULT);
   /* set field 'cpath' */
-  setpath(L, "cpath", LUA_CPATHVERSION, LUA_CPATH, LUA_CPATH_DEFAULT);
+  setpath(L, "cpath", LUA_CPATHVARVERSION, LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
   /* store config information */
   lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
                      LUA_EXEC_DIR "\n" LUA_IGMARK "\n");

src/lobject.c+88−38

 /*
-** $Id: lobject.c,v 2.67 2013/06/25 18:58:32 roberto Exp $
+** $Id: lobject.c,v 2.76 2014/03/21 13:52:33 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
     case LUA_OPSUB:return intop(-, v1, v2);
     case LUA_OPMUL:return intop(*, v1, v2);
     case LUA_OPMOD: return luaV_mod(L, v1, v2);
-    case LUA_OPPOW: return luaV_pow(v1, v2);
+    case LUA_OPPOW: return luaV_pow(L, v1, v2);
-    case LUA_OPUNM: return -v1;
+    case LUA_OPIDIV: return luaV_div(L, v1, v2);
+    case LUA_OPBAND: return intop(&, v1, v2);
+    case LUA_OPBOR: return intop(|, v1, v2);
+    case LUA_OPBXOR: return intop(^, v1, v2);
+    case LUA_OPSHL: return luaV_shiftl(v1, v2);
+    case LUA_OPSHR: return luaV_shiftl(v1, -v2);
+    case LUA_OPUNM: return intop(-, 0, v1);
+    case LUA_OPBNOT: return intop(^, cast_integer(-1), v1);
     default: lua_assert(0); return 0;
   }
 }
-static lua_Number numarith (int op, lua_Number v1, lua_Number v2) {
+static lua_Number numarith (lua_State *L, int op, lua_Number v1,
+                                                  lua_Number v2) {
   switch (op) {
-    case LUA_OPADD: return luai_numadd(NULL, v1, v2);
+    case LUA_OPADD: return luai_numadd(L, v1, v2);
-    case LUA_OPSUB: return luai_numsub(NULL, v1, v2);
+    case LUA_OPSUB: return luai_numsub(L, v1, v2);
-    case LUA_OPMUL: return luai_nummul(NULL, v1, v2);
+    case LUA_OPMUL: return luai_nummul(L, v1, v2);
-    case LUA_OPDIV: return luai_numdiv(NULL, v1, v2);
+    case LUA_OPDIV: return luai_numdiv(L, v1, v2);
-    case LUA_OPMOD: return luai_nummod(NULL, v1, v2);
+    case LUA_OPMOD: return luai_nummod(L, v1, v2);
-    case LUA_OPPOW: return luai_numpow(NULL, v1, v2);
+    case LUA_OPPOW: return luai_numpow(L, v1, v2);
-    case LUA_OPUNM: return luai_numunm(NULL, v1);
+    case LUA_OPUNM: return luai_numunm(L, v1);
     default: lua_assert(0); return 0;
   }
 }
 void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
                  TValue *res) {
-  if (op == LUA_OPIDIV) {  /* operates only on integers */
+  switch (op) {
-    lua_Integer i1; lua_Integer i2;
+    case LUA_OPIDIV: case LUA_OPBAND: case LUA_OPBOR:
-    if (tointeger(p1, &i1) && tointeger(p2, &i2)) {
+    case LUA_OPBXOR: case LUA_OPSHL: case LUA_OPSHR:
-      setivalue(res, luaV_div(L, i1, i2));
+    case LUA_OPBNOT: {  /* operates only on integers */
-      return;
+      lua_Integer i1; lua_Integer i2;
+      if (tointeger(p1, &i1) && tointeger(p2, &i2)) {
+        setivalue(res, intarith(L, op, i1, i2));
+        return;
+      }
+      else break;  /* go to the end */
     }
-    /* else go to the end */
+    case LUA_OPDIV: {  /* operates only on floats */
-  }
+      lua_Number n1; lua_Number n2;
-  else {  /* other operations */
+      if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
-    lua_Number n1; lua_Number n2;
+        setnvalue(res, numarith(L, op, n1, n2));
-    if (ttisinteger(p1) && ttisinteger(p2) && op != LUA_OPDIV &&
+        return;
-        (op != LUA_OPPOW || ivalue(p2) >= 0)) {
+      }
-      setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
+      else break;  /* go to the end */
-      return;
     }
-    else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
+    default: {  /* other operations */
-      setnvalue(res, numarith(op, n1, n2));
+      lua_Number n1; lua_Number n2;
-      return;
+      if (ttisinteger(p1) && ttisinteger(p2)) {
+        setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
+        return;
+      }
+      else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
+        setnvalue(res, numarith(L, op, n1, n2));
+        return;
+      }
+      else break;  /* go to the end */
     }
-    /* else go to the end */
   }
-  /* could not perform raw operation; try metmethod */
+  /* could not perform raw operation; try metamethod */
-  lua_assert(L != NULL);  /* cannot fail when folding (compile time) */
+  lua_assert(L != NULL);  /* should not fail when folding (compile time) */
   luaT_trybinTM(L, p1, p2, res, cast(TMS, op - LUA_OPADD + TM_ADD));
 }
 /*
+** {======================================================
 ** lua_strx2number converts an hexadecimal numeric string to a number.
 ** In C99, 'strtod' does both conversions. C89, however, has no function
 ** to convert floating hexadecimal strings to numbers. For these
 ** systems, you can leave 'lua_strx2number' undefined and Lua will
 ** provide its own implementation.
+** =======================================================
 */
-#if defined(LUA_USE_STRTODHEX)
+#if !defined(lua_strx2number)		/* { */
+#if defined(LUA_USE_C99)		/* { */
 #define lua_strx2number(s,p)    lua_str2number(s,p)
-#endif
+#else					/* }{ */
-#if !defined(lua_strx2number)
+/* Lua's implementation for 'lua_strx2number' */
 #include <math.h>
 /* maximum number of significant digits to read (to avoid overflows
    even with single floats) */
 #define MAXSIGDIG	30
   return l_mathop(ldexp)(r, e);
 }
-#endif
+#endif					/* } */
+#endif					/* } */
+/* }====================================================== */
 int luaO_str2d (const char *s, size_t len, lua_Number *result) {
   while (lisspace(cast_uchar(*s))) s++;  /* skip trailing spaces */
   if (empty || s != ends) return 0;  /* something wrong in the numeral */
   else {
-    if (neg) *result = -cast(lua_Integer, a);
+    *result = cast_integer((neg) ? 0u - a : a);
-    else *result = cast(lua_Integer, a);
     return 1;
   }
 }
+int luaO_utf8esc (char *buff, unsigned int x) {
+  int n = 1;  /* number of bytes put in buffer (backwards) */
+  if (x < 0x80)  /* ascii? */
+    buff[UTF8BUFFSZ - 1] = x;
+  else {  /* need continuation bytes */
+    unsigned int mfb = 0x3f;  /* maximum that fits in first byte */
+    do {
+      buff[UTF8BUFFSZ - (n++)] = 0x80 | (x & 0x3f);  /* add continuation byte */
+      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] = (~mfb << 1) | x;  /* add first byte */
+  }
+  return n;
+}
 static void pushstr (lua_State *L, const char *str, size_t l) {
   setsvalue2s(L, L->top++, luaS_newlstr(L, str, l));
 }
-/* this function handles only `%d', `%c', %f, %p, and `%s' formats */
+/* this function handles only '%d', '%c', '%f', '%p', and '%s'
+   conventional formats, plus Lua-specific '%L' and '%U' */
 const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
   int n = 0;
   for (;;) {
         pushstr(L, buff, l);
         break;
       }
+      case 'U': {
+        char buff[UTF8BUFFSZ];
+        int l = luaO_utf8esc(buff, va_arg(argp, int));
+        pushstr(L, buff + UTF8BUFFSZ - l, l);
+        break;
+      }
       case '%': {
         pushstr(L, "%", 1);
         break;

src/lobject.h+25−20

 /*
-** $Id: lobject.h,v 2.78 2013/05/14 15:59:04 roberto Exp $
+** $Id: lobject.h,v 2.86 2014/02/19 13:52:42 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
 ** Extra tags for non-values
 */
 #define LUA_TPROTO	LUA_NUMTAGS
-#define LUA_TUPVAL	(LUA_NUMTAGS+1)
+#define LUA_TDEADKEY	(LUA_NUMTAGS+1)
-#define LUA_TDEADKEY	(LUA_NUMTAGS+2)
 /*
 ** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
 */
-#define LUA_TOTALTAGS	(LUA_TUPVAL+2)
+#define LUA_TOTALTAGS	(LUA_TPROTO + 2)
 /*
 #define ttisCclosure(o)		checktag((o), ctb(LUA_TCCL))
 #define ttisLclosure(o)		checktag((o), ctb(LUA_TLCL))
 #define ttislcf(o)		checktag((o), LUA_TLCF)
-#define ttisuserdata(o)		checktag((o), ctb(LUA_TUSERDATA))
+#define ttisfulluserdata(o)	checktag((o), ctb(LUA_TUSERDATA))
 #define ttisthread(o)		checktag((o), ctb(LUA_TTHREAD))
 #define ttisdeadkey(o)		checktag((o), LUA_TDEADKEY)
 #define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
 #define rawtsvalue(o)	check_exp(ttisstring(o), &val_(o).gc->ts)
 #define tsvalue(o)	(&rawtsvalue(o)->tsv)
-#define rawuvalue(o)	check_exp(ttisuserdata(o), &val_(o).gc->u)
+#define rawuvalue(o)	check_exp(ttisfulluserdata(o), &val_(o).gc->u)
 #define uvalue(o)	(&rawuvalue(o)->uv)
 #define clvalue(o)	check_exp(ttisclosure(o), &val_(o).gc->cl)
 #define clLvalue(o)	check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
   struct {
     CommonHeader;
     lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
-    unsigned int hash;
     size_t len;  /* number of characters in string */
+    union TString *hnext;  /* linked list for hash table */
+    unsigned int hash;
   } tsv;
 } TString;
   L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
   struct {
     CommonHeader;
+    lu_byte ttuv_;  /* user value's tag */
     struct Table *metatable;
-    struct Table *env;
     size_t len;  /* number of bytes */
+    union Value user_;  /* user value */
   } uv;
 } Udata;
+#define setuservalue(L,u,o) \
+	{ const TValue *io=(o); Udata *iu = (u); \
+	  iu->uv.user_ = io->value_; iu->uv.ttuv_ = io->tt_; \
+	  checkliveness(G(L),io); }
+#define getuservalue(L,u,o) \
+	{ TValue *io=(o); const Udata *iu = (u); \
+	  io->value_ = iu->uv.user_; io->tt_ = iu->uv.ttuv_; \
+	  checkliveness(G(L),io); }
 /*
 ** Description of an upvalue for function prototypes
 /*
 ** Lua Upvalues
 */
-typedef struct UpVal {
+typedef struct UpVal UpVal;
-  CommonHeader;
-  TValue *v;  /* points to stack or to its own value */
-  union {
-    TValue value;  /* the value (when closed) */
-    struct {  /* double linked list (when open) */
-      struct UpVal *prev;
-      struct UpVal *next;
-    } l;
-  } u;
-} UpVal;
 /*
 typedef union TKey {
   struct {
     TValuefields;
-    struct Node *next;  /* for chaining */
+    int next;  /* for chaining (offset for next node) */
   } nk;
   TValue tvk;
 } TKey;
 LUAI_DDEC const TValue luaO_nilobject_;
+/* size of buffer for 'luaO_utf8esc' function */
+#define UTF8BUFFSZ	8
 LUAI_FUNC int luaO_int2fb (unsigned int x);
 LUAI_FUNC int luaO_fb2int (int x);
+LUAI_FUNC int luaO_utf8esc (char *buff, unsigned int x);
 LUAI_FUNC int luaO_ceillog2 (unsigned int x);
 LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
                            const TValue *p2, TValue *res);

src/lopcodes.c+17−5

 /*
-** $Id: lopcodes.c,v 1.50 2013/04/26 13:07:53 roberto Exp $
+** $Id: lopcodes.c,v 1.53 2013/12/30 20:47:58 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
   "ADD",
   "SUB",
   "MUL",
-  "DIV",
-  "IDIV",
   "MOD",
   "POW",
+  "DIV",
+  "IDIV",
+  "BAND",
+  "BOR",
+  "BXOR",
+  "SHL",
+  "SHR",
   "UNM",
+  "BNOT",
   "NOT",
   "LEN",
   "CONCAT",
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_IDIV */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_IDIV */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BAND */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BOR */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BXOR */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHL */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHR */
  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_BNOT */
  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
  ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */

src/lopcodes.h+9−3

 /*
-** $Id: lopcodes.h,v 1.143 2013/04/26 13:07:53 roberto Exp $
+** $Id: lopcodes.h,v 1.146 2013/12/30 20:47:58 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 OP_ADD,/*	A B C	R(A) := RK(B) + RK(C)				*/
 OP_SUB,/*	A B C	R(A) := RK(B) - RK(C)				*/
 OP_MUL,/*	A B C	R(A) := RK(B) * RK(C)				*/
-OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
-OP_IDIV,/*	A B C	R(A) := RK(B) // RK(C)				*/
 OP_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
 OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
+OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
+OP_IDIV,/*	A B C	R(A) := RK(B) // RK(C)				*/
+OP_BAND,/*	A B C	R(A) := RK(B) & RK(C)				*/
+OP_BOR,/*	A B C	R(A) := RK(B) | RK(C)				*/
+OP_BXOR,/*	A B C	R(A) := RK(B) ~ RK(C)				*/
+OP_SHL,/*	A B C	R(A) := RK(B) << RK(C)				*/
+OP_SHR,/*	A B C	R(A) := RK(B) >> RK(C)				*/
 OP_UNM,/*	A B	R(A) := -R(B)					*/
+OP_BNOT,/*	A B	R(A) := ~R(B)					*/
 OP_NOT,/*	A B	R(A) := not R(B)				*/
 OP_LEN,/*	A B	R(A) := length of R(B)				*/

src/loslib.c+42−18

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: loslib.c,v 1.41 2013/05/14 15:57:11 roberto Exp $	2	** $Id: loslib.c,v 1.45 2014/03/20 19:18:54 roberto Exp $
3	** Standard Operating System library	3	** Standard Operating System library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -20,29 +20,44 @@ · 14 unmodified lines
20	#include "lualib.h"	20	#include "lualib.h"
21		21
22		22
		23	#if !defined(LUA_STRFTIMEOPTIONS) /* { */
23	/*	24	/*
24	** list of valid conversion specifiers for the 'strftime' function	25	** list of valid conversion specifiers for the 'strftime' function
25	*/	26	*/
26	#if !defined(LUA_STRFTIMEOPTIONS)
27		27
28	#if !defined(LUA_USE_POSIX)	28	#if !defined(LUA_USE_POSIX)
29	#define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" }	29	#define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" }
30	#else	30	#else
31	#define LUA_STRFTIMEOPTIONS \	31	#define LUA_STRFTIMEOPTIONS \
32	{ "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "" \	32	{ "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "", \
33	"", "E", "cCxXyY", \	33	"E", "cCxXyY", \
34	"O", "deHImMSuUVwWy" }	34	"O", "deHImMSuUVwWy" }
35	#endif	35	#endif
36		36
37	#endif	37	#endif /* } */
		38
		39
		40
		41	#if !defined(l_time_t) /* { */
		42	/*
		43	** type to represent time_t in Lua
		44	*/
		45	#define l_timet lua_Integer
		46	#define l_pushtime(L,t) lua_pushinteger(L,(lua_Integer)(t))
		47	#define l_checktime(L,a) ((time_t)luaL_checkinteger(L,a))
38		48
		49	#endif /* } */
39		50
40		51
		52
		53	#if !defined(lua_tmpnam) /* { */
41	/*	54	/*
42	** By default, Lua uses tmpnam except when POSIX is available, where it	55	** By default, Lua uses tmpnam except when POSIX is available, where it
43	** uses mkstemp.	56	** uses mkstemp.
44	*/	57	*/
45	#if defined(LUA_USE_MKSTEMP)	58
		59	#if defined(LUA_USE_POSIX) /* { */
		60
46	#include <unistd.h>	61	#include <unistd.h>
47	#define LUA_TMPNAMBUFSIZE 32	62	#define LUA_TMPNAMBUFSIZE 32
48	#define lua_tmpnam(b,e) { \	63	#define lua_tmpnam(b,e) { \
@@ -51,29 +66,38 @@ · 2 unmodified lines
51	if (e != -1) close(e); \	66	if (e != -1) close(e); \
52	e = (e == -1); }	67	e = (e == -1); }
53		68
54	#elif !defined(lua_tmpnam)	69	#else /* }{ */
55		70
		71	/* ANSI definitions */
56	#define LUA_TMPNAMBUFSIZE L_tmpnam	72	#define LUA_TMPNAMBUFSIZE L_tmpnam
57	#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }	73	#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }
58		74
59	#endif	75	#endif /* } */
		76
		77	#endif /* } */
		78
60		79
61		80
		81	#if !defined(l_gmtime) /* { */
62	/*	82	/*
63	** By default, Lua uses gmtime/localtime, except when POSIX is available,	83	** By default, Lua uses gmtime/localtime, except when POSIX is available,
64	** where it uses gmtime_r/localtime_r	84	** where it uses gmtime_r/localtime_r
65	*/	85	*/
66	#if defined(LUA_USE_GMTIME_R)	86
		87	#if defined(LUA_USE_POSIX) /* { */
67		88
68	#define l_gmtime(t,r) gmtime_r(t,r)	89	#define l_gmtime(t,r) gmtime_r(t,r)
69	#define l_localtime(t,r) localtime_r(t,r)	90	#define l_localtime(t,r) localtime_r(t,r)
70		91
71	#elif !defined(l_gmtime)	92	#else /* }{ */
72		93
		94	/* ANSI definitions */
73	#define l_gmtime(t,r) ((void)r, gmtime(t))	95	#define l_gmtime(t,r) ((void)r, gmtime(t))
74	#define l_localtime(t,r) ((void)r, localtime(t))	96	#define l_localtime(t,r) ((void)r, localtime(t))
75		97
76	#endif	98	#endif /* } */
		99
		100	#endif /* } */
77		101
78		102
79		103
@@ -147,8 +171,7 @@ static void setboolfield (lua_State L, const char key, int value) { · 67 unmodified lines
147		171
148	static int getboolfield (lua_State L, const char key) {	172	static int getboolfield (lua_State L, const char key) {
149	int res;	173	int res;
150	lua_getfield(L, -1, key);	174	res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1);
151	res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
152	lua_pop(L, 1);	175	lua_pop(L, 1);
153	return res;	176	return res;
154	}	177	}
@@ -194,7 +217,7 @@ static const char checkoption (lua_State L, const char conv, char buff) { · 39 unmodified lines
194		217
195	static int os_date (lua_State *L) {	218	static int os_date (lua_State *L) {
196	const char *s = luaL_optstring(L, 1, "%c");	219	const char *s = luaL_optstring(L, 1, "%c");
197	time_t t = luaL_opt(L, (time_t)luaL_checkinteger, 2, time(NULL));	220	time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
198	struct tm tmr, *stm;	221	struct tm tmr, *stm;
199	if (s == '!') { / UTC? */	222	if (s == '!') { / UTC? */
200	stm = l_gmtime(&t, &tmr);	223	stm = l_gmtime(&t, &tmr);
@@ -255,17 +278,18 @@ static int os_time (lua_State *L) { · 54 unmodified lines
255	ts.tm_isdst = getboolfield(L, "isdst");	278	ts.tm_isdst = getboolfield(L, "isdst");
256	t = mktime(&ts);	279	t = mktime(&ts);
257	}	280	}
258	if (t == (time_t)(-1))	281	if (t != (time_t)(l_timet)t)
		282	luaL_error(L, "time result cannot be represented in this Lua instalation");
		283	else if (t == (time_t)(-1))
259	lua_pushnil(L);	284	lua_pushnil(L);
260	else	285	else
261	lua_pushinteger(L, t);	286	l_pushtime(L, t);
262	return 1;	287	return 1;
263	}	288	}
264		289
265		290
266	static int os_difftime (lua_State *L) {	291	static int os_difftime (lua_State *L) {
267	lua_pushnumber(L, difftime((time_t)(luaL_checkinteger(L, 1)),	292	lua_pushnumber(L, difftime((l_checktime(L, 1)), (l_checktime(L, 2))));
268	(time_t)(luaL_optinteger(L, 2, 0))));
269	return 1;	293	return 1;
270	}	294	}
271		295

src/lparser.c+37−37

 /*
-** $Id: lparser.c,v 2.133 2013/04/26 13:07:53 roberto Exp $
+** $Id: lparser.c,v 2.138 2013/12/30 20:47:58 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 #define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
+/* because all strings are unified by the scanner, the parser
+   can use pointer equality for string equality */
+#define eqstr(a,b)	((a) == (b))
 /*
 ** nodes for block list (list of active blocks)
 static void expr (LexState *ls, expdesc *v);
-static void anchor_token (LexState *ls) {
-  /* last token from outer function must be EOS */
-  lua_assert(ls->fs != NULL || ls->t.token == TK_EOS);
-  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
-    TString *ts = ls->t.seminfo.ts;
-    luaX_newstring(ls, getstr(ts), ts->tsv.len);
-  }
-}
 /* semantic error */
 static l_noret semerror (LexState *ls, const char *msg) {
   ls->t.token = 0;  /* remove 'near to' from final message */
   int i;
   Upvaldesc *up = fs->f->upvalues;
   for (i = 0; i < fs->nups; i++) {
-    if (luaS_eqstr(up[i].name, name)) return i;
+    if (eqstr(up[i].name, name)) return i;
   }
   return -1;  /* not found */
 }
 static int searchvar (FuncState *fs, TString *n) {
   int i;
   for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
-    if (luaS_eqstr(n, getlocvar(fs, i)->varname))
+    if (eqstr(n, getlocvar(fs, i)->varname))
       return i;
   }
   return -1;  /* not found */
   FuncState *fs = ls->fs;
   Labellist *gl = &ls->dyd->gt;
   Labeldesc *gt = &gl->arr[g];
-  lua_assert(luaS_eqstr(gt->name, label->name));
+  lua_assert(eqstr(gt->name, label->name));
   if (gt->nactvar < label->nactvar) {
     TString *vname = getlocvar(fs, gt->nactvar)->varname;
     const char *msg = luaO_pushfstring(ls->L,
   /* check labels in current block for a match */
   for (i = bl->firstlabel; i < dyd->label.n; i++) {
     Labeldesc *lb = &dyd->label.arr[i];
-    if (luaS_eqstr(lb->name, gt->name)) {  /* correct label? */
+    if (eqstr(lb->name, gt->name)) {  /* correct label? */
       if (gt->nactvar > lb->nactvar &&
           (bl->upval || dyd->label.n > bl->firstlabel))
         luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
   Labellist *gl = &ls->dyd->gt;
   int i = ls->fs->bl->firstgoto;
   while (i < gl->n) {
-    if (luaS_eqstr(gl->arr[i].name, lb->name))
+    if (eqstr(gl->arr[i].name, lb->name))
       closegoto(ls, i, lb);
     else
       i++;
 static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
-  lua_State *L = ls->L;
   Proto *f;
   fs->prev = ls->fs;  /* linked list of funcstates */
   fs->ls = ls;
   f = fs->f;
   f->source = ls->source;
   f->maxstacksize = 2;  /* registers 0/1 are always valid */
-  fs->h = luaH_new(L);
-  /* anchor table of constants (to avoid being collected) */
-  sethvalue2s(L, L->top, fs->h);
-  incr_top(L);
   enterblock(fs, bl, 0);
 }
   f->sizeupvalues = fs->nups;
   lua_assert(fs->bl == NULL);
   ls->fs = fs->prev;
-  /* last token read was anchored in defunct function; must re-anchor it */
-  anchor_token(ls);
-  L->top--;  /* pop table of constants */
   luaC_checkGC(L);
 }
   switch (op) {
     case TK_NOT: return OPR_NOT;
     case '-': return OPR_MINUS;
+    case '~': return OPR_BNOT;
     case '#': return OPR_LEN;
     default: return OPR_NOUNOPR;
   }
     case '+': return OPR_ADD;
     case '-': return OPR_SUB;
     case '*': return OPR_MUL;
-    case '/': return OPR_DIV;
-    case TK_IDIV: return OPR_IDIV;
     case '%': return OPR_MOD;
     case '^': return OPR_POW;
+    case '/': return OPR_DIV;
+    case TK_IDIV: return OPR_IDIV;
+    case '&': return OPR_BAND;
+    case '|': return OPR_BOR;
+    case '~': return OPR_BXOR;
+    case TK_SHL: return OPR_SHL;
+    case TK_SHR: return OPR_SHR;
     case TK_CONCAT: return OPR_CONCAT;
     case TK_NE: return OPR_NE;
     case TK_EQ: return OPR_EQ;
   lu_byte left;  /* left priority for each binary operator */
   lu_byte right; /* right priority */
 } priority[] = {  /* ORDER OPR */
-   {6, 6}, {6, 6},  /* '+' '-' */
+   {10, 10}, {10, 10},           /* '+' '-' */
-   {7, 7}, {7, 7}, {7, 7}, {7, 7},  /* '*' '/' '//' '%' */
+   {11, 11}, {11, 11},           /* '*' '%' */
-   {10, 9}, {5, 4},                 /* ^, .. (right associative) */
+   {14, 13},                  /* '^' (right associative) */
-   {3, 3}, {3, 3}, {3, 3},          /* ==, <, <= */
+   {11, 11}, {11, 11},           /* '/' '//' */
-   {3, 3}, {3, 3}, {3, 3},          /* ~=, >, >= */
+   {6, 6}, {4, 4}, {5, 5},   /* '&' '|' '~' */
-   {2, 2}, {1, 1}                   /* and, or */
+   {7, 7}, {7, 7},           /* '<<' '>>' */
+   {9, 8},                   /* '..' (right associative) */
+   {3, 3}, {3, 3}, {3, 3},   /* ==, <, <= */
+   {3, 3}, {3, 3}, {3, 3},   /* ~=, >, >= */
+   {2, 2}, {1, 1}            /* and, or */
 };
-#define UNARY_PRIORITY	8  /* priority for unary operators */
+#define UNARY_PRIORITY	12  /* priority for unary operators */
 /*
 static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
   int i;
   for (i = fs->bl->firstlabel; i < ll->n; i++) {
-    if (luaS_eqstr(label, ll->arr[i].name)) {
+    if (eqstr(label, ll->arr[i].name)) {
       const char *msg = luaO_pushfstring(fs->ls->L,
                           "label " LUA_QS " already defined on line %d",
                           getstr(label), ll->arr[i].line);
   LexState lexstate;
   FuncState funcstate;
   Closure *cl = luaF_newLclosure(L, 1);  /* create main closure */
-  /* anchor closure (to avoid being collected) */
+  setclLvalue(L, L->top, cl);  /* anchor it (to avoid being collected) */
-  setclLvalue(L, L->top, cl);
+  incr_top(L);
+  lexstate.h = luaH_new(L);  /* create table for scanner */
+  sethvalue(L, L->top, lexstate.h);  /* anchor it */
   incr_top(L);
   funcstate.f = cl->l.p = luaF_newproto(L);
   funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
+  luaC_objbarrier(L, funcstate.f, funcstate.f->source);
   lexstate.buff = buff;
   lexstate.dyd = dyd;
   dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
   lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
   /* all scopes should be correctly finished */
   lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
-  return cl;  /* it's on the stack too */
+  L->top--;  /* remove scanner's table */
+  return cl;  /* closure is on the stack, too */
 }

src/lparser.h+1−2

 /*
-** $Id: lparser.h,v 1.71 2013/04/16 18:46:28 roberto Exp $
+** $Id: lparser.h,v 1.72 2013/08/30 16:01:37 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 /* state needed to generate code for a given function */
 typedef struct FuncState {
   Proto *f;  /* current function header */
-  Table *h;  /* table to find (and reuse) elements in `k' */
   struct FuncState *prev;  /* enclosing function */
   struct LexState *ls;  /* lexical state */
   struct BlockCnt *bl;  /* chain of current blocks */

src/lstate.c+53−32

 /*
-** $Id: lstate.c,v 2.99 2012/10/02 17:40:53 roberto Exp $
+** $Id: lstate.c,v 2.121 2014/02/18 13:46:26 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 #define LUAI_GCPAUSE	200  /* 200% */
 #endif
-#if !defined(LUAI_GCMAJOR)
-#define LUAI_GCMAJOR	200  /* 200% */
-#endif
 #if !defined(LUAI_GCMUL)
 #define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
 #endif
 }
+/*
+** free all CallInfo structures not in use by a thread
+*/
 void luaE_freeCI (lua_State *L) {
   CallInfo *ci = L->ci;
   CallInfo *next = ci->next;
 }
+/*
+** free half of the CallInfo structures not in use by a thread
+*/
+void luaE_shrinkCI (lua_State *L) {
+  CallInfo *ci = L->ci;
+  while (ci->next != NULL) {  /* while there is 'next' */
+    CallInfo *next2 = ci->next->next;  /* next's next */
+    if (next2 == NULL) break;
+    luaM_free(L, ci->next);  /* remove next */
+    ci->next = next2;  /* remove 'next' from the list */
+    next2->previous = ci;
+    ci = next2;
+  }
+}
 static void stack_init (lua_State *L1, lua_State *L) {
   int i; CallInfo *ci;
   /* initialize stack array */
 ** Create registry table and its predefined values
 */
 static void init_registry (lua_State *L, global_State *g) {
-  TValue mt;
+  TValue temp;
   /* create registry */
   Table *registry = luaH_new(L);
   sethvalue(L, &g->l_registry, registry);
   luaH_resize(L, registry, LUA_RIDX_LAST, 0);
   /* registry[LUA_RIDX_MAINTHREAD] = L */
-  setthvalue(L, &mt, L);
+  setthvalue(L, &temp, L);  /* temp = L */
-  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt);
+  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &temp);
   /* registry[LUA_RIDX_GLOBALS] = table of globals */
-  sethvalue(L, &mt, luaH_new(L));
+  sethvalue(L, &temp, luaH_new(L));  /* temp = new table (global table) */
-  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt);
+  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &temp);
 }
 /*
-** open parts of the state that may cause memory-allocation errors
+** open parts of the state that may cause memory-allocation errors.
+** ('g->version' != NULL flags that the state was completely build)
 */
 static void f_luaopen (lua_State *L, void *ud) {
   global_State *g = G(L);
   luaX_init(L);
   /* pre-create memory-error message */
   g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
-  luaS_fix(g->memerrmsg);  /* it should never be collected */
+  luaC_fix(L, obj2gco(g->memerrmsg));  /* it should never be collected */
   g->gcrunning = 1;  /* allow gc */
+  g->version = lua_version(NULL);
+  luai_userstateopen(L);
 }
 /*
-** preinitialize a state with consistent values without allocating
+** preinitialize a thread with consistent values without allocating
 ** any memory (to avoid errors)
 */
-static void preinit_state (lua_State *L, global_State *g) {
+static void preinit_thread (lua_State *L, global_State *g) {
   G(L) = g;
   L->stack = NULL;
   L->ci = NULL;
   L->stacksize = 0;
+  L->twups = L;  /* thread has no upvalues */
   L->errorJmp = NULL;
   L->nCcalls = 0;
   L->hook = NULL;
   global_State *g = G(L);
   luaF_close(L, L->stack);  /* close all upvalues for this thread */
   luaC_freeallobjects(L);  /* collect all objects */
+  if (g->version)  /* closing a fully built state? */
+    luai_userstateclose(L);
   luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
   luaZ_freebuffer(L, &g->buff);
   freestack(L);
 LUA_API lua_State *lua_newthread (lua_State *L) {
+    global_State *g = G(L);
   lua_State *L1;
   lua_lock(L);
   luaC_checkGC(L);
-  L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th;
+  /* create new thread */
+  L1 = &cast(LX *, luaM_newobject(L, LUA_TTHREAD, sizeof(LX)))->l;
+  L1->marked = luaC_white(g);
+  L1->tt = LUA_TTHREAD;
+  /* link it on list 'allgc' */
+  L1->next = g->allgc;
+  g->allgc = obj2gco(L1);
   setthvalue(L, L->top, L1);
   api_incr_top(L);
-  preinit_state(L1, G(L));
+  preinit_thread(L1, g);
   L1->hookmask = L->hookmask;
   L1->basehookcount = L->basehookcount;
   L1->hook = L->hook;
   g = &l->g;
   L->next = NULL;
   L->tt = LUA_TTHREAD;
-  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
+  g->currentwhite = bitmask(WHITE0BIT);
   L->marked = luaC_white(g);
-  g->gckind = KGC_NORMAL;
+  preinit_thread(L, g);
-  preinit_state(L, g);
   g->frealloc = f;
   g->ud = ud;
   g->mainthread = L;
   g->seed = makeseed(L);
-  g->uvhead.u.l.prev = &g->uvhead;
-  g->uvhead.u.l.next = &g->uvhead;
   g->gcrunning = 0;  /* no GC while building state */
   g->GCestimate = 0;
-  g->strt.size = 0;
+  g->strt.size = g->strt.nuse = 0;
-  g->strt.nuse = 0;
   g->strt.hash = NULL;
   setnilvalue(&g->l_registry);
   luaZ_initbuffer(L, &g->buff);
   g->panic = NULL;
-  g->version = lua_version(NULL);
+  g->version = NULL;
   g->gcstate = GCSpause;
-  g->allgc = NULL;
+  g->gckind = KGC_NORMAL;
-  g->finobj = NULL;
+  g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
-  g->tobefnz = NULL;
+  g->sweepgc = NULL;
-  g->sweepgc = g->sweepfin = NULL;
   g->gray = g->grayagain = NULL;
   g->weak = g->ephemeron = g->allweak = NULL;
+  g->twups = NULL;
   g->totalbytes = sizeof(LG);
   g->GCdebt = 0;
+  g->gcfinnum = 0;
   g->gcpause = LUAI_GCPAUSE;
-  g->gcmajorinc = LUAI_GCMAJOR;
   g->gcstepmul = LUAI_GCMUL;
   for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
   if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
     close_state(L);
     L = NULL;
   }
-  else
-    luai_userstateopen(L);
   return L;
 }
 LUA_API void lua_close (lua_State *L) {
   L = G(L)->mainthread;  /* only the main thread can be closed */
   lua_lock(L);
-  luai_userstateclose(L);
   close_state(L);
 }

src/lstate.h+19−30

 /*
-** $Id: lstate.h,v 2.82 2012/07/02 13:37:04 roberto Exp $
+** $Id: lstate.h,v 2.102 2014/02/18 13:46:26 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 /*
-** Some notes about garbage-collected objects:  All objects in Lua must
+** Some notes about garbage-collected objects: All objects in Lua must
-** be kept somehow accessible until being freed.
+** be kept somehow accessible until being freed, so all objects always
+** belong to one (and only one) of these lists, using field 'next' of
+** the 'CommonHeader' for the link:
 **
-** Lua keeps most objects linked in list g->allgc. The link uses field
+** allgc: all objects not marked for finalization;
-** 'next' of the CommonHeader.
+** finobj: all objects marked for finalization;
-**
+** tobefnz: all objects ready to be finalized;
-** Strings are kept in several lists headed by the array g->strt.hash.
+** fixedgc: all objects that are not to be collected (currently
-**
+** only small strings, such as reserved words).
-** Open upvalues are not subject to independent garbage collection. They
-** are collected together with their respective threads. Lua keeps a
-** double-linked list with all open upvalues (g->uvhead) so that it can
-** mark objects referred by them. (They are always gray, so they must
-** be remarked in the atomic step. Usually their contents would be marked
-** when traversing the respective threads, but the thread may already be
-** dead, while the upvalue is still accessible through closures.)
-**
-** Objects with finalizers are kept in the list g->finobj.
-**
-** The list g->tobefnz links all objects being finalized.
 */
 /* kinds of Garbage Collection */
 #define KGC_NORMAL	0
 #define KGC_EMERGENCY	1	/* gc was forced by an allocation failure */
-#define KGC_GEN		2	/* generational collection */
 typedef struct stringtable {
-  GCObject **hash;
+  TString **hash;
-  lu_int32 nuse;  /* number of elements */
+  int nuse;  /* number of elements */
   int size;
 } stringtable;
   lu_byte gcstate;  /* state of garbage collector */
   lu_byte gckind;  /* kind of GC running */
   lu_byte gcrunning;  /* true if GC is running */
-  int sweepstrgc;  /* position of sweep in `strt' */
   GCObject *allgc;  /* list of all collectable objects */
+  GCObject **sweepgc;  /* current position of sweep in list */
   GCObject *finobj;  /* list of collectable objects with finalizers */
-  GCObject **sweepgc;  /* current position of sweep in list 'allgc' */
-  GCObject **sweepfin;  /* current position of sweep in list 'finobj' */
   GCObject *gray;  /* list of gray objects */
   GCObject *grayagain;  /* list of objects to be traversed atomically */
   GCObject *weak;  /* list of tables with weak values */
   GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */
   GCObject *allweak;  /* list of all-weak tables */
   GCObject *tobefnz;  /* list of userdata to be GC */
-  UpVal uvhead;  /* head of double-linked list of all open upvalues */
+  GCObject *fixedgc;  /* list of objects not to be collected */
+  struct lua_State *twups;  /* list of threads with open upvalues */
   Mbuffer buff;  /* temporary buffer for string concatenation */
+  unsigned int gcfinnum;  /* number of finalizers to call in each GC step */
   int gcpause;  /* size of pause between successive GCs */
-  int gcmajorinc;  /* pause between major collections (only in gen. mode) */
   int gcstepmul;  /* GC `granularity' */
   lua_CFunction panic;  /* to be called in unprotected errors */
   struct lua_State *mainthread;
   int basehookcount;
   int hookcount;
   lua_Hook hook;
-  GCObject *openupval;  /* list of open upvalues in this stack */
+  UpVal *openupval;  /* list of open upvalues in this stack */
   GCObject *gclist;
+  struct lua_State *twups;  /* list of threads with open upvalues */
   struct lua_longjmp *errorJmp;  /* current error recover point */
   ptrdiff_t errfunc;  /* current error handling function (stack index) */
   CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
   union Closure cl;
   struct Table h;
   struct Proto p;
-  struct UpVal uv;
   struct lua_State th;  /* thread */
 };
 	check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl))
 #define gco2t(o)	check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
 #define gco2p(o)	check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
-#define gco2uv(o)	check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
 #define gco2th(o)	check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
 /* macro to convert any Lua object into a GCObject */
 LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
 LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
 LUAI_FUNC void luaE_freeCI (lua_State *L);
+LUAI_FUNC void luaE_shrinkCI (lua_State *L);
 #endif

src/lstring.c+46−55

 /*
-** $Id: lstring.c,v 2.27 2013/06/19 14:27:00 roberto Exp $
+** $Id: lstring.c,v 2.38 2014/03/19 18:51:42 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 #include "lua.h"
+#include "ldebug.h"
+#include "ldo.h"
 #include "lmem.h"
 #include "lobject.h"
 #include "lstate.h"
 #include "lstring.h"
 /*
 ** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to
 ** compute its hash
 }
-/*
-** equality for strings
-*/
-int luaS_eqstr (TString *a, TString *b) {
-  return (a->tsv.tt == b->tsv.tt) &&
-         (a->tsv.tt == LUA_TSHRSTR ? eqshrstr(a, b) : luaS_eqlngstr(a, b));
-}
 unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
   unsigned int h = seed ^ cast(unsigned int, l);
   size_t l1;
 void luaS_resize (lua_State *L, int newsize) {
   int i;
   stringtable *tb = &G(L)->strt;
-  /* cannot resize while GC is traversing strings */
+  if (newsize > tb->size) {  /* grow table if needed */
-  luaC_runtilstate(L, ~bitmask(GCSsweepstring));
+    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
-  if (newsize > tb->size) {
+    for (i = tb->size; i < newsize; i++)
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
+      tb->hash[i] = NULL;
-    for (i = tb->size; i < newsize; i++) tb->hash[i] = NULL;
   }
-  /* rehash */
+  for (i = 0; i < tb->size; i++) {  /* rehash */
-  for (i=0; i<tb->size; i++) {
+    TString *p = tb->hash[i];
-    GCObject *p = tb->hash[i];
     tb->hash[i] = NULL;
     while (p) {  /* for each node in the list */
-      GCObject *next = gch(p)->next;  /* save next */
+      TString *hnext = p->tsv.hnext;  /* save next */
-      unsigned int h = lmod(gco2ts(p)->hash, newsize);  /* new position */
+      unsigned int h = lmod(p->tsv.hash, newsize);  /* new position */
-      gch(p)->next = tb->hash[h];  /* chain it */
+      p->tsv.hnext = tb->hash[h];  /* chain it */
       tb->hash[h] = p;
-      resetoldbit(p);  /* see MOVE OLD rule */
+      p = hnext;
-      p = next;
     }
   }
-  if (newsize < tb->size) {
+  if (newsize < tb->size) {  /* shrink table if needed */
-    /* shrinking slice must be empty */
+    /* vanishing slice should be empty */
     lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
+    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
   }
   tb->size = newsize;
 }
 /*
 ** creates a new string object
 */
 static TString *createstrobj (lua_State *L, const char *str, size_t l,
-                              int tag, unsigned int h, GCObject **list) {
+                              int tag, unsigned int h) {
   TString *ts;
   size_t totalsize;  /* total size of TString object */
   totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
-  ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts;
+  ts = &luaC_newobj(L, tag, totalsize)->ts;
   ts->tsv.len = l;
   ts->tsv.hash = h;
   ts->tsv.extra = 0;
 }
-/*
+LUAI_FUNC void luaS_remove (lua_State *L, TString *ts) {
-** creates a new short string, inserting it into string table
-*/
-static TString *newshrstr (lua_State *L, const char *str, size_t l,
-                                       unsigned int h) {
-  GCObject **list;  /* (pointer to) list where it will be inserted */
   stringtable *tb = &G(L)->strt;
-  TString *s;
+  TString **p = &tb->hash[lmod(ts->tsv.hash, tb->size)];
-  if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
+  while (*p != ts)  /* find previous element */
-    luaS_resize(L, tb->size*2);  /* too crowded */
+    p = &(*p)->tsv.hnext;
-  list = &tb->hash[lmod(h, tb->size)];
+  *p = (*p)->tsv.hnext;  /* remove element from its list */
-  s = createstrobj(L, str, l, LUA_TSHRSTR, h, list);
+  tb->nuse--;
-  tb->nuse++;
-  return s;
 }
 ** checks whether short string exists and reuses it or creates a new one
 */
 static TString *internshrstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
+  TString *ts;
   global_State *g = G(L);
   unsigned int h = luaS_hash(str, l, g->seed);
-  for (o = g->strt.hash[lmod(h, g->strt.size)];
+  TString **list = &g->strt.hash[lmod(h, g->strt.size)];
-       o != NULL;
+  for (ts = *list; ts != NULL; ts = ts->tsv.hnext) {
-       o = gch(o)->next) {
+    if (l == ts->tsv.len &&
-    TString *ts = rawgco2ts(o);
-    if (h == ts->tsv.hash &&
-        l == ts->tsv.len &&
         (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
-      if (isdead(G(L), o))  /* string is dead (but was not collected yet)? */
+      /* found! */
-        changewhite(o);  /* resurrect it */
+      if (isdead(g, obj2gco(ts)))  /* dead (but not collected yet)? */
+        changewhite(obj2gco(ts));  /* resurrect it */
       return ts;
     }
   }
-  return newshrstr(L, str, l, h);  /* not found; create a new string */
+  if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
+    luaS_resize(L, g->strt.size * 2);
+    list = &g->strt.hash[lmod(h, g->strt.size)];  /* recompute with new size */
+  }
+  ts = createstrobj(L, str, l, LUA_TSHRSTR, h);
+  ts->tsv.hnext = *list;
+  *list = ts;
+  g->strt.nuse++;
+  return ts;
 }
   else {
     if (l + 1 > (MAX_SIZE - sizeof(TString))/sizeof(char))
       luaM_toobig(L);
-    return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL);
+    return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed);
   }
 }
 }
-Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
+Udata *luaS_newudata (lua_State *L, size_t s) {
   Udata *u;
   if (s > MAX_SIZE - sizeof(Udata))
     luaM_toobig(L);
-  u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u;
+  u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s)->u;
   u->uv.len = s;
   u->uv.metatable = NULL;
-  u->uv.env = e;
+  setuservalue(L, u, luaO_nilobject);
   return u;
 }

src/lstring.h+3−5

 /*
-** $Id: lstring.h,v 1.49 2012/02/01 21:57:15 roberto Exp $
+** $Id: lstring.h,v 1.54 2014/03/19 18:51:42 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
                                  (sizeof(s)/sizeof(char))-1))
-#define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)
 /*
 ** test whether a string is a reserved word
 LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
 LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
-LUAI_FUNC int luaS_eqstr (TString *a, TString *b);
 LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
+LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
+LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s);
 LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
 LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);

src/lstrlib.c+222−5

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lstrlib.c,v 1.182 2013/06/20 15:06:51 roberto Exp $	2	** $Id: lstrlib.c,v 1.189 2014/03/21 14:26:44 roberto Exp $
3	** Standard library for string operations and pattern-matching	3	** Standard library for string operations and pattern-matching
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -116,7 +116,7 @@ static int str_rep (lua_State *L) { · 110 unmodified lines
116	lua_Integer n = luaL_checkinteger(L, 2);	116	lua_Integer n = luaL_checkinteger(L, 2);
117	const char *sep = luaL_optlstring(L, 3, "", &lsep);	117	const char *sep = luaL_optlstring(L, 3, "", &lsep);
118	if (n <= 0) lua_pushliteral(L, "");	118	if (n <= 0) lua_pushliteral(L, "");
119	else if (l + lsep < l \|\| l + lsep >= MAXSIZE / n) /* may overflow? */	119	else if (l + lsep < l \|\| l + lsep > MAXSIZE / n) /* may overflow? */
120	return luaL_error(L, "resulting string too large");	120	return luaL_error(L, "resulting string too large");
121	else {	121	else {
122	size_t totallen = n * l + (n - 1) * lsep;	122	size_t totallen = n * l + (n - 1) * lsep;
@@ -124,8 +124,9 @@ static int str_rep (lua_State *L) { · 1 unmodified line
124	char *p = luaL_buffinitsize(L, &b, totallen);	124	char *p = luaL_buffinitsize(L, &b, totallen);
125	while (n-- > 1) { /* first n-1 copies (followed by separator) */	125	while (n-- > 1) { /* first n-1 copies (followed by separator) */
126	memcpy(p, s, l * sizeof(char)); p += l;	126	memcpy(p, s, l * sizeof(char)); p += l;
127	if (lsep > 0) { /* avoid empty 'memcpy' (may be expensive) */	127	if (lsep > 0) { /* empty 'memcpy' is not that cheap */
128	memcpy(p, sep, lsep * sizeof(char)); p += lsep;	128	memcpy(p, sep, lsep * sizeof(char));
		129	p += lsep;
129	}	130	}
130	}	131	}
131	memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */	132	memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */
@@ -178,10 +179,11 @@ static int writer (lua_State L, const void b, size_t size, void *B) { · 46 unmodified lines
178		179
179	static int str_dump (lua_State *L) {	180	static int str_dump (lua_State *L) {
180	luaL_Buffer b;	181	luaL_Buffer b;
		182	int strip = lua_toboolean(L, 2);
181	luaL_checktype(L, 1, LUA_TFUNCTION);	183	luaL_checktype(L, 1, LUA_TFUNCTION);
182	lua_settop(L, 1);	184	lua_settop(L, 1);
183	luaL_buffinit(L,&b);	185	luaL_buffinit(L,&b);
184	if (lua_dump(L, writer, &b) != 0)	186	if (lua_dump(L, writer, &b, strip) != 0)
185	return luaL_error(L, "unable to dump given function");	187	return luaL_error(L, "unable to dump given function");
186	luaL_pushresult(&b);	188	luaL_pushresult(&b);
187	return 1;	189	return 1;
@@ -938,6 +940,217 @@ static int str_format (lua_State *L) { · 750 unmodified lines
938	/* }====================================================== */	940	/* }====================================================== */
939		941
940		942
		943	/*
		944	** {======================================================
		945	** PACK/UNPACK
		946	** =======================================================
		947	*/
		948
		949	/* maximum size for the binary representation of an integer */
		950	#define MAXINTSIZE 8
		951
		952
		953	/* number of bits in a character */
		954	#define NB CHAR_BIT
		955
		956	/* mask for one character (NB ones) */
		957	#define MC (((lua_Integer)1 << NB) - 1)
		958
		959	/* mask for one character without sign ((NB - 1) ones) */
		960	#define SM (((lua_Integer)1 << (NB - 1)) - 1)
		961
		962
		963	#define SZINT ((int)sizeof(lua_Integer))
		964
		965
		966	static union {
		967	int dummy;
		968	char little; /* true iff machine is little endian */
		969	} const nativeendian = {1};
		970
		971
		972	static int getendian (lua_State *L, int arg) {
		973	const char *endian = luaL_optstring(L, arg,
		974	(nativeendian.little ? "l" : "b"));
		975	if (endian == 'n') / native? */
		976	return nativeendian.little;
		977	luaL_argcheck(L, endian == 'l' \|\| endian == 'b', arg,
		978	"endianess must be 'l'/'b'/'n'");
		979	return (*endian == 'l');
		980	}
		981
		982
		983	static int getintsize (lua_State *L, int arg) {
		984	int size = luaL_optint(L, arg, 0);
		985	if (size == 0) size = SZINT;
		986	luaL_argcheck(L, 1 <= size && size <= MAXINTSIZE, arg,
		987	"integer size out of valid range");
		988	return size;
		989	}
		990
		991
		992	static int packint (char *buff, lua_Integer n, int littleendian, int size) {
		993	int i;
		994	if (littleendian) {
		995	for (i = 0; i < size - 1; i++) {
		996	buff[i] = (n & MC);
		997	n >>= NB;
		998	}
		999	}
		1000	else {
		1001	for (i = size - 1; i > 0; i--) {
		1002	buff[i] = (n & MC);
		1003	n >>= NB;
		1004	}
		1005	}
		1006	buff[i] = (n & MC); /* last byte */
		1007	/* test for overflow: OK if there are only zeros left in higher bytes,
		1008	or if there are only ones left and packed number is negative (signal
		1009	bit, the higher bit in last byte, is one) */
		1010	return ((n & ~MC) == 0 \|\| (n \| SM) == ~(lua_Integer)0);
		1011	}
		1012
		1013
		1014	static int packint_l (lua_State *L) {
		1015	char buff[MAXINTSIZE];
		1016	lua_Integer n = luaL_checkinteger(L, 1);
		1017	int size = getintsize(L, 2);
		1018	int endian = getendian(L, 3);
		1019	if (packint(buff, n, endian, size))
		1020	lua_pushlstring(L, buff, size);
		1021	else
		1022	luaL_error(L, "integer does not fit into given size (%d)", size);
		1023	return 1;
		1024	}
		1025
		1026
		1027	/* mask to check higher-order byte in a Lua integer */
		1028	#define HIGHERBYTE (MC << (NB * (SZINT - 1)))
		1029
		1030	/* mask to check higher-order byte + signal bit of next (lower) byte */
		1031	#define HIGHERBYTE1 (HIGHERBYTE \| (HIGHERBYTE >> 1))
		1032
		1033	static int unpackint (const char buff, lua_Integer res,
		1034	int littleendian, int size) {
		1035	lua_Integer n = 0;
		1036	int i;
		1037	for (i = 0; i < size; i++) {
		1038	if (i >= SZINT) { /* will throw away a byte? */
		1039	/* check for overflow: it is OK to throw away leading zeros for a
		1040	positive number, leading ones for a negative number, and a
		1041	leading zero byte to allow unsigned integers with a 1 in
		1042	its "signal bit" */
		1043	if (!((n & HIGHERBYTE1) == 0 \|\| /* zeros for positive number */
		1044	(n & HIGHERBYTE1) == HIGHERBYTE1 \|\| /* ones for negative number */
		1045	((n & HIGHERBYTE) == 0 && i == size - 1))) /* leading zero */
		1046	return 0; /* overflow */
		1047	}
		1048	n <<= NB;
		1049	n \|= (lua_Integer)(unsigned char)buff[littleendian ? size - 1 - i : i];
		1050	}
		1051	if (size < SZINT) { /* need sign extension? */
		1052	lua_Integer mask = (~(lua_Integer)0) << (size*NB - 1);
		1053	if (n & mask) /* negative value? */
		1054	n \|= mask; /* signal extension */
		1055	}
		1056	*res = n;
		1057	return 1;
		1058	}
		1059
		1060
		1061	static int unpackint_l (lua_State *L) {
		1062	lua_Integer res;
		1063	size_t len;
		1064	const char *s = luaL_checklstring(L, 1, &len);
		1065	lua_Integer pos = posrelat(luaL_optinteger(L, 2, 1), len);
		1066	int size = getintsize(L, 3);
		1067	int endian = getendian(L, 4);
		1068	luaL_argcheck(L, 1 <= pos && (size_t)pos + size - 1 <= len, 1,
		1069	"string too short");
		1070	if(unpackint(s + pos - 1, &res, endian, size))
		1071	lua_pushinteger(L, res);
		1072	else
		1073	luaL_error(L, "result does not fit into a Lua integer");
		1074	return 1;
		1075	}
		1076
		1077
		1078	static void correctendianess (lua_State L, char b, int size, int endianarg) {
		1079	int endian = getendian(L, endianarg);
		1080	if (endian != nativeendian.little) { /* not native endianess? */
		1081	int i = 0;
		1082	while (i < --size) {
		1083	char temp = b[i];
		1084	b[i++] = b[size];
		1085	b[size] = temp;
		1086	}
		1087	}
		1088	}
		1089
		1090
		1091	static int getfloatsize (lua_State *L, int arg) {
		1092	const char *size = luaL_optstring(L, arg, "n");
		1093	if (*size == 'n') return sizeof(lua_Number);
		1094	luaL_argcheck(L, size == 'd' \|\| size == 'f', arg,
		1095	"size must be 'f'/'d'/'n'");
		1096	return (*size == 'd' ? sizeof(double) : sizeof(float));
		1097	}
		1098
		1099
		1100	static int packfloat_l (lua_State *L) {
		1101	float f; double d;
		1102	char pn; / pointer to number */
		1103	lua_Number n = luaL_checknumber(L, 1);
		1104	int size = getfloatsize(L, 2);
		1105	if (size == sizeof(lua_Number))
		1106	pn = (char*)&n;
		1107	else if (size == sizeof(float)) {
		1108	f = (float)n;
		1109	pn = (char*)&f;
		1110	}
		1111	else { /* native lua_Number may be neither float nor double */
		1112	lua_assert(size == sizeof(double));
		1113	d = (double)n;
		1114	pn = (char*)&d;
		1115	}
		1116	correctendianess(L, pn, size, 3);
		1117	lua_pushlstring(L, pn, size);
		1118	return 1;
		1119	}
		1120
		1121
		1122	static int unpackfloat_l (lua_State *L) {
		1123	lua_Number res;
		1124	size_t len;
		1125	const char *s = luaL_checklstring(L, 1, &len);
		1126	lua_Integer pos = posrelat(luaL_optinteger(L, 2, 1), len);
		1127	int size = getfloatsize(L, 3);
		1128	luaL_argcheck(L, 1 <= pos && (size_t)pos + size - 1 <= len, 1,
		1129	"string too short");
		1130	if (size == sizeof(lua_Number)) {
		1131	memcpy(&res, s + pos - 1, size);
		1132	correctendianess(L, (char*)&res, size, 4);
		1133	}
		1134	else if (size == sizeof(float)) {
		1135	float f;
		1136	memcpy(&f, s + pos - 1, size);
		1137	correctendianess(L, (char*)&f, size, 4);
		1138	res = (lua_Number)f;
		1139	}
		1140	else { /* native lua_Number may be neither float nor double */
		1141	double d;
		1142	lua_assert(size == sizeof(double));
		1143	memcpy(&d, s + pos - 1, size);
		1144	correctendianess(L, (char*)&d, size, 4);
		1145	res = (lua_Number)d;
		1146	}
		1147	lua_pushnumber(L, res);
		1148	return 1;
		1149	}
		1150
		1151	/* }====================================================== */
		1152
		1153
941	static const luaL_Reg strlib[] = {	1154	static const luaL_Reg strlib[] = {
942	{"byte", str_byte},	1155	{"byte", str_byte},
943	{"char", str_char},	1156	{"char", str_char},
@@ -953,6 +1166,10 @@ static const luaL_Reg strlib[] = { · 9 unmodified lines
953	{"reverse", str_reverse},	1166	{"reverse", str_reverse},
954	{"sub", str_sub},	1167	{"sub", str_sub},
955	{"upper", str_upper},	1168	{"upper", str_upper},
		1169	{"packfloat", packfloat_l},
		1170	{"packint", packint_l},
		1171	{"unpackfloat", unpackfloat_l},
		1172	{"unpackint", unpackint_l},
956	{NULL, NULL}	1173	{NULL, NULL}
957	};	1174	};
958		1175

src/ltable.c+47−27

 /*
-** $Id: ltable.c,v 2.78 2013/06/20 15:02:49 roberto Exp $
+** $Id: ltable.c,v 2.84 2014/01/27 13:34:32 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 static const Node dummynode_ = {
   {NILCONSTANT},  /* value */
-  {{NILCONSTANT, NULL}}  /* key */
+  {{NILCONSTANT, 0}}  /* key */
 };
   if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
     return i-1;  /* yes; that's the index (corrected to C) */
   else {
+    int nx;
     Node *n = mainposition(t, key);
     for (;;) {  /* check whether `key' is somewhere in the chain */
       /* key may be dead already, but it is ok to use it in `next' */
         /* hash elements are numbered after array ones */
         return i + t->sizearray;
       }
-      else n = gnext(n);
+      nx = gnext(n);
-      if (n == NULL)
+      if (nx == 0)
         luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */
+      else n += nx;
     }
   }
 }
     t->node = luaM_newvector(L, size, Node);
     for (i=0; i<size; i++) {
       Node *n = gnode(t, i);
-      gnext(n) = NULL;
+      gnext(n) = 0;
       setnilvalue(gkey(n));
       setnilvalue(gval(n));
     }
 Table *luaH_new (lua_State *L) {
-  Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h;
+  Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table))->h;
   t->metatable = NULL;
   t->flags = cast_byte(~0);
   t->array = NULL;
   else if (ttisfloat(key)) {
     lua_Number n = fltvalue(key);
     lua_Integer k;
-    if (luai_numisnan(L, n))
+    if (luai_numisnan(n))
       luaG_runerror(L, "table index is NaN");
     if (numisinteger(n, &k)) {  /* index is int? */
       setivalue(&aux, k);
   mp = mainposition(t, key);
   if (!ttisnil(gval(mp)) || isdummy(mp)) {  /* main position is taken? */
     Node *othern;
-    Node *n = getfreepos(t);  /* get a free place */
+    Node *f = getfreepos(t);  /* get a free place */
-    if (n == NULL) {  /* cannot find a free place? */
+    if (f == NULL) {  /* cannot find a free place? */
       rehash(L, t, key);  /* grow table */
       /* whatever called 'newkey' take care of TM cache and GC barrier */
       return luaH_set(L, t, key);  /* insert key into grown table */
     }
-    lua_assert(!isdummy(n));
+    lua_assert(!isdummy(f));
     othern = mainposition(t, gkey(mp));
     if (othern != mp) {  /* is colliding node out of its main position? */
       /* yes; move colliding node into free position */
-      while (gnext(othern) != mp) othern = gnext(othern);  /* find previous */
+      while (othern + gnext(othern) != mp)  /* find previous */
-      gnext(othern) = n;  /* redo the chain with `n' in place of `mp' */
+        othern += gnext(othern);
-      *n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
+      gnext(othern) = f - othern;  /* re-chain with 'f' in place of 'mp' */
-      gnext(mp) = NULL;  /* now `mp' is free */
+      *f = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
+      if (gnext(mp) != 0) {
+        gnext(f) += mp - f;  /* correct 'next' */
+        gnext(mp) = 0;  /* now 'mp' is free */
+      }
       setnilvalue(gval(mp));
     }
     else {  /* colliding node is in its own main position */
       /* new node will go into free position */
-      gnext(n) = gnext(mp);  /* chain new position */
+      if (gnext(mp) != 0)
-      gnext(mp) = n;
+        gnext(f) = (mp + gnext(mp)) - f;  /* chain new position */
-      mp = n;
+      else lua_assert(gnext(f) == 0);
+      gnext(mp) = f - mp;
+      mp = f;
     }
   }
   setobj2t(L, gkey(mp), key);
-  luaC_barrierback(L, obj2gco(t), key);
+  luaC_barrierback(L, t, key);
   lua_assert(ttisnil(gval(mp)));
   return gval(mp);
 }
     return &t->array[key - 1];
   else {
     Node *n = hashint(t, key);
-    do {  /* check whether `key' is somewhere in the chain */
+    for (;;) {  /* check whether `key' is somewhere in the chain */
       if (ttisinteger(gkey(n)) && ivalue(gkey(n)) == key)
         return gval(n);  /* that's it */
-      else n = gnext(n);
+      else {
-    } while (n);
+        int nx = gnext(n);
+        if (nx == 0) break;
+        n += nx;
+      }
+    };
     return luaO_nilobject;
   }
 }
 const TValue *luaH_getstr (Table *t, TString *key) {
   Node *n = hashstr(t, key);
   lua_assert(key->tsv.tt == LUA_TSHRSTR);
-  do {  /* check whether `key' is somewhere in the chain */
+  for (;;) {  /* check whether `key' is somewhere in the chain */
     if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key))
       return gval(n);  /* that's it */
-    else n = gnext(n);
+    else {
-  } while (n);
+      int nx = gnext(n);
+      if (nx == 0) break;
+      n += nx;
+    }
+  };
   return luaO_nilobject;
 }
     }
     default: {
       Node *n = mainposition(t, key);
-      do {  /* check whether `key' is somewhere in the chain */
+      for (;;) {  /* check whether `key' is somewhere in the chain */
         if (luaV_rawequalobj(gkey(n), key))
           return gval(n);  /* that's it */
-        else n = gnext(n);
+        else {
-      } while (n);
+          int nx = gnext(n);
+          if (nx == 0) break;
+          n += nx;
+        }
+      };
       return luaO_nilobject;
     }
   }

src/ltable.h+6−1

 /*
-** $Id: ltable.h,v 2.17 2013/04/26 15:39:25 roberto Exp $
+** $Id: ltable.h,v 2.18 2013/08/30 16:01:37 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #define invalidateTMcache(t)	((t)->flags = 0)
+/* returns the key, given the value of a table entry */
+#define keyfromval(v) \
+  (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
 LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
 LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
                             TValue *value);

src/ltablib.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltablib.c,v 1.65 2013/03/07 18:17:24 roberto Exp $	2	** $Id: ltablib.c,v 1.66 2014/03/21 13:52:33 roberto Exp $
3	** Library for Table Manipulation	3	** Library for Table Manipulation
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -140,7 +140,7 @@ static int unpack (lua_State *L) { · 134 unmodified lines
140	e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));	140	e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));
141	if (i > e) return 0; /* empty range */	141	if (i > e) return 0; /* empty range */
142	n = e - i + 1; /* number of elements */	142	n = e - i + 1; /* number of elements */
143	if (n <= 0 \|\| !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */	143	if (n <= 0 \|\| !lua_checkstack(L, n)) /* n <= 0 means arithmetic overflow */
144	return luaL_error(L, "too many results to unpack");	144	return luaL_error(L, "too many results to unpack");
145	lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */	145	lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */
146	while (i++ < e) /* push arg[i + 1...e] */	146	while (i++ < e) /* push arg[i + 1...e] */

src/ltm.c+18−11

 /*
-** $Id: ltm.c,v 2.20 2013/05/06 17:19:11 roberto Exp $
+** $Id: ltm.c,v 2.25 2013/12/30 20:47:58 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
   "no value",
   "nil", "boolean", udatatypename, "number",
   "string", "table", "function", udatatypename, "thread",
-  "proto", "upval"  /* these last two cases are used for tests only */
+  "proto" /* this last case is used for tests only */
 };
   static const char *const luaT_eventname[] = {  /* ORDER TM */
     "__index", "__newindex",
     "__gc", "__mode", "__len", "__eq",
-    "__add", "__sub", "__mul", "__div", "__idiv", "__mod",
+    "__add", "__sub", "__mul", "__mod", "__pow",
-    "__pow", "__unm", "__lt", "__le",
+    "__div", "__idiv",
+    "__band", "__bor", "__bxor", "__shl", "__shr",
+    "__unm", "__bnot", "__lt", "__le",
     "__concat", "__call"
   };
   int i;
   for (i=0; i<TM_N; i++) {
     G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
-    luaS_fix(G(L)->tmname[i]);  /* never collect these names */
+    luaC_fix(L, obj2gco(G(L)->tmname[i]));  /* never collect these names */
   }
 }
 void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
                     StkId res, TMS event) {
   if (!luaT_callbinTM(L, p1, p2, res, event)) {
-    if (event == TM_CONCAT)
+    switch (event) {
-      luaG_concaterror(L, p1, p2);
+      case TM_CONCAT:
-    else if (event == TM_IDIV && ttisnumber(p1) && ttisnumber(p2))
+        luaG_concaterror(L, p1, p2);
-      luaG_tointerror(L, p1, p2);
+      case TM_IDIV: case TM_BAND: case TM_BOR: case TM_BXOR:
-    else
+      case TM_SHL: case TM_SHR: case TM_BNOT:
-      luaG_aritherror(L, p1, p2);
+        if (ttisnumber(p1) && ttisnumber(p2))
+          luaG_tointerror(L, p1, p2);
+        /* else go through */
+      default:
+        luaG_aritherror(L, p1, p2);
+    }
   }
 }

src/ltm.h+10−4

 /*
-** $Id: ltm.h,v 2.16 2013/04/29 16:56:50 roberto Exp $
+** $Id: ltm.h,v 2.19 2013/12/30 20:47:58 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
 /*
 * WARNING: if you change the order of this enumeration,
-* grep "ORDER TM"
+* grep "ORDER TM" and "ORDER OP"
 */
 typedef enum {
   TM_INDEX,
   TM_ADD,
   TM_SUB,
   TM_MUL,
-  TM_DIV,
-  TM_IDIV,
   TM_MOD,
   TM_POW,
+  TM_DIV,
+  TM_IDIV,
+  TM_BAND,
+  TM_BOR,
+  TM_BXOR,
+  TM_SHL,
+  TM_SHR,
   TM_UNM,
+  TM_BNOT,
   TM_LT,
   TM_LE,
   TM_CONCAT,

src/lua.c+69−31

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lua.c,v 1.206 2012/09/29 20:07:06 roberto Exp $	2	** $Id: lua.c,v 1.210 2014/02/26 15:27:56 roberto Exp $
3	** Lua stand-alone interpreter	3	** Lua stand-alone interpreter
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -31,28 +31,38 @@ · 25 unmodified lines
31	#define LUA_MAXINPUT 512	31	#define LUA_MAXINPUT 512
32	#endif	32	#endif
33		33
34	#if !defined(LUA_INIT)	34	#if !defined(LUA_INIT_VAR)
35	#define LUA_INIT "LUA_INIT"	35	#define LUA_INIT_VAR "LUA_INIT"
36	#endif	36	#endif
37		37
38	#define LUA_INITVERSION \	38	#define LUA_INITVARVERSION \
39	LUA_INIT "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR	39	LUA_INIT_VAR "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
40		40
41		41
42	/*	42	/*
43	** lua_stdin_is_tty detects whether the standard input is a 'tty' (that	43	** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
44	** is, whether we're running lua interactively).	44	** is, whether we're running lua interactively).
45	*/	45	*/
46	#if defined(LUA_USE_ISATTY)	46	#if !defined(lua_stdin_is_tty) /* { */
		47
		48	#if defined(LUA_USE_POSIX) /* { */
		49
47	#include <unistd.h>	50	#include <unistd.h>
48	#define lua_stdin_is_tty() isatty(0)	51	#define lua_stdin_is_tty() isatty(0)
49	#elif defined(LUA_WIN)	52
		53	#elif defined(LUA_WIN) /* }{ */
		54
50	#include <io.h>	55	#include <io.h>
51	#include <stdio.h>
52	#define lua_stdin_is_tty() _isatty(_fileno(stdin))	56	#define lua_stdin_is_tty() _isatty(_fileno(stdin))
53	#else	57
		58	#else /* }{ */
		59
		60	/* ANSI definition */
54	#define lua_stdin_is_tty() 1 /* assume stdin is a tty */	61	#define lua_stdin_is_tty() 1 /* assume stdin is a tty */
55	#endif	62
		63	#endif /* } */
		64
		65	#endif /* } */
56		66
57		67
58	/*	68	/*
@@ -61,9 +71,10 @@ · 2 unmodified lines
61	** lua_saveline defines how to "save" a read line in a "history".	71	** lua_saveline defines how to "save" a read line in a "history".
62	** lua_freeline defines how to free a line read by lua_readline.	72	** lua_freeline defines how to free a line read by lua_readline.
63	*/	73	*/
64	#if defined(LUA_USE_READLINE)	74	#if !defined(lua_readline) /* { */
		75
		76	#if defined(LUA_USE_READLINE) /* { */
65		77
66	#include <stdio.h>
67	#include <readline/readline.h>	78	#include <readline/readline.h>
68	#include <readline/history.h>	79	#include <readline/history.h>
69	#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)	80	#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)
@@ -72,7 +83,7 @@ · 2 unmodified lines
72	add_history(lua_tostring(L, idx)); /* add it to history */	83	add_history(lua_tostring(L, idx)); /* add it to history */
73	#define lua_freeline(L,b) ((void)L, free(b))	84	#define lua_freeline(L,b) ((void)L, free(b))
74		85
75	#elif !defined(lua_readline)	86	#else /* }{ */
76		87
77	#define lua_readline(L,b,p) \	88	#define lua_readline(L,b,p) \
78	((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \	89	((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \
@@ -80,7 +91,9 @@ · 1 unmodified line
80	#define lua_saveline(L,idx) { (void)L; (void)idx; }	91	#define lua_saveline(L,idx) { (void)L; (void)idx; }
81	#define lua_freeline(L,b) { (void)L; (void)b; }	92	#define lua_freeline(L,b) { (void)L; (void)b; }
82		93
83	#endif	94	#endif /* } */
		95
		96	#endif /* } */
84		97
85		98
86		99
@@ -257,20 +270,21 @@ static int incomplete (lua_State *L, int status) { · 170 unmodified lines
257	}	270	}
258		271
259		272
		273	/* prompt the user, read a line, and push it into the Lua stack */
260	static int pushline (lua_State *L, int firstline) {	274	static int pushline (lua_State *L, int firstline) {
261	char buffer[LUA_MAXINPUT];	275	char buffer[LUA_MAXINPUT];
262	char *b = buffer;	276	char *b = buffer;
263	size_t l;	277	size_t l;
264	const char *prmt = get_prompt(L, firstline);	278	const char *prmt = get_prompt(L, firstline);
265	int readstatus = lua_readline(L, b, prmt);	279	int readstatus = lua_readline(L, b, prmt);
266	lua_pop(L, 1); /* remove result from 'get_prompt' */
267	if (readstatus == 0)	280	if (readstatus == 0)
268	return 0; /* no input */	281	return 0; /* no input (prompt will be popped by caller) */
		282	lua_pop(L, 1); /* remove prompt */
269	l = strlen(b);	283	l = strlen(b);
270	if (l > 0 && b[l-1] == '\n') /* line ends with newline? */	284	if (l > 0 && b[l-1] == '\n') /* line ends with newline? */
271	b[l-1] = '\0'; /* remove it */	285	b[l-1] = '\0'; /* remove it */
272	if (firstline && b[0] == '=') /* first line starts with `=' ? */	286	if (firstline && b[0] == '=') /* for compatibility with 5.2, ... */
273	lua_pushfstring(L, "return %s", b+1); /* change it to `return' */	287	lua_pushfstring(L, "return %s", b + 1); /* change '=' to 'return' */
274	else	288	else
275	lua_pushstring(L, b);	289	lua_pushstring(L, b);
276	lua_freeline(L, b);	290	lua_freeline(L, b);
@@ -278,24 +292,48 @@ static int pushline (lua_State *L, int firstline) { · 1 unmodified line
278	}	292	}
279		293
280		294
281	static int loadline (lua_State *L) {	295	/* try to compile line on the stack as 'return <line>'; on return, stack
		296	has either compiled chunk or original line (if compilation failed) */
		297	static int addreturn (lua_State *L) {
282	int status;	298	int status;
283	lua_settop(L, 0);	299	size_t len; const char *line;
284	if (!pushline(L, 1))	300	lua_pushliteral(L, "return ");
285	return -1; /* no input */	301	lua_pushvalue(L, -2); /* duplicate line */
		302	lua_concat(L, 2); /* new line is "return ..." */
		303	line = lua_tolstring(L, -1, &len);
		304	if ((status = luaL_loadbuffer(L, line, len, "=stdin")) == LUA_OK)
		305	lua_remove(L, -3); /* remove original line */
		306	else
		307	lua_pop(L, 2); /* remove result from 'luaL_loadbuffer' and new line */
		308	return status;
		309	}
		310
		311
		312	/* read multiple lines until a complete line */
		313	static int multiline (lua_State *L) {
286	for (;;) { /* repeat until gets a complete line */	314	for (;;) { /* repeat until gets a complete line */
287	size_t l;	315	size_t len;
288	const char *line = lua_tolstring(L, 1, &l);	316	const char line = lua_tolstring(L, 1, &len); / get what it has */
289	status = luaL_loadbuffer(L, line, l, "=stdin");	317	int status = luaL_loadbuffer(L, line, len, "=stdin"); /* try it */
290	if (!incomplete(L, status)) break; /* cannot try to add lines? */	318	if (!incomplete(L, status) \|\| !pushline(L, 0))
291	if (!pushline(L, 0)) /* no more input? */	319	return status; /* cannot/should not try to add continuation line */
292	return -1;	320	lua_pushliteral(L, "\n"); /* add newline... */
293	lua_pushliteral(L, "\n"); /* add a new line... */
294	lua_insert(L, -2); /* ...between the two lines */	321	lua_insert(L, -2); /* ...between the two lines */
295	lua_concat(L, 3); /* join them */	322	lua_concat(L, 3); /* join them */
296	}	323	}
		324	}
		325
		326
		327	static int loadline (lua_State *L) {
		328	int status;
		329	lua_settop(L, 0);
		330	if (!pushline(L, 1))
		331	return -1; /* no input */
		332	if ((status = addreturn(L)) != LUA_OK) /* 'return ...' did not work? */
		333	status = multiline(L); /* try as command, maybe with continuation lines */
297	lua_saveline(L, 1);	334	lua_saveline(L, 1);
298	lua_remove(L, 1); /* remove line */	335	lua_remove(L, 1); /* remove line */
		336	lua_assert(lua_gettop(L) == 1);
299	return status;	337	return status;
300	}	338	}
301		339
@@ -421,10 +459,10 @@ static int runargs (lua_State L, char *argv, int n) { · 119 unmodified lines
421		459
422		460
423	static int handle_luainit (lua_State *L) {	461	static int handle_luainit (lua_State *L) {
424	const char *name = "=" LUA_INITVERSION;	462	const char *name = "=" LUA_INITVARVERSION;
425	const char *init = getenv(name + 1);	463	const char *init = getenv(name + 1);
426	if (init == NULL) {	464	if (init == NULL) {
427	name = "=" LUA_INIT;	465	name = "=" LUA_INIT_VAR;
428	init = getenv(name + 1); /* try alternative name */	466	init = getenv(name + 1); /* try alternative name */
429	}	467	}
430	if (init == NULL) return LUA_OK;	468	if (init == NULL) return LUA_OK;

src/lua.h+25−21

 /*
-** $Id: lua.h,v 1.292 2013/07/05 14:29:51 roberto Exp $
+** $Id: lua.h,v 1.302 2014/03/20 19:42:35 roberto Exp $
 ** Lua - A Scripting Language
 ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
 ** See Copyright Notice at the end of this file
 #define LUA_VERSION_MAJOR	"5"
 #define LUA_VERSION_MINOR	"3"
 #define LUA_VERSION_NUM		503
-#define LUA_VERSION_RELEASE	"0 (work1)"
+#define LUA_VERSION_RELEASE	"0 (work2)"
 #define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
 #define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
-#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2013 Lua.org, PUC-Rio"
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2014 Lua.org, PUC-Rio"
 #define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
 ** Comparison and arithmetic functions
 */
-#define LUA_OPADD	0	/* ORDER TM */
+#define LUA_OPADD	0	/* ORDER TM, ORDER OP */
 #define LUA_OPSUB	1
 #define LUA_OPMUL	2
-#define LUA_OPDIV	3
+#define LUA_OPMOD	3
-#define LUA_OPIDIV	4
+#define LUA_OPPOW	4
-#define LUA_OPMOD	5
+#define LUA_OPDIV	5
-#define LUA_OPPOW	6
+#define LUA_OPIDIV	6
-#define LUA_OPUNM	7
+#define LUA_OPBAND	7
+#define LUA_OPBOR	8
+#define LUA_OPBXOR	9
+#define LUA_OPSHL	10
+#define LUA_OPSHR	11
+#define LUA_OPUNM	12
+#define LUA_OPBNOT	13
 LUA_API void  (lua_arith) (lua_State *L, int op);
 /*
 ** get functions (Lua -> stack)
 */
-LUA_API void  (lua_getglobal) (lua_State *L, const char *var);
+LUA_API int (lua_getglobal) (lua_State *L, const char *var);
-LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API int (lua_gettable) (lua_State *L, int idx);
-LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
-LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API int (lua_rawget) (lua_State *L, int idx);
-LUA_API void  (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
-LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);
+LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
 LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
 LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
 LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
                                         const char *chunkname,
                                         const char *mode);
-LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
 /*
 #define LUA_GCSTEP		5
 #define LUA_GCSETPAUSE		6
 #define LUA_GCSETSTEPMUL	7
-#define LUA_GCSETMAJORINC	8
 #define LUA_GCISRUNNING		9
-#define LUA_GCGEN		10
-#define LUA_GCINC		11
 LUA_API int (lua_gc) (lua_State *L, int what, int data);
 LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
                                                int fidx2, int n2);
-LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
 LUA_API lua_Hook (lua_gethook) (lua_State *L);
 LUA_API int (lua_gethookmask) (lua_State *L);
 LUA_API int (lua_gethookcount) (lua_State *L);
 /******************************************************************************
-* Copyright (C) 1994-2013 Lua.org, PUC-Rio.
+* Copyright (C) 1994-2014 Lua.org, PUC-Rio.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the

src/luac.c+1−1

@@ -202,7 +202,7 @@ int main(int argc, char* argv[]) · 201 unmodified lines
202	return EXIT_SUCCESS;	202	return EXIT_SUCCESS;
203	}	203	}
204		204
205	#define nvalue(x) 0	205	#define nvalue(x) ((lua_Number)0)
206	#define ttypenv(x) ttnov(x)	206	#define ttypenv(x) ttnov(x)
207	/*	207	/*
208	** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $	208	** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $

src/luaconf.h+76−44

 /*
-** $Id: luaconf.h,v 1.185 2013/06/25 19:04:40 roberto Exp $
+** $Id: luaconf.h,v 1.193 2014/03/21 14:27:16 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
 */
+/*
+** ===================================================================
+@@ LUA_INT_INT / LUA_INT_LONG / LUA_INT_LONGLONG defines size for
+@* Lua integers;
+@@ LUA_REAL_FLOAT / LUA_REAL_DOUBLE / LUA_REAL_LONGDOUBLE defines size for
+@* Lua floats.
+**
+** These definitions set the numeric types for Lua. Lua should work
+** fine with 32-bit or 64-bit integers mixed with 32-bit or 64-bit
+** floats. The usual configurations are 64-bit integers and floats (the
+** default) and 32-bit integers and floats (Small Lua, for restricted
+** hardware).
+** =====================================================================
+*/
+#define LUA_INT_LONGLONG
+#define LUA_REAL_DOUBLE
 /*
 @@ LUA_ANSI controls the use of non-ansi features.
 ** CHANGE it (define it) if you want Lua to avoid the use of any
 #if defined(LUA_USE_LINUX)
+#define LUA_USE_C99
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
 #define LUA_USE_READLINE	/* needs some extra libraries */
-#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
-#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
-#define LUA_USE_LONGLONG	/* assume support for long long */
 #endif
 #if defined(LUA_USE_MACOSX)
+#define LUA_USE_C99
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* does not need -ldl */
 #define LUA_USE_READLINE	/* needs an extra library: -lreadline */
-#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
-#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
-#define LUA_USE_LONGLONG	/* assume support for long long */
 #endif
+/*
+@@ LUA_USE_C99 includes all functionality from C 99.
+** CHANGE it (define it) if your system is compatible.
+*/
+#if defined(LUA_USE_C99)
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#endif
 /*
 @@ LUA_USE_POSIX includes all functionality listed as X/Open System
 ** CHANGE it (define it) if your system is XSI compatible.
 */
 #if defined(LUA_USE_POSIX)
-#define LUA_USE_MKSTEMP
-#define LUA_USE_ISATTY
-#define LUA_USE_POPEN
-#define LUA_USE_ULONGJMP
-#define LUA_USE_GMTIME_R
 #endif
 #define LUA_CDIR	"!\\"
 #define LUA_PATH_DEFAULT  \
 		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
-		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" ".\\?.lua"
+		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
+		".\\?.lua;" ".\\?\\init.lua"
 #define LUA_CPATH_DEFAULT \
 		LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll"
 #define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR
 #define LUA_PATH_DEFAULT  \
 		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
-		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" "./?.lua"
+		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
+		"./?.lua;" "./?/init.lua"
 #define LUA_CPATH_DEFAULT \
 		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
 #endif			/* } */
 */
 #if defined(LUA_COMPAT_ALL)	/* { */
+/*
+@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
+*/
+#define LUA_COMPAT_BITLIB
 /*
 @@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
 ** You can replace it with 'table.unpack'.
 /*
 @@ LUAI_MAXSTACK limits the size of the Lua stack.
 ** CHANGE it if you need a different limit. This limit is arbitrary;
-** its only purpose is to stop Lua to consume unlimited stack
+** its only purpose is to stop Lua from consuming unlimited stack
 ** space (and to reserve some numbers for pseudo-indices).
 */
 #if LUAI_BITSINT >= 32
 #define LUAL_BUFFERSIZE		BUFSIZ
 /*
 ** {==================================================================
-** The following definitions set the numeric types for Lua.
+** Configuration for Numbers.
-** Lua should work fine with 32-bit or 64-bit integers mixed with
+** Change these definitions if no predefined LUA_REAL_* / LUA_INT_*
-** 32-bit or 64-bit floats. The usual configurations are 64-bit
+** satisfy your needs.
-** integers and floats (the default) and 32-bit integers and floats.
 ** ===================================================================
 */
-/*
-@@ LUA_INTSIZE defines size for Lua integer: 1=int, 2=long, 3=long long
-@@ LUA_FLOATSIZE defines size for Lua float: 1=float, 2=double, 3=long double
-** Default is long long + double
-*/
-#define LUA_INTSIZE		3
-#define LUA_FLOATSIZE		2
 /*
 @@ LUA_NUMBER is the floating-point type used by Lua.
 **
 @@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
 @@ LUA_NUMBER_SCAN is the format for reading floats.
 @@ LUA_NUMBER_FMT is the format for writing floats.
-@@ lua_number2str converts a floats to a string.
+@@ lua_number2str converts a float to a string.
 **
 @@ l_mathop allows the addition of an 'l' or 'f' to all math operations
 **
 @@ lua_str2number converts a decimal numeric string to a number.
 */
-#if LUA_FLOATSIZE == 1	/* { single float */
+#if defined(LUA_REAL_FLOAT)		/* { single float */
 #define LUA_NUMBER	float
 #define lua_str2number(s,p)	strtof((s), (p))
-#elif LUA_FLOATSIZE == 3	/* }{ long double */
+#elif defined(LUA_REAL_LONGDOUBLE)	/* }{ long double */
 #define LUA_NUMBER	long double
 #define lua_str2number(s,p)	strtold((s), (p))
-#else	/* }{ default: double */
+#elif defined(LUA_REAL_DOUBLE)		/* }{ double */
 #define LUA_NUMBER	double
 #define lua_str2number(s,p)	strtod((s), (p))
-#endif	/* } */
+#else					/* }{ */
+#error "numeric real type not defined"
+#endif					/* } */
 #if defined(LUA_ANSI)
 /* the following operations need the math library */
 #if defined(lobject_c) || defined(lvm_c)
 #include <math.h>
-#define luai_nummod(L,a,b)	((a) - l_floor((a)/(b))*(b))
+#define luai_nummod(L,a,b)	((void)L, (a) - l_floor((a)/(b))*(b))
-#define luai_numpow(L,a,b)	(l_mathop(pow)(a,b))
+#define luai_numpow(L,a,b)	((void)L, l_mathop(pow)(a,b))
 #endif
 /* these are quite standard operations */
 #define luai_numdiv(L,a,b)	((a)/(b))
 #define luai_numunm(L,a)	(-(a))
 #define luai_numeq(a,b)		((a)==(b))
-#define luai_numlt(L,a,b)	((a)<(b))
+#define luai_numlt(a,b)		((a)<(b))
-#define luai_numle(L,a,b)	((a)<=(b))
+#define luai_numle(a,b)		((a)<=(b))
-#define luai_numisnan(L,a)	(!luai_numeq((a), (a)))
+#define luai_numisnan(a)	(!luai_numeq((a), (a)))
 #endif
+/*
+** The following macro checks whether an operation is not safe to be
+** performed by the constant folder. It should result in zero only if
+** the operation is safe.
+*/
+#define luai_numinvalidop(op,a,b)	0
 /*
 @@ LUA_INTEGER is the integer type used by Lua.
 @@ lua_integer2str converts an integer to a string.
 */
-#if LUA_INTSIZE == 1	/* { int */
+#if defined(LUA_INT_INT)		/* { int */
 #define LUA_INTEGER		int
 #define LUA_INTEGER_FRMLEN	""
-#elif LUA_INTSIZE == 2	/* }{ long */
+#elif defined(LUA_INT_LONG)	/* }{ long */
 #define LUA_INTEGER		long
 #define LUA_INTEGER_FRMLEN	"l"
-#else	/* }{ default: long long */
+#elif defined(LUA_INT_LONGLONG)	/* }{ long long */
+#if defined(_WIN32)
+#define LUA_INTEGER		__int64
+#define LUA_INTEGER_FRMLEN	"I64"
+#else
 #define LUA_INTEGER		long long
 #define LUA_INTEGER_FRMLEN	"ll"
+#endif
-#endif	/* } */
+#else				/* }{ */
+#error "numeric integer type not defined"
+#endif				/* } */
 #define LUA_INTEGER_SCAN	"%" LUA_INTEGER_FRMLEN "d"

src/lualib.h+4−1

 /*
-** $Id: lualib.h,v 1.43 2011/12/08 12:11:37 roberto Exp $
+** $Id: lualib.h,v 1.44 2014/02/06 17:32:33 roberto Exp $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
 #define LUA_STRLIBNAME	"string"
 LUAMOD_API int (luaopen_string) (lua_State *L);
+#define LUA_UTF8LIBNAME	"utf8"
+LUAMOD_API int (luaopen_utf8) (lua_State *L);
 #define LUA_BITLIBNAME	"bit32"
 LUAMOD_API int (luaopen_bit32) (lua_State *L);

src/lundump.c+207−209

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lundump.c,v 2.23 2013/04/26 18:48:35 roberto Exp $	2	** $Id: lundump.c,v 2.34 2014/03/11 18:56:27 roberto Exp $
3	** load precompiled Lua chunks	3	** load precompiled Lua chunks
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -20,249 +20,247 @@ · 14 unmodified lines
20	#include "lundump.h"	20	#include "lundump.h"
21	#include "lzio.h"	21	#include "lzio.h"
22		22
		23
		24	#if !defined(luai_verifycode)
		25	#define luai_verifycode(L,b,f) /* empty */
		26	#endif
		27
		28
23	typedef struct {	29	typedef struct {
24	lua_State* L;	30	lua_State *L;
25	ZIO* Z;	31	ZIO *Z;
26	Mbuffer* b;	32	Mbuffer *b;
27	const char* name;	33	const char *name;
28	} LoadState;	34	} LoadState;
29		35
30	static l_noret error(LoadState* S, const char* why)	36
31	{	37	static l_noret error(LoadState S, const char why) {
32	luaO_pushfstring(S->L,"%s: %s precompiled chunk",S->name,why);	38	luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why);
33	luaD_throw(S->L,LUA_ERRSYNTAX);	39	luaD_throw(S->L, LUA_ERRSYNTAX);
34	}	40	}
35		41
36	#define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size))
37	#define LoadByte(S) (lu_byte)LoadChar(S)
38	#define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x))
39	#define LoadVector(S,b,n,size) LoadMem(S,b,n,size)
40		42
41	#if !defined(luai_verifycode)	43	/*
42	#define luai_verifycode(L,b,f) /* empty */	44	** All high-level loads go through LoadVector; you can change it to
43	#endif	45	** adapt to the endianess of the input
		46	*/
		47	#define LoadVector(S,b,n) LoadBlock(S,b,(n)*sizeof((b)[0]))
44		48
45	static void LoadBlock(LoadState* S, void* b, size_t size)	49	static void LoadBlock (LoadState S, void b, size_t size) {
46	{	50	if (luaZ_read(S->Z, b, size) != 0)
47	if (luaZ_read(S->Z,b,size)!=0) error(S,"truncated");	51	error(S, "truncated");
48	}	52	}
49		53
50	static int LoadChar(LoadState* S)	54
51	{	55	#define LoadVar(S,x) LoadVector(S,&x,1)
52	char x;	56
53	LoadVar(S,x);	57
54	return x;	58	static lu_byte LoadByte (LoadState *S) {
		59	lu_byte x;
		60	LoadVar(S, x);
		61	return x;
55	}	62	}
56		63
57	static int LoadInt(LoadState* S)	64
58	{	65	static int LoadInt (LoadState *S) {
59	int x;	66	int x;
60	LoadVar(S,x);	67	LoadVar(S, x);
61	if (x<0) error(S,"corrupted");	68	return x;
62	return x;
63	}	69	}
64		70
65	static lua_Number LoadNumber(LoadState* S)	71
66	{	72	static lua_Number LoadNumber (LoadState *S) {
67	lua_Number x;	73	lua_Number x;
68	LoadVar(S,x);	74	LoadVar(S, x);
69	return x;	75	return x;
70	}	76	}
71		77
72	static lua_Integer LoadInteger(LoadState* S)	78
73	{	79	static lua_Integer LoadInteger (LoadState *S) {
74	lua_Integer x;	80	lua_Integer x;
75	LoadVar(S,x);	81	LoadVar(S, x);
76	return x;	82	return x;
77	}	83	}
78		84
79	static TString* LoadString(LoadState* S)	85
80	{	86	static TString LoadString (LoadState S) {
81	size_t size;	87	size_t size = LoadByte(S);
82	LoadVar(S,size);	88	if (size == 0xFF)
83	if (size==0)	89	LoadVar(S, size);
84	return NULL;	90	if (size == 0)
85	else	91	return NULL;
86	{	92	else {
87	char* s=luaZ_openspace(S->L,S->b,size);	93	char *s = luaZ_openspace(S->L, S->b, --size);
88	LoadBlock(S,s,size*sizeof(char));	94	LoadVector(S, s, size);
89	return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */	95	return luaS_newlstr(S->L, s, size);
90	}	96	}
91	}	97	}
92		98
93	static void LoadCode(LoadState* S, Proto* f)	99
94	{	100	static void LoadCode (LoadState S, Proto f) {
95	int n=LoadInt(S);	101	int n = LoadInt(S);
96	f->code=luaM_newvector(S->L,n,Instruction);	102	f->code = luaM_newvector(S->L, n, Instruction);
97	f->sizecode=n;	103	f->sizecode = n;
98	LoadVector(S,f->code,n,sizeof(Instruction));	104	LoadVector(S, f->code, n);
99	}	105	}
100		106
101	static void LoadFunction(LoadState* S, Proto* f);	107
102		108	static void LoadFunction(LoadState S, Proto f);
103	static void LoadConstants(LoadState* S, Proto* f)	109
104	{	110
105	int i,n;	111	static void LoadConstants (LoadState S, Proto f) {
106	n=LoadInt(S);	112	int i, n;
107	f->k=luaM_newvector(S->L,n,TValue);	113	n = LoadInt(S);
108	f->sizek=n;	114	f->k = luaM_newvector(S->L, n, TValue);
109	for (i=0; i<n; i++) setnilvalue(&f->k[i]);	115	f->sizek = n;
110	for (i=0; i<n; i++)	116	for (i = 0; i < n; i++)
111	{	117	setnilvalue(&f->k[i]);
112	TValue* o=&f->k[i];	118	for (i = 0; i < n; i++) {
113	int t=LoadChar(S);	119	TValue *o = &f->k[i];
114	switch (t)	120	int t = LoadByte(S);
115	{	121	switch (t) {
116	case LUA_TNIL:	122	case LUA_TNIL:
117	setnilvalue(o);	123	setnilvalue(o);
118	break;	124	break;
119	case LUA_TBOOLEAN:	125	case LUA_TBOOLEAN:
120	setbvalue(o,LoadChar(S));	126	setbvalue(o, LoadByte(S));
121	break;	127	break;
122	case LUA_TNUMFLT:	128	case LUA_TNUMFLT:
123	setnvalue(o,LoadNumber(S));	129	setnvalue(o, LoadNumber(S));
124	break;	130	break;
125	case LUA_TNUMINT:	131	case LUA_TNUMINT:
126	setivalue(o,LoadInteger(S));	132	setivalue(o, LoadInteger(S));
127	break;	133	break;
128	case LUA_TSHRSTR: case LUA_TLNGSTR:	134	case LUA_TSHRSTR:
129	setsvalue2n(S->L,o,LoadString(S));	135	case LUA_TLNGSTR:
130	break;	136	setsvalue2n(S->L, o, LoadString(S));
131	default: lua_assert(0);	137	break;
		138	default:
		139	lua_assert(0);
		140	}
		141	}
		142	n = LoadInt(S);
		143	f->p = luaM_newvector(S->L, n, Proto *);
		144	f->sizep = n;
		145	for (i = 0; i < n; i++)
		146	f->p[i] = NULL;
		147	for (i = 0; i < n; i++) {
		148	f->p[i] = luaF_newproto(S->L);
		149	LoadFunction(S, f->p[i]);
132	}	150	}
133	}
134	n=LoadInt(S);
135	f->p=luaM_newvector(S->L,n,Proto*);
136	f->sizep=n;
137	for (i=0; i<n; i++) f->p[i]=NULL;
138	for (i=0; i<n; i++)
139	{
140	f->p[i]=luaF_newproto(S->L);
141	LoadFunction(S,f->p[i]);
142	}
143	}	151	}
144		152
145	static void LoadUpvalues(LoadState* S, Proto* f)	153
146	{	154	static void LoadUpvalues (LoadState S, Proto f) {
147	int i,n;	155	int i, n;
148	n=LoadInt(S);	156	n = LoadInt(S);
149	f->upvalues=luaM_newvector(S->L,n,Upvaldesc);	157	f->upvalues = luaM_newvector(S->L, n, Upvaldesc);
150	f->sizeupvalues=n;	158	f->sizeupvalues = n;
151	for (i=0; i<n; i++) f->upvalues[i].name=NULL;	159	for (i = 0; i < n; i++)
152	for (i=0; i<n; i++)	160	f->upvalues[i].name = NULL;
153	{	161	for (i = 0; i < n; i++) {
154	f->upvalues[i].instack=LoadByte(S);	162	f->upvalues[i].instack = LoadByte(S);
155	f->upvalues[i].idx=LoadByte(S);	163	f->upvalues[i].idx = LoadByte(S);
156	}	164	}
157	}	165	}
158		166
159	static void LoadDebug(LoadState* S, Proto* f)	167
160	{	168	static void LoadDebug (LoadState S, Proto f) {
161	int i,n;	169	int i, n;
162	f->source=LoadString(S);	170	f->source = LoadString(S);
163	n=LoadInt(S);	171	n = LoadInt(S);
164	f->lineinfo=luaM_newvector(S->L,n,int);	172	f->lineinfo = luaM_newvector(S->L, n, int);
165	f->sizelineinfo=n;	173	f->sizelineinfo = n;
166	LoadVector(S,f->lineinfo,n,sizeof(int));	174	LoadVector(S, f->lineinfo, n);
167	n=LoadInt(S);	175	n = LoadInt(S);
168	f->locvars=luaM_newvector(S->L,n,LocVar);	176	f->locvars = luaM_newvector(S->L, n, LocVar);
169	f->sizelocvars=n;	177	f->sizelocvars = n;
170	for (i=0; i<n; i++) f->locvars[i].varname=NULL;	178	for (i = 0; i < n; i++)
171	for (i=0; i<n; i++)	179	f->locvars[i].varname = NULL;
172	{	180	for (i = 0; i < n; i++) {
173	f->locvars[i].varname=LoadString(S);	181	f->locvars[i].varname = LoadString(S);
174	f->locvars[i].startpc=LoadInt(S);	182	f->locvars[i].startpc = LoadInt(S);
175	f->locvars[i].endpc=LoadInt(S);	183	f->locvars[i].endpc = LoadInt(S);
176	}	184	}
177	n=LoadInt(S);	185	n = LoadInt(S);
178	for (i=0; i<n; i++) f->upvalues[i].name=LoadString(S);	186	for (i = 0; i < n; i++)
		187	f->upvalues[i].name = LoadString(S);
179	}	188	}
180		189
181	static void LoadFunction(LoadState* S, Proto* f)	190
182	{	191	static void LoadFunction (LoadState S, Proto f) {
183	f->linedefined=LoadInt(S);	192	f->linedefined = LoadInt(S);
184	f->lastlinedefined=LoadInt(S);	193	f->lastlinedefined = LoadInt(S);
185	f->numparams=LoadByte(S);	194	f->numparams = LoadByte(S);
186	f->is_vararg=LoadByte(S);	195	f->is_vararg = LoadByte(S);
187	f->maxstacksize=LoadByte(S);	196	f->maxstacksize = LoadByte(S);
188	LoadCode(S,f);	197	LoadCode(S, f);
189	LoadConstants(S,f);	198	LoadConstants(S, f);
190	LoadUpvalues(S,f);	199	LoadUpvalues(S, f);
191	LoadDebug(S,f);	200	LoadDebug(S, f);
192	}	201	}
193		202
194	/* the code below must be consistent with the code in luaU_header */	203
195	#define N0 LUAC_HEADERSIZE	204	static void checkliteral (LoadState S, const char s, const char *msg) {
196	#define N1 (sizeof(LUA_SIGNATURE)-sizeof(char))	205	char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
197	#define N2 N1+2	206	int len = strlen(s);
198	#define N3 N2+6	207	LoadVector(S, buff, len);
199		208	if (memcmp(s, buff, len) != 0)
200	static void LoadHeader(LoadState* S)	209	error(S, msg);
201	{
202	lu_byte h[LUAC_HEADERSIZE];
203	lu_byte s[LUAC_HEADERSIZE];
204	luaU_header(h);
205	memcpy(s,h,sizeof(char)); /* first char already read */
206	LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char));
207	if (memcmp(h,s,N0)==0) return;
208	if (memcmp(h,s,N1)!=0) error(S,"not a");
209	if (memcmp(h,s,N2)!=0) error(S,"version mismatch in");
210	if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted");
211	}	210	}
212		211
213	/*	212
214	** load precompiled chunk	213	static void fchecksize (LoadState S, size_t size, const char tname) {
215	*/	214	if (LoadByte(S) != size)
216	Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)	215	error(S, luaO_pushfstring(S->L, "%s size mismatch in", tname));
217	{	216	}
218	LoadState S;	217
219	Closure* cl;	218
220	if (name=='@' \|\| name=='=')	219	#define checksize(S,t) fchecksize(S,sizeof(t),#t)
221	S.name=name+1;	220
222	else if (*name==LUA_SIGNATURE[0])	221	static void checkHeader (LoadState *S) {
223	S.name="binary string";	222	checkliteral(S, LUA_SIGNATURE + 1, "not a"); /* 1st char already checked */
224	else	223	if (LoadByte(S) != LUAC_VERSION)
225	S.name=name;	224	error(S, "version mismatch in");
226	S.L=L;	225	if (LoadByte(S) != LUAC_FORMAT)
227	S.Z=Z;	226	error(S, "format mismatch in");
228	S.b=buff;	227	checkliteral(S, LUAC_DATA, "corrupted");
229	LoadHeader(&S);	228	checksize(S, int);
230	cl=luaF_newLclosure(L,1);	229	checksize(S, size_t);
231	setclLvalue(L,L->top,cl); incr_top(L);	230	checksize(S, Instruction);
232	cl->l.p=luaF_newproto(L);	231	checksize(S, lua_Integer);
233	LoadFunction(&S,cl->l.p);	232	checksize(S, lua_Number);
234	if (cl->l.p->sizeupvalues != 1)	233	if (LoadInteger(S) != LUAC_INT)
235	{	234	error(S, "endianess mismatch in");
236	Proto* p=cl->l.p;	235	if (LoadNumber(S) != LUAC_NUM)
237	cl=luaF_newLclosure(L,cl->l.p->sizeupvalues);	236	error(S, "float format mismatch in");
238	cl->l.p=p;
239	setclLvalue(L,L->top-1,cl);
240	}
241	luai_verifycode(L,buff,cl->l.p);
242	return cl;
243	}	237	}
244		238
245	#define MYINT(s) (s[0]-'0')
246	#define VERSION MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)
247	#define FORMAT 0 /* this is the official format */
248		239
249	/*	240	/*
250	* make header for precompiled chunks	241	** load precompiled chunk
251	* if you change the code below be sure to update LoadHeader and FORMAT above
252	* and LUAC_HEADERSIZE in lundump.h
253	*/	242	*/
254	void luaU_header (lu_byte* h)	243	Closure luaU_undump(lua_State L, ZIO Z, Mbuffer buff,
255	{	244	const char *name) {
256	int x=1;	245	LoadState S;
257	memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-sizeof(char));	246	Closure *cl;
258	h+=sizeof(LUA_SIGNATURE)-sizeof(char);	247	if (name == '@' \|\| name == '=')
259	*h++=cast_byte(VERSION);	248	S.name = name + 1;
260	*h++=cast_byte(FORMAT);	249	else if (*name == LUA_SIGNATURE[0])
261	h++=cast_byte((char)&x); / endianness */	250	S.name = "binary string";
262	*h++=cast_byte(sizeof(int));	251	else
263	*h++=cast_byte(sizeof(size_t));	252	S.name = name;
264	*h++=cast_byte(sizeof(Instruction));	253	S.L = L;
265	*h++=cast_byte(sizeof(lua_Number));	254	S.Z = Z;
266	h++=cast_byte(((lua_Number)0.5)==0); / is lua_Number integral? */	255	S.b = buff;
267	memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char));	256	checkHeader(&S);
		257	cl = luaF_newLclosure(L, LoadByte(&S));
		258	setclLvalue(L, L->top, cl);
		259	incr_top(L);
		260	cl->l.p = luaF_newproto(L);
		261	LoadFunction(&S, cl->l.p);
		262	lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
		263	luai_verifycode(L, buff, cl->l.p);
		264	return cl;
268	}	265	}
		266

src/lundump.h+16−11

 /*
-** $Id: lundump.h,v 1.39 2012/05/08 13:53:33 roberto Exp $
+** $Id: lundump.h,v 1.42 2014/03/11 14:22:54 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 #ifndef lundump_h
 #define lundump_h
+#include "llimits.h"
 #include "lobject.h"
 #include "lzio.h"
-/* load one chunk; from lundump.c */
-LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
-/* make header; from lundump.c */
+/* data to catch conversion errors */
-LUAI_FUNC void luaU_header (lu_byte* h);
+#define LUAC_DATA	"\x19\x93\r\n\x1a\n"
-/* dump one chunk; from ldump.c */
+#define LUAC_INT	cast_integer(0xABCD)
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
+#define LUAC_NUM	cast_num(370.5)
-/* data to catch conversion errors */
+#define MYINT(s)	(s[0]-'0')
-#define LUAC_TAIL		"\x19\x93\r\n\x1a\n"
+#define LUAC_VERSION	(MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
+#define LUAC_FORMAT	0	/* this is the official format */
-/* size in bytes of header of binary files */
+/* load one chunk; from lundump.c */
-#define LUAC_HEADERSIZE		(sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char))
+LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff,
+                                const char* name);
+/* dump one chunk; from ldump.c */
+LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,
+                         void* data, int strip);
 #endif

src/lutf8lib.c+240−0

@@ -0,0 +1,240 @@
	1	/*
	2	** $Id: lutf8lib.c,v 1.4 2014/03/20 19:36:02 roberto Exp $
	3	** Standard library for UTF-8 manipulation
	4	** See Copyright Notice in lua.h
	5	*/
	6
	7
	8	#include <assert.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11
	12	#define lutf8lib_c
	13	#define LUA_LIB
	14
	15	#include "lua.h"
	16
	17	#include "lauxlib.h"
	18	#include "lualib.h"
	19
	20	#define MAXUNICODE 0x10FFFF
	21
	22	#define iscont(p) ((*(p) & 0xC0) == 0x80)
	23
	24
	25	/* from strlib */
	26	/* translate a relative string position: negative means back from end */
	27	static lua_Integer u_posrelat (lua_Integer pos, size_t len) {
	28	if (pos >= 0) return pos;
	29	else if (0u - (size_t)pos > len) return 0;
	30	else return (lua_Integer)len + pos + 1;
	31	}
	32
	33
	34	/*
	35	** Decode an UTF-8 sequence, returning NULL if byte sequence is invalid.
	36	*/
	37	static const char utf8_decode (const char o, int *val) {
	38	static unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
	39	const unsigned char s = (const unsigned char )o;
	40	unsigned int c = s[0];
	41	unsigned int res = 0; /* final result */
	42	if (c < 0x80) /* ascii? */
	43	res = c;
	44	else {
	45	int count = 0; /* to count number of continuation bytes */
	46	while (c & 0x40) { /* still have continuation bytes? */
	47	int cc = s[++count]; /* read next byte */
	48	if ((cc & 0xC0) != 0x80) /* not a continuation byte? */
	49	return NULL; /* invalid byte sequence */
	50	res = (res << 6) \| (cc & 0x3F); /* add lower 6 bits from cont. byte */
	51	c <<= 1; /* to test next bit */
	52	}
	53	res \|= ((c & 0x7F) << (count * 5)); /* add first byte */
	54	if (count > 3 \|\| res > MAXUNICODE \|\| res <= limits[count])
	55	return NULL; /* invalid byte sequence */
	56	s += count; /* skip continuation bytes read */
	57	}
	58	if (val) *val = res;
	59	return (const char )s + 1; / +1 to include first byte */
	60	}
	61
	62
	63	/*
	64	** utf8len(s, [i]) --> number of codepoints in 's' after 'i';
	65	** nil if 's' not well formed
	66	*/
	67	static int utflen (lua_State *L) {
	68	int n = 0;
	69	const char *ends;
	70	size_t len;
	71	const char *s = luaL_checklstring(L, 1, &len);
	72	lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), 1);
	73	luaL_argcheck(L, 1 <= posi && posi <= (lua_Integer)len, 1,
	74	"initial position out of string");
	75	ends = s + len;
	76	s += posi - 1;
	77	while (s < ends && (s = utf8_decode(s, NULL)) != NULL)
	78	n++;
	79	if (s == ends)
	80	lua_pushinteger(L, n);
	81	else
	82	lua_pushnil(L);
	83	return 1;
	84	}
	85
	86
	87	/*
	88	** codepoint(s, [i, [j]]) -> returns codepoints for all characters
	89	** between i and j
	90	*/
	91	static int codepoint (lua_State *L) {
	92	size_t len;
	93	const char *s = luaL_checklstring(L, 1, &len);
	94	lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
	95	lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len);
	96	int n;
	97	const char *se;
	98	luaL_argcheck(L, posi >= 1, 2, "out of range");
	99	luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of range");
	100	if (posi > pose) return 0; /* empty interval; return no values */
	101	n = (int)(pose - posi + 1);
	102	if (posi + n <= pose) /* (lua_Integer -> int) overflow? */
	103	return luaL_error(L, "string slice too long");
	104	luaL_checkstack(L, n, "string slice too long");
	105	n = 0;
	106	se = s + pose;
	107	for (s += posi - 1; s < se;) {
	108	int code;
	109	s = utf8_decode(s, &code);
	110	if (s == NULL)
	111	return luaL_error(L, "invalid UTF-8 code");
	112	lua_pushinteger(L, code);
	113	n++;
	114	}
	115	return n;
	116	}
	117
	118
	119	static void pushutfchar (lua_State *L, int arg) {
	120	int code = luaL_checkint(L, arg);
	121	luaL_argcheck(L, 0 <= code && code <= MAXUNICODE, arg, "value out of range");
	122	lua_pushfstring(L, "%U", code);
	123	}
	124
	125
	126	/*
	127	** utfchar(n1, n2, ...) -> char(n1)..char(n2)...
	128	*/
	129	static int utfchar (lua_State *L) {
	130	int n = lua_gettop(L); /* number of arguments */
	131	if (n == 1) /* optimize common case of single char */
	132	pushutfchar(L, 1);
	133	else {
	134	int i;
	135	luaL_Buffer b;
	136	luaL_buffinit(L, &b);
	137	for (i = 1; i <= n; i++) {
	138	pushutfchar(L, i);
	139	luaL_addvalue(&b);
	140	}
	141	luaL_pushresult(&b);
	142	}
	143	return 1;
	144	}
	145
	146
	147	/*
	148	** offset(s, n, [i]) -> index where n-th character after
	149	** position 'i' starts; 0 means character at 'i'.
	150	*/
	151	static int byteoffset (lua_State *L) {
	152	size_t len;
	153	const char *s = luaL_checklstring(L, 1, &len);
	154	int n = luaL_checkint(L, 2);
	155	lua_Integer posi = u_posrelat(luaL_optinteger(L, 3, 1), len) - 1;
	156	luaL_argcheck(L, 0 <= posi && posi <= (lua_Integer)len, 3,
	157	"position out of range");
	158	if (n == 0) {
	159	/* find beginning of current byte sequence */
	160	while (posi > 0 && iscont(s + posi)) posi--;
	161	}
	162	else if (n < 0) {
	163	while (n < 0 && posi > 0) { /* move back */
	164	do { /* find beginning of previous character */
	165	posi--;
	166	} while (posi > 0 && iscont(s + posi));
	167	n++;
	168	}
	169	}
	170	else {
	171	n--; /* do not move for 1st character */
	172	while (n > 0 && posi < (lua_Integer)len) {
	173	do { /* find beginning of next character */
	174	posi++;
	175	} while (iscont(s + posi)); /* ('\0' is not continuation) */
	176	n--;
	177	}
	178	}
	179	if (n == 0)
	180	lua_pushinteger(L, posi + 1);
	181	else
	182	lua_pushnil(L); /* no such position */
	183	return 1;
	184	}
	185
	186
	187	static int iter_aux (lua_State *L) {
	188	size_t len;
	189	const char *s = luaL_checklstring(L, 1, &len);
	190	int n = lua_tointeger(L, 2) - 1;
	191	if (n < 0) /* first iteration? */
	192	n = 0; /* start from here */
	193	else if (n < (lua_Integer)len) {
	194	n++; /* skip current byte */
	195	while (iscont(s + n)) n++; /* and its continuations */
	196	}
	197	if (n >= (lua_Integer)len)
	198	return 0; /* no more codepoints */
	199	else {
	200	int code;
	201	const char *next = utf8_decode(s + n, &code);
	202	if (next == NULL \|\| iscont(next))
	203	return luaL_error(L, "invalid UTF-8 code");
	204	lua_pushinteger(L, n + 1);
	205	lua_pushinteger(L, code);
	206	return 2;
	207	}
	208	}
	209
	210
	211	static int iter_codes (lua_State *L) {
	212	luaL_checkstring(L, 1);
	213	lua_pushcfunction(L, iter_aux);
	214	lua_pushvalue(L, 1);
	215	lua_pushinteger(L, 0);
	216	return 3;
	217	}
	218
	219
	220	/* pattern to match a single UTF-8 character */
	221	#define UTF8PATT "[\0-\x7F\xC2-\xF4][\x80-\xBF]*"
	222
	223
	224	static struct luaL_Reg funcs[] = {
	225	{"offset", byteoffset},
	226	{"codepoint", codepoint},
	227	{"char", utfchar},
	228	{"len", utflen},
	229	{"codes", iter_codes},
	230	{NULL, NULL}
	231	};
	232
	233
	234	int luaopen_utf8 (lua_State *L) {
	235	luaL_newlib(L, funcs);
	236	lua_pushliteral(L, UTF8PATT);
	237	lua_setfield(L, -2, "charpatt");
	238	return 1;
	239	}
	240

src/lvm.c+125−56

 /*
-** $Id: lvm.c,v 2.175 2013/06/20 15:02:49 roberto Exp $
+** $Id: lvm.c,v 2.190 2014/03/15 12:29:48 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 /* limit for table tag-method chains (to avoid loops) */
-#define MAXTAGLOOP	100
+#define MAXTAGLOOP	2000
 /* maximum length of the conversion of a number to a string */
     return 0;
   else {
     char buff[MAXNUMBER2STR];
-    size_t len;
+    size_t len = (ttisinteger(obj))
-    if (ttisinteger(obj))
+                 ? lua_integer2str(buff, ivalue(obj))
-      len = lua_integer2str(buff, ivalue(obj));
+                 : lua_number2str(buff, fltvalue(obj));
-    else {
-      len = lua_number2str(buff, fltvalue(obj));
-      if (strspn(buff, "-0123456789") == len) {  /* look like an integer? */
-        buff[len++] = '.';  /* add a '.0' */
-        buff[len++] = '0';
-        buff[len] = '\0';
-      }
-    }
     setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
     return 1;
   }
 ** Check whether a float number is within the range of a lua_Integer.
 ** (The comparisons are tricky because of rounding, which can or
 ** not occur depending on the relative sizes of floats and integers.)
-** This function is called only when 'n' has an integer value.
+** This function should be called only when 'n' has an integral value.
 */
 int luaV_numtointeger (lua_Number n, lua_Integer *p) {
   if (cast_num(MIN_INTEGER) <= n && n < (MAX_INTEGER + cast_num(1))) {
     }
     t = tm;  /* else repeat with 'tm' */
   }
-  luaG_runerror(L, "loop in gettable");
+  luaG_runerror(L, "gettable chain too long; possible loop");
 }
         /* no metamethod and (now) there is an entry with given key */
         setobj2t(L, oldval, val);  /* assign new value to that entry */
         invalidateTMcache(h);
-        luaC_barrierback(L, obj2gco(h), val);
+        luaC_barrierback(L, h, val);
         return;
       }
       /* else will try the metamethod */
     }
     t = tm;  /* else repeat with 'tm' */
   }
-  luaG_runerror(L, "loop in settable");
+  luaG_runerror(L, "settable chain too long; possible loop");
 }
   if (ttisinteger(l) && ttisinteger(r))
     return (ivalue(l) < ivalue(r));
   else if (tonumber(l, &nl) && tonumber(r, &nr))
-    return luai_numlt(L, nl, nr);
+    return luai_numlt(nl, nr);
   else if (ttisstring(l) && ttisstring(r))
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
   else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0)
   if (ttisinteger(l) && ttisinteger(r))
     return (ivalue(l) <= ivalue(r));
   else if (tonumber(l, &nl) && tonumber(r, &nr))
-    return luai_numle(L, nl, nr);
+    return luai_numle(nl, nr);
   else if (ttisstring(l) && ttisstring(r))
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
   else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0)  /* first try `le' */
     else {  /* two numbers with different variants */
       lua_Number n1, n2;
       lua_assert(ttisnumber(t1) && ttisnumber(t2));
-      (void)tonumber(t1, &n1); (void)tonumber(t2, &n2);
+      cast_void(tonumber(t1, &n1)); cast_void(tonumber(t2, &n2));
       return luai_numeq(n1, n2);
     }
   }
     if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1))
       luaT_trybinTM(L, top-2, top-1, top-2, TM_CONCAT);
     else if (tsvalue(top-1)->len == 0)  /* second operand is empty? */
-      (void)tostring(L, top - 2);  /* result is first operand */
+      cast_void(tostring(L, top - 2));  /* result is first operand */
     else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) {
       setobjs2s(L, top - 2, top - 1);  /* result is second op. */
     }
   if (cast_unsigned(y) + 1 <= 1U) {  /* special cases: -1 or 0 */
     if (y == 0)
       luaG_runerror(L, "attempt to divide by zero");
-    else  /* -1 */
+    return intop(-, 0, x);   /* y==-1; avoid overflow with 0x80000...//-1 */
-      return -x;   /* avoid overflow with 0x80000... */
   }
   else {
     lua_Integer d = x / y;  /* perform division */
   if (cast_unsigned(y) + 1 <= 1U) {  /* special cases: -1 or 0 */
     if (y == 0)
       luaG_runerror(L, "attempt to perform 'n%%0'");
-    else  /* -1 */
+    return 0;   /* y==-1; avoid overflow with 0x80000...%-1 */
-      return 0;   /* avoid overflow with 0x80000... */
   }
   else {
     lua_Integer r = x % y;
 }
-lua_Integer luaV_pow (lua_Integer x, lua_Integer y) {
+lua_Integer luaV_pow (lua_State *L, lua_Integer x, lua_Integer y) {
-  lua_Integer r = 1;
+  if (y <= 0) {  /* special cases: 0 or negative exponent */
-  lua_assert(y >= 0);
+    if (y < 0)
-  if (y == 0) return r;
+      luaG_runerror(L, "integer exponentiation with negative exponent");
-  for (; y > 1; y >>= 1) {
+    return 1;  /* x^0 == 1 */
-    if (y & 1) r = intop(*, r, x);
+  }
-    x = intop(*, x, x);
+  else {
+    lua_Integer r = 1;
+    for (; y > 1; y >>= 1) {
+      if (y & 1) r = intop(*, r, x);
+      x = intop(*, x, x);
+    }
+    r = intop(*, r, x);
+    return r;
+  }
+}
+/* number of bits in an integer */
+#define NBITS	cast_int(sizeof(lua_Integer) * CHAR_BIT)
+LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) {
+  if (y < 0) {  /* shift right? */
+    if (y <= -NBITS) return 0;
+    else return cast_integer(cast_unsigned(x) >> (-y));
+  }
+  else {  /* shift left */
+    if (y >= NBITS) return 0;
+    else return x << y;
   }
-  r = intop(*, r, x);
-  return r;
 }
 /*
 ** create a new Lua closure, push it in the stack, and initialize
-** its upvalues. Note that the call to 'luaC_barrierproto' must come
+** its upvalues. Note that the closure is not cached if prototype is
-** before the assignment to 'p->cache', as the function needs the
+** already black (which means that 'cache' was already cleared by the
-** original value of that field.
+** GC).
 */
 static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base,
                          StkId ra) {
       ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx);
     else  /* get upvalue from enclosing function */
       ncl->l.upvals[i] = encup[uv[i].idx];
+    ncl->l.upvals[i]->refcount++;
+    /* new closure is white, so we do not need a barrier here */
   }
-  luaC_barrierproto(L, p, ncl);
+  if (!isblack(obj2gco(p)))  /* cache will not break GC invariant? */
-  p->cache = ncl;  /* save it on cache for reuse */
+    p->cache = ncl;  /* save it on cache for reuse */
 }
   OpCode op = GET_OPCODE(inst);
   switch (op) {  /* finish its execution */
     case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_IDIV:
-    case OP_MOD: case OP_POW: case OP_UNM: case OP_LEN:
+    case OP_BAND: case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR:
+    case OP_MOD: case OP_POW:
+    case OP_UNM: case OP_BNOT: case OP_LEN:
     case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: {
       setobjs2s(L, base + GETARG_A(inst), --L->top);
       break;
       vmcase(OP_SETUPVAL,
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
-        luaC_barrier(L, uv, ra);
+        luaC_upvalbarrier(L, uv);
       )
       vmcase(OP_SETTABLE,
         Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_IDIV)); }
       )
+      vmcase(OP_BAND,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, intop(&, ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BAND)); }
+      )
+      vmcase(OP_BOR,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, intop(|, ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BOR)); }
+      )
+      vmcase(OP_BXOR,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, intop(^, ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BXOR)); }
+      )
+      vmcase(OP_SHL,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, luaV_shiftl(ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHL)); }
+      )
+      vmcase(OP_SHR,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, luaV_shiftl(ib, -ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHR)); }
+      )
       vmcase(OP_MOD,
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         lua_Number nb; lua_Number nc;
-        lua_Integer ic;
+        if (ttisinteger(rb) && ttisinteger(rc)) {
-        if (ttisinteger(rb) && ttisinteger(rc) &&
+          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
-            (ic = ivalue(rc)) >= 0) {
+          setivalue(ra, luaV_pow(L, ib, ic));
-          lua_Integer ib = ivalue(rb);
-          setivalue(ra, luaV_pow(ib, ic));
         }
         else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
           setnvalue(ra, luai_numpow(L, nb, nc));
         lua_Number nb;
         if (ttisinteger(rb)) {
           lua_Integer ib = ivalue(rb);
-          setivalue(ra, -ib);
+          setivalue(ra, intop(-, 0, ib));
         }
         else if (tonumber(rb, &nb)) {
           setnvalue(ra, luai_numunm(L, nb));
           Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM));
         }
       )
+      vmcase(OP_BNOT,
+        TValue *rb = RB(i);
+        lua_Integer ib;
+        if (tointeger(rb, &ib)) {
+          setivalue(ra, intop(^, cast_integer(-1), ib));
+        }
+        else {
+          Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT));
+        }
+      )
       vmcase(OP_NOT,
         TValue *rb = RB(i);
         int res = l_isfalse(rb);  /* next assignment may change this value */
         }
       )
       vmcase(OP_FORLOOP,
-        if (ttisinteger(ra)) {  /* integer count? */
+        if (ttisinteger(ra)) {  /* integer loop? */
           lua_Integer step = ivalue(ra + 2);
           lua_Integer idx = ivalue(ra) + step; /* increment index */
           lua_Integer limit = ivalue(ra + 1);
             setivalue(ra + 3, idx);  /* ...and external index */
           }
         }
-        else {  /* floating count */
+        else {  /* floating loop */
           lua_Number step = fltvalue(ra + 2);
           lua_Number idx = luai_numadd(L, fltvalue(ra), step); /* inc. index */
           lua_Number limit = fltvalue(ra + 1);
-          if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit)
+          if (luai_numlt(0, step) ? luai_numle(idx, limit)
-                                     : luai_numle(L, limit, idx)) {
+                                  : luai_numle(limit, idx)) {
             ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
             setnvalue(ra, idx);  /* update internal index... */
             setnvalue(ra + 3, idx);  /* ...and external index */
         TValue *init = ra;
         TValue *plimit = ra + 1;
         TValue *pstep = ra + 2;
-        if (ttisinteger(ra) && ttisinteger(ra + 1) && ttisinteger(ra + 2)) {
+        if (ttisinteger(init) && ttisinteger(plimit) && ttisinteger(pstep)) {
-          setivalue(ra, ivalue(ra) - ivalue(pstep));
+          /* all values are integer */
+          setivalue(init, ivalue(init) - ivalue(pstep));
         }
-        else {  /* try with floats */
+        else {  /* try making all values floats */
           lua_Number ninit; lua_Number nlimit; lua_Number nstep;
           if (!tonumber(plimit, &nlimit))
             luaG_runerror(L, LUA_QL("for") " limit must be a number");
           setnvalue(pstep, nstep);
           if (!tonumber(init, &ninit))
             luaG_runerror(L, LUA_QL("for") " initial value must be a number");
-          setnvalue(ra, luai_numsub(L, ninit, nstep));
+          setnvalue(init, luai_numsub(L, ninit, nstep));
         }
         ci->u.l.savedpc += GETARG_sBx(i);
       )
         for (; n > 0; n--) {
           TValue *val = ra+n;
           luaH_setint(L, h, last--, val);
-          luaC_barrierback(L, obj2gco(h), val);
+          luaC_barrierback(L, h, val);
         }
         L->top = ci->top;  /* correct top (in case of previous open call) */
       )

src/lvm.h+3−2

 /*
-** $Id: lvm.h,v 2.23 2013/05/02 12:31:26 roberto Exp $
+** $Id: lvm.h,v 2.25 2013/12/30 20:47:58 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 LUAI_FUNC void luaV_concat (lua_State *L, int total);
 LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y);
 LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
-LUAI_FUNC lua_Integer luaV_pow (lua_Integer x, lua_Integer y);
+LUAI_FUNC lua_Integer luaV_pow (lua_State *L, lua_Integer x, lua_Integer y);
+LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
 LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
 #endif

src/lzio.h+2−1

 /*
-** $Id: lzio.h,v 1.27 2013/06/07 14:51:10 roberto Exp $
+** $Id: lzio.h,v 1.28 2014/01/31 15:14:22 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
 #define luaZ_sizebuffer(buff)	((buff)->buffsize)
 #define luaZ_bufflen(buff)	((buff)->n)
+#define luaZ_buffremove(buff,i)	((buff)->n -= (i))
 #define luaZ_resetbuffer(buff) ((buff)->n = 0)

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lauxlib.h,v 1.122 2013/06/27 18:32:33 roberto Exp $	2	** $Id: lauxlib.h,v 1.123 2014/01/05 14:04:46 roberto Exp $
3	** Auxiliary functions for building Lua libraries	3	** Auxiliary functions for building Lua libraries
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -35,24 +35,24 @@ LUALIB_API void (luaL_checkversion_) (lua_State *L, int ver, size_t sz); · 29 unmodified lines
35	LUALIB_API int (luaL_getmetafield) (lua_State L, int obj, const char e);	35	LUALIB_API int (luaL_getmetafield) (lua_State L, int obj, const char e);
36	LUALIB_API int (luaL_callmeta) (lua_State L, int obj, const char e);	36	LUALIB_API int (luaL_callmeta) (lua_State L, int obj, const char e);
37	LUALIB_API const char (luaL_tolstring) (lua_State L, int idx, size_t *len);	37	LUALIB_API const char (luaL_tolstring) (lua_State L, int idx, size_t *len);
38	LUALIB_API int (luaL_argerror) (lua_State L, int numarg, const char extramsg);	38	LUALIB_API int (luaL_argerror) (lua_State L, int arg, const char extramsg);
39	LUALIB_API const char (luaL_checklstring) (lua_State L, int numArg,	39	LUALIB_API const char (luaL_checklstring) (lua_State L, int arg,
40	size_t *l);	40	size_t *l);
41	LUALIB_API const char (luaL_optlstring) (lua_State L, int numArg,	41	LUALIB_API const char (luaL_optlstring) (lua_State L, int arg,
42	const char def, size_t l);	42	const char def, size_t l);
43	LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);	43	LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
44	LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);	44	LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
45		45
46	LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);	46	LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
47	LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,	47	LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
48	lua_Integer def);	48	lua_Integer def);
49	LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);	49	LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int arg);
50	LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,	50	LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int arg,
51	lua_Unsigned def);	51	lua_Unsigned def);
52		52
53	LUALIB_API void (luaL_checkstack) (lua_State L, int sz, const char msg);	53	LUALIB_API void (luaL_checkstack) (lua_State L, int sz, const char msg);
54	LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);	54	LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
55	LUALIB_API void (luaL_checkany) (lua_State *L, int narg);	55	LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
56		56
57	LUALIB_API int (luaL_newmetatable) (lua_State L, const char tname);	57	LUALIB_API int (luaL_newmetatable) (lua_State L, const char tname);
58	LUALIB_API void (luaL_setmetatable) (lua_State L, const char tname);	58	LUALIB_API void (luaL_setmetatable) (lua_State L, const char tname);
@@ -62,7 +62,7 @@ LUALIB_API void (luaL_checkudata) (lua_State L, int ud, const char *tname); · 3 unmodified lines
62	LUALIB_API void (luaL_where) (lua_State *L, int lvl);	62	LUALIB_API void (luaL_where) (lua_State *L, int lvl);
63	LUALIB_API int (luaL_error) (lua_State L, const char fmt, ...);	63	LUALIB_API int (luaL_error) (lua_State L, const char fmt, ...);
64		64
65	LUALIB_API int (luaL_checkoption) (lua_State L, int narg, const char def,	65	LUALIB_API int (luaL_checkoption) (lua_State L, int arg, const char def,
66	const char *const lst[]);	66	const char *const lst[]);
67		67
68	LUALIB_API int (luaL_fileresult) (lua_State L, int stat, const char fname);	68	LUALIB_API int (luaL_fileresult) (lua_State L, int stat, const char fname);
@@ -114,8 +114,8 @@ LUALIB_API void (luaL_requiref) (lua_State L, const char modname, · 45 unmodified lines
114	#define luaL_newlib(L,l) \	114	#define luaL_newlib(L,l) \
115	(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))	115	(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
116		116
117	#define luaL_argcheck(L, cond,numarg,extramsg) \	117	#define luaL_argcheck(L, cond,arg,extramsg) \
118	((void)((cond) \|\| luaL_argerror(L, (numarg), (extramsg))))	118	((void)((cond) \|\| luaL_argerror(L, (arg), (extramsg))))
119	#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))	119	#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
120	#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))	120	#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
121	#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))	121	#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))