Release 1.7.0

Co-authored-by: shencyx <yixin.cen@alibaba-inc.com>

.github/ISSUE_TEMPLATE/readme-first.md

@@ -0,0 +1,23 @@
+---
+name: Readme First
+about: Issues is bug report only
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+The **Issues** is for bug report only.
+
+Goto **Discussions** for feature request , questions, etc.
+
+**Update to master branch HEAD first**, and
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior.
+
+**Additional context**
+Add any other context about the problem here.

.gitignore

@@ -1,10 +1,13 @@
 *.o
 *.a
-skynet
-skynet.pid
+/skynet
+/skynet.pid
 3rd/lua/lua
 3rd/lua/luac
-cservice
-luaclib
+3rd/lua/all
+/cservice
+/luaclib
 *.so
 *.dSYM
+.DS_Store
+.vscode

3rd/lpeg/HISTORY

@@ -0,0 +1,109 @@
+HISTORY for LPeg 1.1.0
+
+* Changes from version 1.0.2 to 1.1.0
+  ---------------------------------
+  + accumulator capture
+  + UTF-8 ranges
+  + Larger limit for number of rules in a grammar
+  + Larger limit for number of captures in a match
+  + bug fixes
+  + other small improvements
+
+* Changes from version 1.0.1 to 1.0.2
+  ---------------------------------
+  + some bugs fixed
+
+* Changes from version 0.12 to 1.0.1
+  ---------------------------------
+  + group "names" can be any Lua value
+  + some bugs fixed
+  + other small improvements
+
+* Changes from version 0.11 to 0.12
+  ---------------------------------
+  + no "unsigned short" limit for pattern sizes
+  + mathtime captures considered nullable
+  + some bugs fixed
+
+* Changes from version 0.10 to 0.11
+  -------------------------------
+  + complete reimplementation of the code generator
+  + new syntax for table captures
+  + new functions in module 're'
+  + other small improvements
+
+* Changes from version 0.9 to 0.10
+  -------------------------------
+  + backtrack stack has configurable size
+  + better error messages
+  + Notation for non-terminals in 're' back to A instead o <A>
+  + experimental look-behind pattern
+  + support for external extensions
+  + works with Lua 5.2
+  + consumes less C stack
+
+  - "and" predicates do not keep captures
+
+* Changes from version 0.8 to 0.9
+  -------------------------------
+  + The accumulator capture was replaced by a fold capture;
+    programs that used the old 'lpeg.Ca' will need small changes.
+  + Some support for character classes from old C locales.
+  + A new named-group capture.
+
+* Changes from version 0.7 to 0.8
+  -------------------------------
+  + New "match-time" capture.
+  + New "argument capture" that allows passing arguments into the pattern.
+  + Better documentation for 're'.
+  + Several small improvements for 're'.
+  + The 're' module has an incompatibility with previous versions:
+    now, any use of a non-terminal must be enclosed in angle brackets
+    (like <B>).
+
+* Changes from version 0.6 to 0.7
+  -------------------------------
+  + Several improvements in module 're':
+    - better documentation;
+    - support for most captures (all but accumulator);
+    - limited repetitions p{n,m}.
+  + Small improvements in efficiency.
+  + Several small bugs corrected (special thanks to Hans Hagen
+    and Taco Hoekwater).
+
+* Changes from version 0.5 to 0.6
+  -------------------------------
+  + Support for non-numeric indices in grammars.
+  + Some bug fixes (thanks to the luatex team).
+  + Some new optimizations; (thanks to Mike Pall).
+  + A new page layout (thanks to Andre Carregal).
+  + Minimal documentation for module 're'.
+
+* Changes from version 0.4 to 0.5
+  -------------------------------
+  + Several optimizations.
+  + lpeg.P now accepts booleans.
+  + Some new examples.
+  + A proper license.
+  + Several small improvements.
+
+* Changes from version 0.3 to 0.4
+  -------------------------------
+  + Static check for loops in repetitions and grammars.
+  + Removed label option in captures.
+  + The implementation of captures uses less memory.
+
+* Changes from version 0.2 to 0.3
+  -------------------------------
+  + User-defined patterns in Lua.
+  + Several new captures.
+
+* Changes from version 0.1 to 0.2
+  -------------------------------
+  + Several small corrections.
+  + Handles embedded zeros like any other character.
+  + Capture "name" can be any Lua value.
+  + Unlimited number of captures.
+  + Match gets an optional initial position.
+
+(end of HISTORY)

3rd/lpeg/README.md

@@ -0,0 +1,4 @@
+# LPeg - Parsing Expression Grammars For Lua
+
+For more information,
+see [Lpeg](//www.inf.puc-rio.br/~roberto/lpeg/).

3rd/lpeg/lpcap.c

@@ -0,0 +1,612 @@
+
+#include "lua.h"
+#include "lauxlib.h"
+
+#include "lpcap.h"
+#include "lpprint.h"
+#include "lptypes.h"
+
+
+#define getfromktable(cs,v)	lua_rawgeti((cs)->L, ktableidx((cs)->ptop), v)
+
+#define pushluaval(cs)		getfromktable(cs, (cs)->cap->idx)
+
+
+
+#define skipclose(cs,head)  \
+	if (isopencap(head)) { assert(isclosecap(cs->cap)); cs->cap++; }
+
+
+/*
+** Return the size of capture 'cap'. If it is an open capture, 'close'
+** must be its corresponding close.
+*/
+static Index_t capsize (Capture *cap, Capture *close) {
+  if (isopencap(cap)) {
+    assert(isclosecap(close));
+    return close->index - cap->index;
+  }
+  else
+    return cap->siz - 1;
+}
+
+
+static Index_t closesize (CapState *cs, Capture *head) {
+  return capsize(head, cs->cap);
+}
+
+
+/*
+** Put at the cache for Lua values the value indexed by 'v' in ktable
+** of the running pattern (if it is not there yet); returns its index.
+*/
+static int updatecache (CapState *cs, int v) {
+  int idx = cs->ptop + 1;  /* stack index of cache for Lua values */
+  if (v != cs->valuecached) {  /* not there? */
+    getfromktable(cs, v);  /* get value from 'ktable' */
+    lua_replace(cs->L, idx);  /* put it at reserved stack position */
+    cs->valuecached = v;  /* keep track of what is there */
+  }
+  return idx;
+}
+
+
+static int pushcapture (CapState *cs);
+
+
+/*
+** Goes back in a list of captures looking for an open capture
+** corresponding to a close one.
+*/
+static Capture *findopen (Capture *cap) {
+  int n = 0;  /* number of closes waiting an open */
+  for (;;) {
+    cap--;
+    if (isclosecap(cap)) n++;  /* one more open to skip */
+    else if (isopencap(cap))
+      if (n-- == 0) return cap;
+  }
+}
+
+
+/*
+** Go to the next capture at the same level.
+*/
+static void nextcap (CapState *cs) {
+  Capture *cap = cs->cap;
+  if (isopencap(cap)) {  /* must look for a close? */
+    int n = 0;  /* number of opens waiting a close */
+    for (;;) {  /* look for corresponding close */
+      cap++;
+      if (isopencap(cap)) n++;
+      else if (isclosecap(cap))
+        if (n-- == 0) break;
+    }
+    cs->cap = cap + 1;  /* + 1 to skip last close */
+  }
+  else {
+    Capture *next;
+    for (next = cap + 1; capinside(cap, next); next++)
+      ;  /* skip captures inside current one */
+    cs->cap = next;
+  }
+}
+
+
+/*
+** Push on the Lua stack all values generated by nested captures inside
+** the current capture. Returns number of values pushed. 'addextra'
+** makes it push the entire match after all captured values. The
+** entire match is pushed also if there are no other nested values,
+** so the function never returns zero.
+*/
+static int pushnestedvalues (CapState *cs, int addextra) {
+  Capture *head = cs->cap++;  /* original capture */
+  int n = 0;  /* number of pushed subvalues */
+  /* repeat for all nested patterns */
+  while (capinside(head, cs->cap))
+    n += pushcapture(cs);
+  if (addextra || n == 0) {  /* need extra? */
+    lua_pushlstring(cs->L, cs->s + head->index, closesize(cs, head));
+    n++;
+  }
+  skipclose(cs, head);
+  return n;
+}
+
+
+/*
+** Push only the first value generated by nested captures
+*/
+static void pushonenestedvalue (CapState *cs) {
+  int n = pushnestedvalues(cs, 0);
+  if (n > 1)
+    lua_pop(cs->L, n - 1);  /* pop extra values */
+}
+
+
+/*
+** Checks whether group 'grp' is visible to 'ref', that is, 'grp' is
+** not nested inside a full capture that does not contain 'ref'.  (We
+** only need to care for full captures because the search at 'findback'
+** skips open-end blocks; so, if 'grp' is nested in a non-full capture,
+** 'ref' is also inside it.)  To check this, we search backward for the
+** inner full capture enclosing 'grp'.  A full capture cannot contain
+** non-full captures, so a close capture means we cannot be inside a
+** full capture anymore.
+*/
+static int capvisible (CapState *cs, Capture *grp, Capture *ref) {
+  Capture *cap = grp;
+  int i = MAXLOP;  /* maximum distance for an 'open' */
+  while (i-- > 0 && cap-- > cs->ocap) {
+    if (isclosecap(cap))
+      return 1;  /* can stop the search */
+    else if (grp->index - cap->index >= UCHAR_MAX)
+      return 1;  /* can stop the search */
+    else if (capinside(cap, grp))  /* is 'grp' inside cap? */
+      return capinside(cap, ref);  /* ok iff cap also contains 'ref' */
+  }
+  return 1;  /* 'grp' is not inside any capture */
+}
+
+
+/*
+** Try to find a named group capture with the name given at the top of
+** the stack; goes backward from 'ref'.
+*/
+static Capture *findback (CapState *cs, Capture *ref) {
+  lua_State *L = cs->L;
+  Capture *cap = ref;
+  while (cap-- > cs->ocap) {  /* repeat until end of list */
+    if (isclosecap(cap))
+      cap = findopen(cap);  /* skip nested captures */
+    else if (capinside(cap, ref))
+      continue;  /* enclosing captures are not visible to 'ref' */
+    if (captype(cap) == Cgroup && capvisible(cs, cap, ref)) {
+      getfromktable(cs, cap->idx);  /* get group name */
+      if (lp_equal(L, -2, -1)) {  /* right group? */
+        lua_pop(L, 2);  /* remove reference name and group name */
+        return cap;
+      }
+      else lua_pop(L, 1);  /* remove group name */
+    }
+  }
+  luaL_error(L, "back reference '%s' not found", lua_tostring(L, -1));
+  return NULL;  /* to avoid warnings */
+}
+
+
+/*
+** Back-reference capture. Return number of values pushed.
+*/
+static int backrefcap (CapState *cs) {
+  int n;
+  Capture *curr = cs->cap;
+  pushluaval(cs);  /* reference name */
+  cs->cap = findback(cs, curr);  /* find corresponding group */
+  n = pushnestedvalues(cs, 0);  /* push group's values */
+  cs->cap = curr + 1;
+  return n;
+}
+
+
+/*
+** Table capture: creates a new table and populates it with nested
+** captures.
+*/
+static int tablecap (CapState *cs) {
+  lua_State *L = cs->L;
+  Capture *head = cs->cap++;
+  int n = 0;
+  lua_newtable(L);
+  while (capinside(head, cs->cap)) {
+    if (captype(cs->cap) == Cgroup && cs->cap->idx != 0) {  /* named group? */
+      pushluaval(cs);  /* push group name */
+      pushonenestedvalue(cs);
+      lua_settable(L, -3);
+    }
+    else {  /* not a named group */
+      int i;
+      int k = pushcapture(cs);
+      for (i = k; i > 0; i--)  /* store all values into table */
+        lua_rawseti(L, -(i + 1), n + i);
+      n += k;
+    }
+  }
+  skipclose(cs, head);
+  return 1;  /* number of values pushed (only the table) */
+}
+
+
+/*
+** Table-query capture
+*/
+static int querycap (CapState *cs) {
+  int idx = cs->cap->idx;
+  pushonenestedvalue(cs);  /* get nested capture */
+  lua_gettable(cs->L, updatecache(cs, idx));  /* query cap. value at table */
+  if (!lua_isnil(cs->L, -1))
+    return 1;
+  else {  /* no value */
+    lua_pop(cs->L, 1);  /* remove nil */
+    return 0;
+  }
+}
+
+
+/*
+** Fold capture
+*/
+static int foldcap (CapState *cs) {
+  int n;
+  lua_State *L = cs->L;
+  Capture *head = cs->cap++;
+  int idx = head->idx;
+  if (isclosecap(cs->cap) ||  /* no nested captures (large subject)? */
+      (n = pushcapture(cs)) == 0)  /* nested captures with no values? */
+    return luaL_error(L, "no initial value for fold capture");
+  if (n > 1)
+    lua_pop(L, n - 1);  /* leave only one result for accumulator */
+  while (capinside(head, cs->cap)) {
+    lua_pushvalue(L, updatecache(cs, idx));  /* get folding function */
+    lua_insert(L, -2);  /* put it before accumulator */
+    n = pushcapture(cs);  /* get next capture's values */
+    lua_call(L, n + 1, 1);  /* call folding function */
+  }
+  skipclose(cs, head);
+  return 1;  /* only accumulator left on the stack */
+}
+
+
+/*
+** Function capture
+*/
+static int functioncap (CapState *cs) {
+  int n;
+  int top = lua_gettop(cs->L);
+  pushluaval(cs);  /* push function */
+  n = pushnestedvalues(cs, 0);  /* push nested captures */
+  lua_call(cs->L, n, LUA_MULTRET);  /* call function */
+  return lua_gettop(cs->L) - top;  /* return function's results */
+}
+
+
+/*
+** Accumulator capture
+*/
+static int accumulatorcap (CapState *cs) {
+  lua_State *L = cs->L;
+  int n;
+  if (lua_gettop(L) < cs->firstcap)
+    luaL_error(L, "no previous value for accumulator capture");
+  pushluaval(cs);  /* push function */
+  lua_insert(L, -2);  /* previous value becomes first argument */
+  n = pushnestedvalues(cs, 0);  /* push nested captures */
+  lua_call(L, n + 1, 1);  /* call function */
+  return 0;  /* did not add any extra value */
+}
+
+
+/*
+** Select capture
+*/
+static int numcap (CapState *cs) {
+  int idx = cs->cap->idx;  /* value to select */
+  if (idx == 0) {  /* no values? */
+    nextcap(cs);  /* skip entire capture */
+    return 0;  /* no value produced */
+  }
+  else {
+    int n = pushnestedvalues(cs, 0);
+    if (n < idx)  /* invalid index? */
+      return luaL_error(cs->L, "no capture '%d'", idx);
+    else {
+      lua_pushvalue(cs->L, -(n - idx + 1));  /* get selected capture */
+      lua_replace(cs->L, -(n + 1));  /* put it in place of 1st capture */
+      lua_pop(cs->L, n - 1);  /* remove other captures */
+      return 1;
+    }
+  }
+}
+
+
+/*
+** Return the stack index of the first runtime capture in the given
+** list of captures (or zero if no runtime captures)
+*/
+int finddyncap (Capture *cap, Capture *last) {
+  for (; cap < last; cap++) {
+    if (cap->kind == Cruntime)
+      return cap->idx;  /* stack position of first capture */
+  }
+  return 0;  /* no dynamic captures in this segment */
+}
+
+
+/*
+** Calls a runtime capture. Returns number of captures "removed" by the
+** call, that is, those inside the group capture. Captures to be added
+** are on the Lua stack.
+*/
+int runtimecap (CapState *cs, Capture *close, const char *s, int *rem) {
+  int n, id;
+  lua_State *L = cs->L;
+  int otop = lua_gettop(L);
+  Capture *open = findopen(close);  /* get open group capture */
+  assert(captype(open) == Cgroup);
+  id = finddyncap(open, close);  /* get first dynamic capture argument */
+  close->kind = Cclose;  /* closes the group */
+  close->index = s - cs->s;
+  cs->cap = open; cs->valuecached = 0;  /* prepare capture state */
+  luaL_checkstack(L, 4, "too many runtime captures");
+  pushluaval(cs);  /* push function to be called */
+  lua_pushvalue(L, SUBJIDX);  /* push original subject */
+  lua_pushinteger(L, s - cs->s + 1);  /* push current position */
+  n = pushnestedvalues(cs, 0);  /* push nested captures */
+  lua_call(L, n + 2, LUA_MULTRET);  /* call dynamic function */
+  if (id > 0) {  /* are there old dynamic captures to be removed? */
+    int i;
+    for (i = id; i <= otop; i++)
+      lua_remove(L, id);  /* remove old dynamic captures */
+    *rem = otop - id + 1;  /* total number of dynamic captures removed */
+  }
+  else
+    *rem = 0;  /* no dynamic captures removed */
+  return close - open - 1;  /* number of captures to be removed */
+}
+
+
+/*
+** Auxiliary structure for substitution and string captures: keep
+** information about nested captures for future use, avoiding to push
+** string results into Lua
+*/
+typedef struct StrAux {
+  int isstring;  /* whether capture is a string */
+  union {
+    Capture *cp;  /* if not a string, respective capture */
+    struct {  /* if it is a string... */
+      Index_t idx;  /* starts here */
+      Index_t siz;  /* with this size */
+    } s;
+  } u;
+} StrAux;
+
+#define MAXSTRCAPS	10
+
+/*
+** Collect values from current capture into array 'cps'. Current
+** capture must be Cstring (first call) or Csimple (recursive calls).
+** (In first call, fills %0 with whole match for Cstring.)
+** Returns number of elements in the array that were filled.
+*/
+static int getstrcaps (CapState *cs, StrAux *cps, int n) {
+  int k = n++;
+  Capture *head = cs->cap++;
+  cps[k].isstring = 1;  /* get string value */
+  cps[k].u.s.idx = head->index;  /* starts here */
+  while (capinside(head, cs->cap)) {
+    if (n >= MAXSTRCAPS)  /* too many captures? */
+      nextcap(cs);  /* skip extra captures (will not need them) */
+    else if (captype(cs->cap) == Csimple)  /* string? */
+      n = getstrcaps(cs, cps, n);  /* put info. into array */
+    else {
+      cps[n].isstring = 0;  /* not a string */
+      cps[n].u.cp = cs->cap;  /* keep original capture */
+      nextcap(cs);
+      n++;
+    }
+  }
+  cps[k].u.s.siz = closesize(cs, head);
+  skipclose(cs, head);
+  return n;
+}
+
+
+/*
+** add next capture value (which should be a string) to buffer 'b'
+*/
+static int addonestring (luaL_Buffer *b, CapState *cs, const char *what);
+
+
+/*
+** String capture: add result to buffer 'b' (instead of pushing
+** it into the stack)
+*/
+static void stringcap (luaL_Buffer *b, CapState *cs) {
+  StrAux cps[MAXSTRCAPS];
+  int n;
+  size_t len, i;
+  const char *fmt;  /* format string */
+  fmt = lua_tolstring(cs->L, updatecache(cs, cs->cap->idx), &len);
+  n = getstrcaps(cs, cps, 0) - 1;  /* collect nested captures */
+  for (i = 0; i < len; i++) {  /* traverse format string */
+    if (fmt[i] != '%')  /* not an escape? */
+      luaL_addchar(b, fmt[i]);  /* add it to buffer */
+    else if (fmt[++i] < '0' || fmt[i] > '9')  /* not followed by a digit? */
+      luaL_addchar(b, fmt[i]);  /* add to buffer */
+    else {
+      int l = fmt[i] - '0';  /* capture index */
+      if (l > n)
+        luaL_error(cs->L, "invalid capture index (%d)", l);
+      else if (cps[l].isstring)
+        luaL_addlstring(b, cs->s + cps[l].u.s.idx, cps[l].u.s.siz);
+      else {
+        Capture *curr = cs->cap;
+        cs->cap = cps[l].u.cp;  /* go back to evaluate that nested capture */
+        if (!addonestring(b, cs, "capture"))
+          luaL_error(cs->L, "no values in capture index %d", l);
+        cs->cap = curr;  /* continue from where it stopped */
+      }
+    }
+  }
+}
+
+
+/*
+** Substitution capture: add result to buffer 'b'
+*/
+static void substcap (luaL_Buffer *b, CapState *cs) {
+  const char *curr = cs->s + cs->cap->index;
+  Capture *head = cs->cap++;
+  while (capinside(head, cs->cap)) {
+    Capture *cap = cs->cap;
+    const char *caps = cs->s + cap->index;
+    luaL_addlstring(b, curr, caps - curr);  /* add text up to capture */
+    if (addonestring(b, cs, "replacement"))
+      curr = caps + capsize(cap, cs->cap - 1);  /* continue after match */
+    else  /* no capture value */
+      curr = caps;  /* keep original text in final result */
+  }
+  /* add last piece of text */
+  luaL_addlstring(b, curr, cs->s + head->index + closesize(cs, head) - curr);
+  skipclose(cs, head);
+}
+
+
+/*
+** Evaluates a capture and adds its first value to buffer 'b'; returns
+** whether there was a value
+*/
+static int addonestring (luaL_Buffer *b, CapState *cs, const char *what) {
+  switch (captype(cs->cap)) {
+    case Cstring:
+      stringcap(b, cs);  /* add capture directly to buffer */
+      return 1;
+    case Csubst:
+      substcap(b, cs);  /* add capture directly to buffer */
+      return 1;
+    case Cacc:  /* accumulator capture? */
+      return luaL_error(cs->L, "invalid context for an accumulator capture");
+    default: {
+      lua_State *L = cs->L;
+      int n = pushcapture(cs);
+      if (n > 0) {
+        if (n > 1) lua_pop(L, n - 1);  /* only one result */
+        if (!lua_isstring(L, -1))
+          return luaL_error(L, "invalid %s value (a %s)",
+                               what, luaL_typename(L, -1));
+        luaL_addvalue(b);
+      }
+      return n;
+    }
+  }
+}
+
+
+#if !defined(MAXRECLEVEL)
+#define MAXRECLEVEL	200
+#endif
+
+
+/*
+** Push all values of the current capture into the stack; returns
+** number of values pushed
+*/
+static int pushcapture (CapState *cs) {
+  lua_State *L = cs->L;
+  int res;
+  luaL_checkstack(L, 4, "too many captures");
+  if (cs->reclevel++ > MAXRECLEVEL)
+    return luaL_error(L, "subcapture nesting too deep");
+  switch (captype(cs->cap)) {
+    case Cposition: {
+      lua_pushinteger(L, cs->cap->index + 1);
+      cs->cap++;
+      res = 1;
+      break;
+    }
+    case Cconst: {
+      pushluaval(cs);
+      cs->cap++;
+      res = 1;
+      break;
+    }
+    case Carg: {
+      int arg = (cs->cap++)->idx;
+      if (arg + FIXEDARGS > cs->ptop)
+        return luaL_error(L, "reference to absent extra argument #%d", arg);
+      lua_pushvalue(L, arg + FIXEDARGS);
+      res = 1;
+      break;
+    }
+    case Csimple: {
+      int k = pushnestedvalues(cs, 1);
+      lua_insert(L, -k);  /* make whole match be first result */
+      res = k;
+      break;
+    }
+    case Cruntime: {
+      lua_pushvalue(L, (cs->cap++)->idx);  /* value is in the stack */
+      res = 1;
+      break;
+    }
+    case Cstring: {
+      luaL_Buffer b;
+      luaL_buffinit(L, &b);
+      stringcap(&b, cs);
+      luaL_pushresult(&b);
+      res = 1;
+      break;
+    }
+    case Csubst: {
+      luaL_Buffer b;
+      luaL_buffinit(L, &b);
+      substcap(&b, cs);
+      luaL_pushresult(&b);
+      res = 1;
+      break;
+    }
+    case Cgroup: {
+      if (cs->cap->idx == 0)  /* anonymous group? */
+        res = pushnestedvalues(cs, 0);  /* add all nested values */
+      else {  /* named group: add no values */
+        nextcap(cs);  /* skip capture */
+        res = 0;
+      }
+      break;
+    }
+    case Cbackref: res = backrefcap(cs); break;
+    case Ctable: res = tablecap(cs); break;
+    case Cfunction: res = functioncap(cs); break;
+    case Cacc: res = accumulatorcap(cs); break;
+    case Cnum: res = numcap(cs); break;
+    case Cquery: res = querycap(cs); break;
+    case Cfold: res = foldcap(cs); break;
+    default: assert(0); res = 0;
+  }
+  cs->reclevel--;
+  return res;
+}
+
+
+/*
+** Prepare a CapState structure and traverse the entire list of
+** captures in the stack pushing its results. 's' is the subject
+** string, 'r' is the final position of the match, and 'ptop'
+** the index in the stack where some useful values were pushed.
+** Returns the number of results pushed. (If the list produces no
+** results, push the final position of the match.)
+*/
+int getcaptures (lua_State *L, const char *s, const char *r, int ptop) {
+  Capture *capture = (Capture *)lua_touserdata(L, caplistidx(ptop));
+  int n = 0;
+  /* printcaplist(capture); */
+  if (!isclosecap(capture)) {  /* is there any capture? */
+    CapState cs;
+    cs.ocap = cs.cap = capture; cs.L = L; cs.reclevel = 0;
+    cs.s = s; cs.valuecached = 0; cs.ptop = ptop;
+    cs.firstcap = lua_gettop(L) + 1;  /* where first value (if any) will go */
+    do {  /* collect their values */
+      n += pushcapture(&cs);
+    } while (!isclosecap(cs.cap));
+    assert(lua_gettop(L) - cs.firstcap == n - 1);
+  }
+  if (n == 0) {  /* no capture values? */
+    lua_pushinteger(L, r - s + 1);  /* return only end position */
+    n = 1;
+  }
+  return n;
+}
+
+

3rd/lpeg/lpcap.h

@@ -0,0 +1,86 @@
+
+#if !defined(lpcap_h)
+#define lpcap_h
+
+
+#include "lptypes.h"
+
+
+/* kinds of captures */
+typedef enum CapKind {
+  Cclose,  /* not used in trees */
+  Cposition,
+  Cconst,  /* ktable[key] is Lua constant */
+  Cbackref,  /* ktable[key] is "name" of group to get capture */
+  Carg,  /* 'key' is arg's number */
+  Csimple,  /* next node is pattern */
+  Ctable,  /* next node is pattern */
+  Cfunction,  /* ktable[key] is function; next node is pattern */
+  Cacc,  /* ktable[key] is function; next node is pattern */
+  Cquery,  /* ktable[key] is table; next node is pattern */
+  Cstring,  /* ktable[key] is string; next node is pattern */
+  Cnum,  /* numbered capture; 'key' is number of value to return */
+  Csubst,  /* substitution capture; next node is pattern */
+  Cfold,  /* ktable[key] is function; next node is pattern */
+  Cruntime,  /* not used in trees (is uses another type for tree) */
+  Cgroup  /* ktable[key] is group's "name" */
+} CapKind;
+
+
+/*
+** An unsigned integer large enough to index any subject entirely.
+** It can be size_t, but that will double the size of the array
+** of captures in a 64-bit machine.
+*/
+#if !defined(Index_t)
+typedef uint Index_t;
+#endif
+
+#define MAXINDT		(~(Index_t)0)
+
+
+typedef struct Capture {
+  Index_t index;  /* subject position */
+  unsigned short idx;  /* extra info (group name, arg index, etc.) */
+  byte kind;  /* kind of capture */
+  byte siz;  /* size of full capture + 1 (0 = not a full capture) */
+} Capture;
+
+
+typedef struct CapState {
+  Capture *cap;  /* current capture */
+  Capture *ocap;  /* (original) capture list */
+  lua_State *L;
+  int ptop;  /* stack index of last argument to 'match' */
+  int firstcap;  /* stack index of first capture pushed in the stack */
+  const char *s;  /* original string */
+  int valuecached;  /* value stored in cache slot */
+  int reclevel;  /* recursion level */
+} CapState;
+
+
+#define captype(cap)    ((cap)->kind)
+
+#define isclosecap(cap) (captype(cap) == Cclose)
+#define isopencap(cap)  ((cap)->siz == 0)
+
+/* true if c2 is (any number of levels) inside c1 */
+#define capinside(c1,c2)  \
+	(isopencap(c1) ? !isclosecap(c2) \
+                       : (c2)->index < (c1)->index + (c1)->siz - 1)
+
+
+/**
+** Maximum number of captures to visit when looking for an 'open'.
+*/
+#define MAXLOP		20
+
+
+
+int runtimecap (CapState *cs, Capture *close, const char *s, int *rem);
+int getcaptures (lua_State *L, const char *s, const char *r, int ptop);
+int finddyncap (Capture *cap, Capture *last);
+
+#endif
+
+

3rd/lpeg/lpcode.h

@@ -0,0 +1,36 @@
+
+#if !defined(lpcode_h)
+#define lpcode_h
+
+#include "lua.h"
+
+#include "lptypes.h"
+#include "lptree.h"
+#include "lpvm.h"
+
+int checkaux (TTree *tree, int pred);
+int fixedlen (TTree *tree);
+int hascaptures (TTree *tree);
+int lp_gc (lua_State *L);
+Instruction *compile (lua_State *L, Pattern *p, uint size);
+void freecode (lua_State *L, Pattern *p);
+int sizei (const Instruction *i);
+
+
+#define PEnullable      0
+#define PEnofail        1
+
+/*
+** nofail(t) implies that 't' cannot fail with any input
+*/
+#define nofail(t)	checkaux(t, PEnofail)
+
+/*
+** (not nullable(t)) implies 't' cannot match without consuming
+** something
+*/
+#define nullable(t)	checkaux(t, PEnullable)
+
+
+
+#endif

3rd/lpeg/lpcset.c

@@ -0,0 +1,110 @@
+
+#include "lptypes.h"
+#include "lpcset.h"
+
+
+/*
+** Add to 'c' the index of the (only) bit set in byte 'b'
+*/
+static int onlybit (int c, int b) {
+  if ((b & 0xF0) != 0) { c += 4; b >>= 4; }
+  if ((b & 0x0C) != 0) { c += 2; b >>= 2; }
+  if ((b & 0x02) != 0) { c += 1; }
+  return c;
+}
+
+
+/*
+** Check whether a charset is empty (returns IFail), singleton (IChar),
+** full (IAny), or none of those (ISet). When singleton, 'info.offset'
+** returns which character it is. When generic set, 'info' returns
+** information about its range.
+*/
+Opcode charsettype (const byte *cs, charsetinfo *info) {
+  int low0, low1, high0, high1;
+  for (low1 = 0; low1 < CHARSETSIZE && cs[low1] == 0; low1++)
+    /* find lowest byte with a 1-bit */;
+  if (low1 == CHARSETSIZE)
+    return IFail;  /* no characters in set */
+  for (high1 = CHARSETSIZE - 1; cs[high1] == 0; high1--)
+    /* find highest byte with a 1-bit; low1 is a sentinel */;
+  if (low1 == high1) {  /* only one byte with 1-bits? */
+    int b = cs[low1];
+    if ((b & (b - 1)) == 0) {  /* does byte has only one 1-bit? */
+      info->offset = onlybit(low1 * BITSPERCHAR, b);  /* get that bit */
+      return IChar;  /* single character */
+    }
+  }
+  for (low0 = 0; low0 < CHARSETSIZE && cs[low0] == 0xFF; low0++)
+    /* find lowest byte with a 0-bit */;
+  if (low0 == CHARSETSIZE)
+    return IAny;  /* set has all bits set */
+  for (high0 = CHARSETSIZE - 1; cs[high0] == 0xFF; high0--)
+    /* find highest byte with a 0-bit; low0 is a sentinel */;
+  if (high1 - low1 <= high0 - low0) {  /* range of 1s smaller than of 0s? */
+    info->offset = low1;
+    info->size = high1 - low1 + 1;
+    info->deflt = 0;  /* all discharged bits were 0 */
+  }
+  else {
+    info->offset = low0;
+    info->size = high0 - low0 + 1;
+    info->deflt = 0xFF;  /* all discharged bits were 1 */
+  }
+  info->cs = cs + info->offset;
+  return ISet;
+}
+
+
+/*
+** Get a byte from a compact charset. If index is inside the charset
+** range, get the byte from the supporting charset (correcting it
+** by the offset). Otherwise, return the default for the set.
+*/
+byte getbytefromcharset (const charsetinfo *info, int index) {
+  if (index < info->size)
+    return info->cs[index];
+  else return info->deflt;
+}
+
+
+/*
+** If 'tree' is a 'char' pattern (TSet, TChar, TAny, TFalse), convert it
+** into a charset and return 1; else return 0.
+*/
+int tocharset (TTree *tree, Charset *cs) {
+  switch (tree->tag) {
+    case TChar: {  /* only one char */
+      assert(0 <= tree->u.n && tree->u.n <= UCHAR_MAX);
+      clearset(cs->cs);  /* erase all chars */
+      setchar(cs->cs, tree->u.n);  /* add that one */
+      return 1;
+    }
+    case TAny: {
+      fillset(cs->cs, 0xFF);  /* add all characters to the set */
+      return 1;
+    }
+    case TFalse: {
+      clearset(cs->cs);  /* empty set */
+      return 1;
+    }
+    case TSet: {  /* fill set */
+      int i;
+      fillset(cs->cs, tree->u.set.deflt);
+      for (i = 0; i < tree->u.set.size; i++)
+        cs->cs[tree->u.set.offset + i] = treebuffer(tree)[i];
+      return 1;
+    }
+    default: return 0;
+  }
+}
+
+
+void tree2cset (TTree *tree, charsetinfo *info) {
+  assert(tree->tag == TSet);
+  info->offset = tree->u.set.offset;
+  info->size = tree->u.set.size;
+  info->deflt = tree->u.set.deflt;
+  info->cs = treebuffer(tree);
+}
+

3rd/lpeg/lpcset.h

@@ -0,0 +1,30 @@
+
+#if !defined(lpset_h)
+#define lpset_h
+
+#include "lpcset.h"
+#include "lpcode.h"
+#include "lptree.h"
+
+
+/*
+** Extra information for the result of 'charsettype'.  When result is
+** IChar, 'offset' is the character.  When result is ISet, 'cs' is the
+** supporting bit array (with offset included), 'offset' is the offset
+** (in bytes), 'size' is the size (in bytes), and 'delt' is the default
+** value for bytes outside the set.
+*/
+typedef struct {
+  const byte *cs;
+  int offset;
+  int size;
+  int deflt;
+} charsetinfo;
+
+
+int tocharset (TTree *tree, Charset *cs);
+Opcode charsettype (const byte *cs, charsetinfo *info);
+byte getbytefromcharset (const charsetinfo *info, int index);
+void tree2cset (TTree *tree, charsetinfo *info);
+
+#endif

3rd/lpeg/lpprint.c

@@ -0,0 +1,298 @@
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdio.h>
+
+
+#include "lptypes.h"
+#include "lpprint.h"
+#include "lpcode.h"
+
+
+#if defined(LPEG_DEBUG)
+
+/*
+** {======================================================
+** Printing patterns (for debugging)
+** =======================================================
+*/
+
+
+void printcharset (const byte *st) {
+  int i;
+  printf("[");
+  for (i = 0; i <= UCHAR_MAX; i++) {
+    int first = i;
+    while (i <= UCHAR_MAX && testchar(st, i)) i++;
+    if (i - 1 == first)  /* unary range? */
+      printf("(%02x)", first);
+    else if (i - 1 > first)  /* non-empty range? */
+      printf("(%02x-%02x)", first, i - 1);
+  }
+  printf("]");
+}
+
+
+static void printIcharset (const Instruction *inst, const byte *buff) {
+  byte cs[CHARSETSIZE];
+  int i;
+  printf("(%02x-%d) ", inst->i.aux2.set.offset, inst->i.aux2.set.size);
+  clearset(cs);
+  for (i = 0; i < CHARSETSIZE * 8; i++) {
+    if (charinset(inst, buff, i))
+      setchar(cs, i);
+  }
+  printcharset(cs);
+}
+
+
+static void printTcharset (TTree *tree) {
+  byte cs[CHARSETSIZE];
+  int i;
+  printf("(%02x-%d) ", tree->u.set.offset, tree->u.set.size);
+  fillset(cs, tree->u.set.deflt);
+  for (i = 0; i < tree->u.set.size; i++)
+    cs[tree->u.set.offset + i] = treebuffer(tree)[i];
+  printcharset(cs);
+}
+
+
+static const char *capkind (int kind) {
+  const char *const modes[] = {
+    "close", "position", "constant", "backref",
+    "argument", "simple", "table", "function", "accumulator",
+    "query", "string", "num", "substitution", "fold",
+    "runtime", "group"};
+  return modes[kind];
+}
+
+
+static void printjmp (const Instruction *op, const Instruction *p) {
+  printf("-> %d", (int)(p + (p + 1)->offset - op));
+}
+
+
+void printinst (const Instruction *op, const Instruction *p) {
+  const char *const names[] = {
+    "any", "char", "set",
+    "testany", "testchar", "testset",
+    "span", "utf-range", "behind",
+    "ret", "end",
+    "choice", "jmp", "call", "open_call",
+    "commit", "partial_commit", "back_commit", "failtwice", "fail", "giveup",
+     "fullcapture", "opencapture", "closecapture", "closeruntime",
+     "--"
+  };
+  printf("%02ld: %s ", (long)(p - op), names[p->i.code]);
+  switch ((Opcode)p->i.code) {
+    case IChar: {
+      printf("'%c' (%02x)", p->i.aux1, p->i.aux1);
+      break;
+    }
+    case ITestChar: {
+      printf("'%c' (%02x)", p->i.aux1, p->i.aux1); printjmp(op, p);
+      break;
+    }
+    case IUTFR: {
+      printf("%d - %d", p[1].offset, utf_to(p));
+      break;
+    }
+    case IFullCapture: {
+      printf("%s (size = %d)  (idx = %d)",
+             capkind(getkind(p)), getoff(p), p->i.aux2.key);
+      break;
+    }
+    case IOpenCapture: {
+      printf("%s (idx = %d)", capkind(getkind(p)), p->i.aux2.key);
+      break;
+    }
+    case ISet: {
+      printIcharset(p, (p+1)->buff);
+      break;
+    }
+    case ITestSet: {
+      printIcharset(p, (p+2)->buff); printjmp(op, p);
+      break;
+    }
+    case ISpan: {
+      printIcharset(p, (p+1)->buff);
+      break;
+    }
+    case IOpenCall: {
+      printf("-> %d", (p + 1)->offset);
+      break;
+    }
+    case IBehind: {
+      printf("%d", p->i.aux1);
+      break;
+    }
+    case IJmp: case ICall: case ICommit: case IChoice:
+    case IPartialCommit: case IBackCommit: case ITestAny: {
+      printjmp(op, p);
+      break;
+    }
+    default: break;
+  }
+  printf("\n");
+}
+
+
+void printpatt (Instruction *p) {
+  Instruction *op = p;
+  uint n = op[-1].codesize - 1;
+  while (p < op + n) {
+    printinst(op, p);
+    p += sizei(p);
+  }
+}
+
+
+static void printcap (Capture *cap, int ident) {
+  while (ident--) printf(" ");
+  printf("%s (idx: %d - size: %d) -> %lu  (%p)\n",
+         capkind(cap->kind), cap->idx, cap->siz, (long)cap->index, (void*)cap);
+}
+
+
+/*
+** Print a capture and its nested captures
+*/
+static Capture *printcap2close (Capture *cap, int ident) {
+  Capture *head = cap++;
+  printcap(head, ident);  /* print head capture */
+  while (capinside(head, cap))
+    cap = printcap2close(cap, ident + 2);  /* print nested captures */
+  if (isopencap(head)) {
+    assert(isclosecap(cap));
+    printcap(cap++, ident);  /* print and skip close capture */
+  }
+  return cap;
+}
+
+
+void printcaplist (Capture *cap) {
+  {  /* for debugging, print first a raw list of captures */
+    Capture *c = cap;
+    while (c->index != MAXINDT) { printcap(c, 0); c++; }
+  }
+  printf(">======\n");
+  while (!isclosecap(cap))
+    cap = printcap2close(cap, 0);
+  printf("=======\n");
+}
+
+/* }====================================================== */
+
+
+/*
+** {======================================================
+** Printing trees (for debugging)
+** =======================================================
+*/
+
+static const char *tagnames[] = {
+  "char", "set", "any",
+  "true", "false", "utf8.range",
+  "rep",
+  "seq", "choice",
+  "not", "and",
+  "call", "opencall", "rule", "xinfo", "grammar",
+  "behind",
+  "capture", "run-time"
+};
+
+
+void printtree (TTree *tree, int ident) {
+  int i;
+  int sibs = numsiblings[tree->tag];
+  for (i = 0; i < ident; i++) printf(" ");
+  printf("%s", tagnames[tree->tag]);
+  switch (tree->tag) {
+    case TChar: {
+      int c = tree->u.n;
+      if (isprint(c))
+        printf(" '%c'\n", c);
+      else
+        printf(" (%02X)\n", c);
+      break;
+    }
+    case TSet: {
+      printTcharset(tree);
+      printf("\n");
+      break;
+    }
+    case TUTFR: {
+      assert(sib1(tree)->tag == TXInfo);
+      printf(" %d (%02x %d) - %d (%02x %d) \n",
+        tree->u.n, tree->key, tree->cap,
+        sib1(tree)->u.n, sib1(tree)->key, sib1(tree)->cap);
+      break;
+    }
+    case TOpenCall: case TCall: {
+      assert(sib1(sib2(tree))->tag == TXInfo);
+      printf(" key: %d  (rule: %d)\n", tree->key, sib1(sib2(tree))->u.n);
+      break;
+    }
+    case TBehind: {
+      printf(" %d\n", tree->u.n);
+      break;
+    }
+    case TCapture: {
+      printf(" kind: '%s'  key: %d\n", capkind(tree->cap), tree->key);
+      break;
+    }
+    case TRule: {
+      printf(" key: %d\n", tree->key);
+      sibs = 1;  /* do not print 'sib2' (next rule) as a sibling */
+      break;
+    }
+    case TXInfo: {
+      printf(" n: %d\n", tree->u.n);
+      break;
+    }
+    case TGrammar: {
+      TTree *rule = sib1(tree);
+      printf(" %d\n", tree->u.n);  /* number of rules */
+      for (i = 0; i < tree->u.n; i++) {
+        printtree(rule, ident + 2);
+        rule = sib2(rule);
+      }
+      assert(rule->tag == TTrue);  /* sentinel */
+      sibs = 0;  /* siblings already handled */
+      break;
+    }
+    default:
+      printf("\n");
+      break;
+  }
+  if (sibs >= 1) {
+    printtree(sib1(tree), ident + 2);
+    if (sibs >= 2)
+      printtree(sib2(tree), ident + 2);
+  }
+}
+
+
+void printktable (lua_State *L, int idx) {
+  int n, i;
+  lua_getuservalue(L, idx);
+  if (lua_isnil(L, -1))  /* no ktable? */
+    return;
+  n = lua_rawlen(L, -1);
+  printf("[");
+  for (i = 1; i <= n; i++) {
+    printf("%d = ", i);
+    lua_rawgeti(L, -1, i);
+    if (lua_isstring(L, -1))
+      printf("%s  ", lua_tostring(L, -1));
+    else
+      printf("%s  ", lua_typename(L, lua_type(L, -1)));
+    lua_pop(L, 1);
+  }
+  printf("]\n");
+  /* leave ktable at the stack */
+}
+
+/* }====================================================== */
+
+#endif

3rd/lpeg/lpprint.h

@@ -0,0 +1,32 @@
+
+#if !defined(lpprint_h)
+#define lpprint_h
+
+
+#include "lptree.h"
+#include "lpvm.h"
+
+
+#if defined(LPEG_DEBUG)
+
+void printpatt (Instruction *p);
+void printtree (TTree *tree, int ident);
+void printktable (lua_State *L, int idx);
+void printcharset (const byte *st);
+void printcaplist (Capture *cap);
+void printinst (const Instruction *op, const Instruction *p);
+
+#else
+
+#define printktable(L,idx)  \
+	luaL_error(L, "function only implemented in debug mode")
+#define printtree(tree,i)  \
+	luaL_error(L, "function only implemented in debug mode")
+#define printpatt(p)  \
+	luaL_error(L, "function only implemented in debug mode")
+
+#endif
+
+
+#endif
+

3rd/lpeg/lptree.h

@@ -0,0 +1,92 @@
+
+#if !defined(lptree_h)
+#define lptree_h
+
+
+#include "lptypes.h"
+
+
+/*
+** types of trees
+*/
+typedef enum TTag {
+  TChar = 0,  /* 'n' = char */
+  TSet,  /* the set is encoded in 'u.set' and the next 'u.set.size' bytes */
+  TAny,
+  TTrue,
+  TFalse,
+  TUTFR,  /* range of UTF-8 codepoints; 'n' has initial codepoint;
+             'cap' has length; 'key' has first byte;
+             extra info is similar for end codepoint */
+  TRep,  /* 'sib1'* */
+  TSeq,  /* 'sib1' 'sib2' */
+  TChoice,  /* 'sib1' / 'sib2' */
+  TNot,  /* !'sib1' */
+  TAnd,  /* &'sib1' */
+  TCall,  /* ktable[key] is rule's key; 'sib2' is rule being called */
+  TOpenCall,  /* ktable[key] is rule's key */
+  TRule,  /* ktable[key] is rule's key (but key == 0 for unused rules);
+             'sib1' is rule's pattern pre-rule; 'sib2' is next rule;
+             extra info 'n' is rule's sequential number */
+  TXInfo,  /* extra info */
+  TGrammar,  /* 'sib1' is initial (and first) rule */
+  TBehind,  /* 'sib1' is pattern, 'n' is how much to go back */
+  TCapture,  /* captures: 'cap' is kind of capture (enum 'CapKind');
+                ktable[key] is Lua value associated with capture;
+                'sib1' is capture body */
+  TRunTime  /* run-time capture: 'key' is Lua function;
+               'sib1' is capture body */
+} TTag;
+
+
+/*
+** Tree trees
+** The first child of a tree (if there is one) is immediately after
+** the tree.  A reference to a second child (ps) is its position
+** relative to the position of the tree itself.
+*/
+typedef struct TTree {
+  byte tag;
+  byte cap;  /* kind of capture (if it is a capture) */
+  unsigned short key;  /* key in ktable for Lua data (0 if no key) */
+  union {
+    int ps;  /* occasional second child */
+    int n;  /* occasional counter */
+    struct {
+      byte offset;  /* compact set offset (in bytes) */
+      byte size;  /* compact set size (in bytes) */
+      byte deflt;  /* default value */
+      byte bitmap[1];  /* bitmap (open array) */
+    } set;  /* for compact sets */
+  } u;
+} TTree;
+
+
+/* access to charset */
+#define treebuffer(t)      ((t)->u.set.bitmap)
+
+
+/*
+** A complete pattern has its tree plus, if already compiled,
+** its corresponding code
+*/
+typedef struct Pattern {
+  union Instruction *code;
+  TTree tree[1];
+} Pattern;
+
+
+/* number of children for each tree */
+extern const byte numsiblings[];
+
+/* access to children */
+#define sib1(t)         ((t) + 1)
+#define sib2(t)         ((t) + (t)->u.ps)
+
+
+
+
+
+
+#endif
+

3rd/lpeg/lptypes.h

@@ -0,0 +1,150 @@
+/*
+** LPeg - PEG pattern matching for Lua
+** Copyright 2007-2023, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
+** written by Roberto Ierusalimschy
+*/
+
+#if !defined(lptypes_h)
+#define lptypes_h
+
+
+#include <assert.h>
+#include <limits.h>
+#include <string.h>
+
+#include "lua.h"
+
+
+#define VERSION         "1.1.0"
+
+
+#define PATTERN_T	"lpeg-pattern"
+#define MAXSTACKIDX	"lpeg-maxstack"
+
+
+/*
+** compatibility with Lua 5.1
+*/
+#if (LUA_VERSION_NUM == 501)
+
+#define lp_equal	lua_equal
+
+#define lua_getuservalue	lua_getfenv
+#define lua_setuservalue	lua_setfenv
+
+#define lua_rawlen		lua_objlen
+
+#define luaL_setfuncs(L,f,n)	luaL_register(L,NULL,f)
+#define luaL_newlib(L,f)	luaL_register(L,"lpeg",f)
+
+typedef size_t lua_Unsigned;
+
+#endif
+
+
+#if !defined(lp_equal)
+#define lp_equal(L,idx1,idx2)  lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#endif
+
+
+/* default maximum size for call/backtrack stack */
+#if !defined(MAXBACK)
+#define MAXBACK         400
+#endif
+
+
+/* maximum number of rules in a grammar (limited by 'unsigned short') */
+#if !defined(MAXRULES)
+#define MAXRULES        1000
+#endif
+
+
+
+/* initial size for capture's list */
+#define INITCAPSIZE	32
+
+
+/* index, on Lua stack, for subject */
+#define SUBJIDX		2
+
+/* number of fixed arguments to 'match' (before capture arguments) */
+#define FIXEDARGS	3
+
+/* index, on Lua stack, for capture list */
+#define caplistidx(ptop)	((ptop) + 2)
+
+/* index, on Lua stack, for pattern's ktable */
+#define ktableidx(ptop)		((ptop) + 3)
+
+/* index, on Lua stack, for backtracking stack */
+#define stackidx(ptop)	((ptop) + 4)
+
+
+
+typedef unsigned char byte;
+
+typedef unsigned int uint;
+
+
+#define BITSPERCHAR		8
+
+#define CHARSETSIZE		((UCHAR_MAX/BITSPERCHAR) + 1)
+
+
+
+typedef struct Charset {
+  byte cs[CHARSETSIZE];
+} Charset;
+
+
+
+#define loopset(v,b)    { int v; for (v = 0; v < CHARSETSIZE; v++) {b;} }
+
+#define fillset(s,c)	memset(s,c,CHARSETSIZE)
+#define clearset(s)	fillset(s,0)
+
+/* number of slots needed for 'n' bytes */
+#define bytes2slots(n)  (((n) - 1u) / (uint)sizeof(TTree) + 1u)
+
+/* set 'b' bit in charset 'cs' */
+#define setchar(cs,b)   ((cs)[(b) >> 3] |= (1 << ((b) & 7)))
+
+
+/*
+** in capture instructions, 'kind' of capture and its offset are
+** packed in field 'aux', 4 bits for each
+*/
+#define getkind(op)		((op)->i.aux1 & 0xF)
+#define getoff(op)		(((op)->i.aux1 >> 4) & 0xF)
+#define joinkindoff(k,o)	((k) | ((o) << 4))
+
+#define MAXOFF		0xF
+#define MAXAUX		0xFF
+
+
+/* maximum number of bytes to look behind */
+#define MAXBEHIND	MAXAUX
+
+
+/* maximum size (in elements) for a pattern */
+#define MAXPATTSIZE	(SHRT_MAX - 10)
+
+
+/* size (in instructions) for l bytes (l > 0) */
+#define instsize(l) ((int)(((l) + (uint)sizeof(Instruction) - 1u) \
+			/ (uint)sizeof(Instruction)))
+
+
+/* size (in elements) for a ISet instruction */
+#define CHARSETINSTSIZE		(1 + instsize(CHARSETSIZE))
+
+/* size (in elements) for a IFunc instruction */
+#define funcinstsize(p)		((p)->i.aux + 2)
+
+
+
+#define testchar(st,c)	((((uint)(st)[((c) >> 3)]) >> ((c) & 7)) & 1)
+
+
+#endif
+

3rd/lpeg/lpvm.c

@@ -0,0 +1,455 @@
+
+#include <limits.h>
+#include <string.h>
+
+
+#include "lua.h"
+#include "lauxlib.h"
+
+#include "lpcap.h"
+#include "lptypes.h"
+#include "lpvm.h"
+#include "lpprint.h"
+
+
+/* initial size for call/backtrack stack */
+#if !defined(INITBACK)
+#define INITBACK	MAXBACK
+#endif
+
+
+#define getoffset(p)	(((p) + 1)->offset)
+
+static const Instruction giveup = {{IGiveup, 0, {0}}};
+
+
+int charinset (const Instruction *i, const byte *buff, uint c) {
+  c -= i->i.aux2.set.offset;
+  if (c >= ((uint)i->i.aux2.set.size  /* size in instructions... */
+           * (uint)sizeof(Instruction)  /* in bytes... */
+           * 8u))  /* in bits */
+    return i->i.aux1;  /* out of range; return default value */
+  return testchar(buff, c);
+}
+
+
+/*
+** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid.
+*/
+static const char *utf8_decode (const char *o, int *val) {
+  static const uint limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFFu};
+  const unsigned char *s = (const unsigned char *)o;
+  uint c = s[0];  /* first byte */
+  uint res = 0;  /* final result */
+  if (c < 0x80)  /* ascii? */
+    res = c;
+  else {
+    int count = 0;  /* to count number of continuation bytes */
+    while (c & 0x40) {  /* still have continuation bytes? */
+      int cc = s[++count];  /* read next byte */
+      if ((cc & 0xC0) != 0x80)  /* not a continuation byte? */
+        return NULL;  /* invalid byte sequence */
+      res = (res << 6) | (cc & 0x3F);  /* add lower 6 bits from cont. byte */
+      c <<= 1;  /* to test next bit */
+    }
+    res |= (c & 0x7F) << (count * 5);  /* add first byte */
+    if (count > 3 || res > 0x10FFFFu || res <= limits[count])
+      return NULL;  /* invalid byte sequence */
+    s += count;  /* skip continuation bytes read */
+  }
+  *val = res;
+  return (const char *)s + 1;  /* +1 to include first byte */
+}
+
+
+/*
+** {======================================================
+** Virtual Machine
+** =======================================================
+*/
+
+
+typedef struct Stack {
+  const char *s;  /* saved position (or NULL for calls) */
+  const Instruction *p;  /* next instruction */
+  int caplevel;
+} Stack;
+
+
+#define getstackbase(L, ptop)	((Stack *)lua_touserdata(L, stackidx(ptop)))
+
+
+/*
+** Ensures the size of array 'capture' (with size '*capsize' and
+** 'captop' elements being used) is enough to accomodate 'n' extra
+** elements plus one.  (Because several opcodes add stuff to the capture
+** array, it is simpler to ensure the array always has at least one free
+** slot upfront and check its size later.)
+*/
+
+/* new size in number of elements cannot overflow integers, and new
+   size in bytes cannot overflow size_t. */
+#define MAXNEWSIZE  \
+    (((size_t)INT_MAX) <= (~(size_t)0 / sizeof(Capture)) ?  \
+     ((size_t)INT_MAX) : (~(size_t)0 / sizeof(Capture)))
+
+static Capture *growcap (lua_State *L, Capture *capture, int *capsize,
+                                       int captop, int n, int ptop) {
+  if (*capsize - captop > n)
+    return capture;  /* no need to grow array */
+  else {  /* must grow */
+    Capture *newc;
+    uint newsize = captop + n + 1;  /* minimum size needed */
+    if (newsize < (MAXNEWSIZE / 3) * 2)
+      newsize += newsize / 2;  /* 1.5 that size, if not too big */
+    else if (newsize < (MAXNEWSIZE / 9) * 8)
+      newsize += newsize / 8;  /* else, try 9/8 that size */
+    else
+      luaL_error(L, "too many captures");
+    newc = (Capture *)lua_newuserdata(L, newsize * sizeof(Capture));
+    memcpy(newc, capture, captop * sizeof(Capture));
+    *capsize = newsize;
+    lua_replace(L, caplistidx(ptop));
+    return newc;
+  }
+}
+
+
+/*
+** Double the size of the stack
+*/
+static Stack *doublestack (lua_State *L, Stack **stacklimit, int ptop) {
+  Stack *stack = getstackbase(L, ptop);
+  Stack *newstack;
+  int n = *stacklimit - stack;  /* current stack size */
+  int max, newn;
+  lua_getfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
+  max = lua_tointeger(L, -1);  /* maximum allowed size */
+  lua_pop(L, 1);
+  if (n >= max)  /* already at maximum size? */
+    luaL_error(L, "backtrack stack overflow (current limit is %d)", max);
+  newn = 2 * n;  /* new size */
+  if (newn > max) newn = max;
+  newstack = (Stack *)lua_newuserdata(L, newn * sizeof(Stack));
+  memcpy(newstack, stack, n * sizeof(Stack));
+  lua_replace(L, stackidx(ptop));
+  *stacklimit = newstack + newn;
+  return newstack + n;  /* return next position */
+}
+
+
+/*
+** Interpret the result of a dynamic capture: false -> fail;
+** true -> keep current position; number -> next position.
+** Return new subject position. 'fr' is stack index where
+** is the result; 'curr' is current subject position; 'limit'
+** is subject's size.
+*/
+static int resdyncaptures (lua_State *L, int fr, int curr, int limit) {
+  lua_Integer res;
+  if (!lua_toboolean(L, fr)) {  /* false value? */
+    lua_settop(L, fr - 1);  /* remove results */
+    return -1;  /* and fail */
+  }
+  else if (lua_isboolean(L, fr))  /* true? */
+    res = curr;  /* keep current position */
+  else {
+    res = lua_tointeger(L, fr) - 1;  /* new position */
+    if (res < curr || res > limit)
+      luaL_error(L, "invalid position returned by match-time capture");
+  }
+  lua_remove(L, fr);  /* remove first result (offset) */
+  return res;
+}
+
+
+/*
+** Add capture values returned by a dynamic capture to the list
+** 'capture', nested inside a group. 'fd' indexes the first capture
+** value, 'n' is the number of values (at least 1). The open group
+** capture is already in 'capture', before the place for the new entries.
+*/
+static void adddyncaptures (Index_t index, Capture *capture, int n, int fd) {
+  int i;
+  assert(capture[-1].kind == Cgroup && capture[-1].siz == 0);
+  capture[-1].idx = 0;  /* make group capture an anonymous group */
+  for (i = 0; i < n; i++) {  /* add runtime captures */
+    capture[i].kind = Cruntime;
+    capture[i].siz = 1;  /* mark it as closed */
+    capture[i].idx = fd + i;  /* stack index of capture value */
+    capture[i].index = index;
+  }
+  capture[n].kind = Cclose;  /* close group */
+  capture[n].siz = 1;
+  capture[n].index = index;
+}
+
+
+/*
+** Remove dynamic captures from the Lua stack (called in case of failure)
+*/
+static int removedyncap (lua_State *L, Capture *capture,
+                         int level, int last) {
+  int id = finddyncap(capture + level, capture + last);  /* index of 1st cap. */
+  int top = lua_gettop(L);
+  if (id == 0) return 0;  /* no dynamic captures? */
+  lua_settop(L, id - 1);  /* remove captures */
+  return top - id + 1;  /* number of values removed */
+}
+
+
+/*
+** Find the corresponding 'open' capture before 'cap', when that capture
+** can become a full capture. If a full capture c1 is followed by an
+** empty capture c2, there is no way to know whether c2 is inside
+** c1. So, full captures can enclose only captures that start *before*
+** its end.
+*/
+static Capture *findopen (Capture *cap, Index_t currindex) {
+  int i;
+  cap--;  /* check last capture */
+  /* Must it be inside current one, but starts where current one ends? */
+  if (!isopencap(cap) && cap->index == currindex)
+    return NULL;  /* current one cannot be a full capture */
+  /* else, look for an 'open' capture */
+  for (i = 0; i < MAXLOP; i++, cap--) {
+    if (currindex - cap->index >= UCHAR_MAX)
+      return NULL;  /* capture too long for a full capture */
+    else if (isopencap(cap))  /* open capture? */
+      return cap;  /* that's the one to be closed */
+    else if (cap->kind == Cclose)
+      return NULL;  /* a full capture should not nest a non-full one */
+  }
+  return NULL;  /* not found within allowed search limit */
+}
+
+
+/*
+** Opcode interpreter
+*/
+const char *match (lua_State *L, const char *o, const char *s, const char *e,
+                   Instruction *op, Capture *capture, int ptop) {
+  Stack stackbase[INITBACK];
+  Stack *stacklimit = stackbase + INITBACK;
+  Stack *stack = stackbase;  /* point to first empty slot in stack */
+  int capsize = INITCAPSIZE;
+  int captop = 0;  /* point to first empty slot in captures */
+  int ndyncap = 0;  /* number of dynamic captures (in Lua stack) */
+  const Instruction *p = op;  /* current instruction */
+  stack->p = &giveup; stack->s = s; stack->caplevel = 0; stack++;
+  lua_pushlightuserdata(L, stackbase);
+  for (;;) {
+#if defined(DEBUG)
+      printf("-------------------------------------\n");
+      printcaplist(capture, capture + captop);
+      printf("s: |%s| stck:%d, dyncaps:%d, caps:%d  ",
+             s, (int)(stack - getstackbase(L, ptop)), ndyncap, captop);
+      printinst(op, p);
+#endif
+    assert(stackidx(ptop) + ndyncap == lua_gettop(L) && ndyncap <= captop);
+    switch ((Opcode)p->i.code) {
+      case IEnd: {
+        assert(stack == getstackbase(L, ptop) + 1);
+        capture[captop].kind = Cclose;
+        capture[captop].index = MAXINDT;
+        return s;
+      }
+      case IGiveup: {
+        assert(stack == getstackbase(L, ptop));
+        return NULL;
+      }
+      case IRet: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s == NULL);
+        p = (--stack)->p;
+        continue;
+      }
+      case IAny: {
+        if (s < e) { p++; s++; }
+        else goto fail;
+        continue;
+      }
+      case IUTFR: {
+        int codepoint;
+        if (s >= e)
+          goto fail;
+        s = utf8_decode (s, &codepoint);
+        if (s && p[1].offset <= codepoint && codepoint <= utf_to(p))
+          p += 2;
+        else
+          goto fail;
+        continue;
+      }
+      case ITestAny: {
+        if (s < e) p += 2;
+        else p += getoffset(p);
+        continue;
+      }
+      case IChar: {
+        if ((byte)*s == p->i.aux1 && s < e) { p++; s++; }
+        else goto fail;
+        continue;
+      }
+      case ITestChar: {
+        if ((byte)*s == p->i.aux1 && s < e) p += 2;
+        else p += getoffset(p);
+        continue;
+      }
+      case ISet: {
+        uint c = (byte)*s;
+        if (charinset(p, (p+1)->buff, c) && s < e)
+          { p += 1 + p->i.aux2.set.size; s++; }
+        else goto fail;
+        continue;
+      }
+      case ITestSet: {
+        uint c = (byte)*s;
+        if (charinset(p, (p + 2)->buff, c) && s < e)
+          p += 2 + p->i.aux2.set.size;
+        else p += getoffset(p);
+        continue;
+      }
+      case IBehind: {
+        int n = p->i.aux1;
+        if (n > s - o) goto fail;
+        s -= n; p++;
+        continue;
+      }
+      case ISpan: {
+        for (; s < e; s++) {
+          uint c = (byte)*s;
+          if (!charinset(p, (p+1)->buff, c)) break;
+        }
+        p += 1 + p->i.aux2.set.size;
+        continue;
+      }
+      case IJmp: {
+        p += getoffset(p);
+        continue;
+      }
+      case IChoice: {
+        if (stack == stacklimit)
+          stack = doublestack(L, &stacklimit, ptop);
+        stack->p = p + getoffset(p);
+        stack->s = s;
+        stack->caplevel = captop;
+        stack++;
+        p += 2;
+        continue;
+      }
+      case ICall: {
+        if (stack == stacklimit)
+          stack = doublestack(L, &stacklimit, ptop);
+        stack->s = NULL;
+        stack->p = p + 2;  /* save return address */
+        stack++;
+        p += getoffset(p);
+        continue;
+      }
+      case ICommit: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
+        stack--;
+        p += getoffset(p);
+        continue;
+      }
+      case IPartialCommit: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
+        (stack - 1)->s = s;
+        (stack - 1)->caplevel = captop;
+        p += getoffset(p);
+        continue;
+      }
+      case IBackCommit: {
+        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
+        s = (--stack)->s;
+        if (ndyncap > 0)  /* are there matchtime captures? */
+          ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
+        captop = stack->caplevel;
+        p += getoffset(p);
+        continue;
+      }
+      case IFailTwice:
+        assert(stack > getstackbase(L, ptop));
+        stack--;
+        /* FALLTHROUGH */
+      case IFail:
+      fail: { /* pattern failed: try to backtrack */
+        do {  /* remove pending calls */
+          assert(stack > getstackbase(L, ptop));
+          s = (--stack)->s;
+        } while (s == NULL);
+        if (ndyncap > 0)  /* is there matchtime captures? */
+          ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
+        captop = stack->caplevel;
+        p = stack->p;
+#if defined(DEBUG)
+        printf("**FAIL**\n");
+#endif
+        continue;
+      }
+      case ICloseRunTime: {
+        CapState cs;
+        int rem, res, n;
+        int fr = lua_gettop(L) + 1;  /* stack index of first result */
+        cs.reclevel = 0; cs.L = L;
+        cs.s = o; cs.ocap = capture; cs.ptop = ptop;
+        n = runtimecap(&cs, capture + captop, s, &rem);  /* call function */
+        captop -= n;  /* remove nested captures */
+        ndyncap -= rem;  /* update number of dynamic captures */
+        fr -= rem;  /* 'rem' items were popped from Lua stack */
+        res = resdyncaptures(L, fr, s - o, e - o);  /* get result */
+        if (res == -1)  /* fail? */
+          goto fail;
+        s = o + res;  /* else update current position */
+        n = lua_gettop(L) - fr + 1;  /* number of new captures */
+        ndyncap += n;  /* update number of dynamic captures */
+        if (n == 0)  /* no new captures? */
+          captop--;  /* remove open group */
+        else {  /* new captures; keep original open group */
+          if (fr + n >= SHRT_MAX)
+            luaL_error(L, "too many results in match-time capture");
+          /* add new captures + close group to 'capture' list */
+          capture = growcap(L, capture, &capsize, captop, n + 1, ptop);
+          adddyncaptures(s - o, capture + captop, n, fr);
+          captop += n + 1;  /* new captures + close group */
+        }
+        p++;
+        continue;
+      }
+      case ICloseCapture: {
+        Capture *open = findopen(capture + captop, s - o);
+        assert(captop > 0);
+        if (open) {  /* if possible, turn capture into a full capture */
+          open->siz = (s - o) - open->index + 1;
+          p++;
+          continue;
+        }
+        else {  /* must create a close capture */
+          capture[captop].siz = 1;  /* mark entry as closed */
+          capture[captop].index = s - o;
+          goto pushcapture;
+        }
+      }
+      case IOpenCapture:
+        capture[captop].siz = 0;  /* mark entry as open */
+        capture[captop].index = s - o;
+        goto pushcapture;
+      case IFullCapture:
+        capture[captop].siz = getoff(p) + 1;  /* save capture size */
+        capture[captop].index = s - o - getoff(p);
+        /* goto pushcapture; */
+      pushcapture: {
+        capture[captop].idx = p->i.aux2.key;
+        capture[captop].kind = getkind(p);
+        captop++;
+        capture = growcap(L, capture, &capsize, captop, 0, ptop);
+        p++;
+        continue;
+      }
+      default: assert(0); return NULL;
+    }
+  }
+}
+
+/* }====================================================== */
+
+

3rd/lpeg/lpvm.h

@@ -0,0 +1,79 @@
+
+#if !defined(lpvm_h)
+#define lpvm_h
+
+#include "lpcap.h"
+
+
+/*
+** About Character sets in instructions: a set is a bit map with an
+** initial offset, in bits, and a size, in number of instructions.
+** aux1 has the default value for the bits outsize that range.
+*/
+
+
+/* Virtual Machine's instructions */
+typedef enum Opcode {
+  IAny, /* if no char, fail */
+  IChar,  /* if char != aux1, fail */
+  ISet,  /* if char not in set, fail */
+  ITestAny,  /* in no char, jump to 'offset' */
+  ITestChar,  /* if char != aux1, jump to 'offset' */
+  ITestSet,  /* if char not in set, jump to 'offset' */
+  ISpan,  /* read a span of chars in set */
+  IUTFR,  /* if codepoint not in range [offset, utf_to], fail */
+  IBehind,  /* walk back 'aux1' characters (fail if not possible) */
+  IRet,  /* return from a rule */
+  IEnd,  /* end of pattern */
+  IChoice,  /* stack a choice; next fail will jump to 'offset' */
+  IJmp,  /* jump to 'offset' */
+  ICall,  /* call rule at 'offset' */
+  IOpenCall,  /* call rule number 'key' (must be closed to a ICall) */
+  ICommit,  /* pop choice and jump to 'offset' */
+  IPartialCommit,  /* update top choice to current position and jump */
+  IBackCommit,  /* backtrack like "fail" but jump to its own 'offset' */
+  IFailTwice,  /* pop one choice and then fail */
+  IFail,  /* go back to saved state on choice and jump to saved offset */
+  IGiveup,  /* internal use */
+  IFullCapture,  /* complete capture of last 'off' chars */
+  IOpenCapture,  /* start a capture */
+  ICloseCapture,
+  ICloseRunTime,
+  IEmpty  /* to fill empty slots left by optimizations */
+} Opcode;
+
+
+/*
+** All array of instructions has a 'codesize' as its first element
+** and is referred by a pointer to its second element, which is the
+** first actual opcode.
+*/
+typedef union Instruction {
+  struct Inst {
+    byte code;
+    byte aux1;
+    union {
+      short key;
+      struct {
+        byte offset;
+        byte size;
+      } set;
+    } aux2;
+  } i;
+  int offset;
+  uint codesize;
+  byte buff[1];
+} Instruction;
+
+
+/* extract 24-bit value from an instruction */
+#define utf_to(inst)	(((inst)->i.aux2.key << 8) | (inst)->i.aux1)
+
+
+int charinset (const Instruction *i, const byte *buff, uint c);
+const char *match (lua_State *L, const char *o, const char *s, const char *e,
+                   Instruction *op, Capture *capture, int ptop);
+
+
+#endif
+

3rd/lpeg/makefile

@@ -0,0 +1,59 @@
+LIBNAME = lpeg
+LUADIR = ../lua/
+
+COPT = -O2 -DNDEBUG
+# COPT = -O0 -DLPEG_DEBUG -g
+
+CWARNS = -Wall -Wextra -pedantic \
+	-Waggregate-return \
+	-Wcast-align \
+	-Wcast-qual \
+	-Wdisabled-optimization \
+	-Wpointer-arith \
+	-Wshadow \
+	-Wredundant-decls \
+	-Wsign-compare \
+	-Wundef \
+	-Wwrite-strings \
+	-Wbad-function-cast \
+	-Wdeclaration-after-statement \
+	-Wmissing-prototypes \
+	-Wmissing-declarations \
+	-Wnested-externs \
+	-Wstrict-prototypes \
+	-Wc++-compat \
+# -Wunreachable-code \
+
+
+CFLAGS = $(CWARNS) $(COPT) -std=c99 -I$(LUADIR) -fPIC
+CC = gcc
+
+FILES = lpvm.o lpcap.o lptree.o lpcode.o lpprint.o lpcset.o
+
+# For Linux
+linux:
+	$(MAKE) lpeg.so "DLLFLAGS = -shared -fPIC"
+
+# For Mac OS
+macosx:
+	$(MAKE) lpeg.so "DLLFLAGS = -bundle -undefined dynamic_lookup"
+
+lpeg.so: $(FILES)
+	env $(CC) $(DLLFLAGS) $(FILES) -o lpeg.so
+
+$(FILES): makefile
+
+test: test.lua re.lua lpeg.so
+	./test.lua
+
+clean:
+	rm -f $(FILES) lpeg.so
+
+
+lpcap.o: lpcap.c lpcap.h lptypes.h
+lpcode.o: lpcode.c lptypes.h lpcode.h lptree.h lpvm.h lpcap.h lpcset.h
+lpcset.o: lpcset.c lptypes.h lpcset.h lpcode.h lptree.h lpvm.h lpcap.h
+lpprint.o: lpprint.c lptypes.h lpprint.h lptree.h lpvm.h lpcap.h lpcode.h
+lptree.o: lptree.c lptypes.h lpcap.h lpcode.h lptree.h lpvm.h lpprint.h \
+ lpcset.h
+lpvm.o: lpvm.c lpcap.h lptypes.h lpvm.h lpprint.h lptree.h

3rd/lpeg/re.html

@@ -0,0 +1,472 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+   "//www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+<head>
+    <title>LPeg.re - Regex syntax for LPEG</title>
+    <link rel="stylesheet"
+          href="//www.inf.puc-rio.br/~roberto/lpeg/doc.css"
+          type="text/css"/>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+</head>
+<body>
+
+
+<div id="container">
+	
+<div id="product">
+  <div id="product_logo">
+    <a href="//www.inf.puc-rio.br/~roberto/lpeg/">
+    <img alt="LPeg logo" src="lpeg-128.gif"/>
+    </a>
+  </div>
+  <div id="product_name"><big><strong>LPeg.re</strong></big></div>
+  <div id="product_description">
+     Regex syntax for LPEG
+  </div>
+</div> <!-- id="product" -->
+
+<div id="main">
+	
+<div id="navigation">
+<h1>re</h1>
+
+<ul>
+  <li><a href="#basic">Basic Constructions</a></li>
+  <li><a href="#func">Functions</a></li>
+  <li><a href="#ex">Some Examples</a></li>
+  <li><a href="#license">License</a></li>
+  </ul>
+  </li>
+</ul>
+</div> <!-- id="navigation" -->
+
+<div id="content">
+
+<h2><a name="basic"></a>The <code>re</code> Module</h2>
+
+<p>
+The <code>re</code> module
+(provided by file <code>re.lua</code> in the distribution)
+supports a somewhat conventional regex syntax
+for pattern usage within <a href="lpeg.html">LPeg</a>.
+</p>
+
+<p>
+The next table summarizes <code>re</code>'s syntax.
+A <code>p</code> represents an arbitrary pattern;
+<code>num</code> represents a number (<code>[0-9]+</code>);
+<code>name</code> represents an identifier
+(<code>[a-zA-Z][a-zA-Z0-9_]*</code>).
+Constructions are listed in order of decreasing precedence.
+<table border="1">
+<tbody><tr><td><b>Syntax</b></td><td><b>Description</b></td></tr>
+<tr><td><code>( p )</code></td> <td>grouping</td></tr>
+<tr><td><code>&amp; p</code></td> <td>and predicate</td></tr>
+<tr><td><code>! p</code></td> <td>not predicate</td></tr>
+<tr><td><code>p1 p2</code></td> <td>concatenation</td></tr>
+<tr><td><code>p1 / p2</code></td> <td>ordered choice</td></tr>
+<tr><td><code>p ?</code></td> <td>optional match</td></tr>
+<tr><td><code>p *</code></td> <td>zero or more repetitions</td></tr>
+<tr><td><code>p +</code></td> <td>one or more repetitions</td></tr>
+<tr><td><code>p^num</code></td>
+      <td>exactly <code>num</code> repetitions</td></tr>
+<tr><td><code>p^+num</code></td>
+      <td>at least <code>num</code> repetitions</td></tr>
+<tr><td><code>p^-num</code></td>
+      <td>at most <code>num</code> repetitions</td></tr>
+<tr><td>(<code>name &lt;- p</code>)<sup>+</sup></td> <td>grammar</td></tr>
+<tr><td><code>'string'</code></td> <td>literal string</td></tr>
+<tr><td><code>"string"</code></td> <td>literal string</td></tr>
+<tr><td><code>[class]</code></td> <td>character class</td></tr>
+<tr><td><code>.</code></td> <td>any character</td></tr>
+<tr><td><code>%name</code></td>
+  <td>pattern <code>defs[name]</code> or a pre-defined pattern</td></tr>
+<tr><td><code>name</code></td><td>non terminal</td></tr>
+<tr><td><code>&lt;name&gt;</code></td><td>non terminal</td></tr>
+
+<tr><td><code>{}</code></td> <td>position capture</td></tr>
+<tr><td><code>{ p }</code></td> <td>simple capture</td></tr>
+<tr><td><code>{: p :}</code></td> <td>anonymous group capture</td></tr>
+<tr><td><code>{:name: p :}</code></td> <td>named group capture</td></tr>
+<tr><td><code>{~ p ~}</code></td> <td>substitution capture</td></tr>
+<tr><td><code>{| p |}</code></td> <td>table capture</td></tr>
+<tr><td><code>=name</code></td> <td>back reference</td></tr>
+
+<tr><td><code>p -&gt; 'string'</code></td> <td>string capture</td></tr>
+<tr><td><code>p -&gt; "string"</code></td> <td>string capture</td></tr>
+<tr><td><code>p -&gt; num</code></td> <td>numbered capture</td></tr>
+<tr><td><code>p -&gt; name</code></td> <td>function/query/string capture
+equivalent to <code>p / defs[name]</code></td></tr>
+<tr><td><code>p =&gt; name</code></td> <td>match-time capture
+equivalent to <code>lpeg.Cmt(p, defs[name])</code></td></tr>
+<tr><td><code>p ~&gt; name</code></td> <td>fold capture
+(deprecated)</td></tr>
+<tr><td><code>p &gt;&gt; name</code></td> <td>accumulator capture
+equivalent to <code>(p % defs[name])</code></td></tr>
+</tbody></table>
+<p>
+Any space appearing in a syntax description can be
+replaced by zero or more space characters and Lua-style short comments
+(<code>--</code> until end of line).
+</p>
+
+<p>
+Character classes define sets of characters.
+An initial <code>^</code> complements the resulting set.
+A range <em>x</em><code>-</code><em>y</em> includes in the set
+all characters with codes between the codes of <em>x</em> and <em>y</em>.
+A pre-defined class <code>%</code><em>name</em> includes all
+characters of that class.
+A simple character includes itself in the set.
+The only special characters inside a class are <code>^</code>
+(special only if it is the first character);
+<code>]</code>
+(can be included in the set as the first character,
+after the optional <code>^</code>);
+<code>%</code> (special only if followed by a letter);
+and <code>-</code>
+(can be included in the set as the first or the last character).
+</p>
+
+<p>
+Currently the pre-defined classes are similar to those from the
+Lua's string library
+(<code>%a</code> for letters,
+<code>%A</code> for non letters, etc.).
+There is also a class <code>%nl</code>
+containing only the newline character,
+which is particularly handy for grammars written inside long strings,
+as long strings do not interpret escape sequences like <code>\n</code>.
+</p>
+
+
+<h2><a name="func">Functions</a></h2>
+
+<h3><code>re.compile (string, [, defs])</code></h3>
+<p>
+Compiles the given string and
+returns an equivalent LPeg pattern.
+The given string may define either an expression or a grammar.
+The optional <code>defs</code> table provides extra Lua values
+to be used by the pattern.
+</p>
+
+<h3><code>re.find (subject, pattern [, init])</code></h3>
+<p>
+Searches the given pattern in the given subject.
+If it finds a match,
+returns the index where this occurrence starts and
+the index where it ends.
+Otherwise, returns nil.
+</p>
+
+<p>
+An optional numeric argument <code>init</code> makes the search
+starts at that position in the subject string.
+As usual in Lua libraries,
+a negative value counts from the end.
+</p>
+
+<h3><code>re.gsub (subject, pattern, replacement)</code></h3>
+<p>
+Does a <em>global substitution</em>,
+replacing all occurrences of <code>pattern</code>
+in the given <code>subject</code> by <code>replacement</code>.
+
+<h3><code>re.match (subject, pattern)</code></h3>
+<p>
+Matches the given pattern against the given subject,
+returning all captures.
+</p>
+
+<h3><code>re.updatelocale ()</code></h3>
+<p>
+Updates the pre-defined character classes to the current locale.
+</p>
+
+
+<h2><a name="ex">Some Examples</a></h2>
+
+<h3>A complete simple program</h3>
+<p>
+The next code shows a simple complete Lua program using
+the <code>re</code> module:
+</p>
+<pre class="example">
+local re = require"re"
+
+-- find the position of the first numeral in a string
+print(re.find("the number 423 is odd", "[0-9]+"))  --&gt; 12    14
+
+-- returns all words in a string
+print(re.match("the number 423 is odd", "({%a+} / .)*"))
+--&gt; the    number    is    odd
+
+-- returns the first numeral in a string
+print(re.match("the number 423 is odd", "s &lt;- {%d+} / . s"))
+--&gt; 423
+
+-- substitutes a dot for each vowel in a string
+print(re.gsub("hello World", "[aeiou]", "."))
+--&gt; h.ll. W.rld
+</pre>
+
+
+<h3>Balanced parentheses</h3>
+<p>
+The following call will produce the same pattern produced by the
+Lua expression in the
+<a href="lpeg.html#balanced">balanced parentheses</a> example:
+</p>
+<pre class="example">
+b = re.compile[[  balanced &lt;- "(" ([^()] / balanced)* ")"  ]]
+</pre>
+
+<h3>String reversal</h3>
+<p>
+The next example reverses a string:
+</p>
+<pre class="example">
+rev = re.compile[[ R &lt;- (!.) -&gt; '' / ({.} R) -&gt; '%2%1']]
+print(rev:match"0123456789")   --&gt; 9876543210
+</pre>
+
+<h3>CSV decoder</h3>
+<p>
+The next example replicates the <a href="lpeg.html#CSV">CSV decoder</a>:
+</p>
+<pre class="example">
+record = re.compile[[
+  record &lt;- {| field (',' field)* |} (%nl / !.)
+  field &lt;- escaped / nonescaped
+  nonescaped &lt;- { [^,"%nl]* }
+  escaped &lt;- '"' {~ ([^"] / '""' -&gt; '"')* ~} '"'
+]]
+</pre>
+
+<h3>Lua's long strings</h3>
+<p>
+The next example matches Lua long strings:
+</p>
+<pre class="example">
+c = re.compile([[
+  longstring &lt;- ('[' {:eq: '='* :} '[' close)
+  close &lt;- ']' =eq ']' / . close
+]])
+
+print(c:match'[==[]]===]]]]==]===[]')   --&gt; 17
+</pre>
+
+<h3>Abstract Syntax Trees</h3>
+<p>
+This example shows a simple way to build an
+abstract syntax tree (AST) for a given grammar.
+To keep our example simple,
+let us consider the following grammar
+for lists of names:
+</p>
+<pre class="example">
+p = re.compile[[
+      listname &lt;- (name s)*
+      name &lt;- [a-z][a-z]*
+      s &lt;- %s*
+]]
+</pre>
+<p>
+Now, we will add captures to build a corresponding AST.
+As a first step, the pattern will build a table to
+represent each non terminal;
+terminals will be represented by their corresponding strings:
+</p>
+<pre class="example">
+c = re.compile[[
+      listname &lt;- {| (name s)* |}
+      name &lt;- {| {[a-z][a-z]*} |}
+      s &lt;- %s*
+]]
+</pre>
+<p>
+Now, a match against <code>"hi hello bye"</code>
+results in the table
+<code>{{"hi"}, {"hello"}, {"bye"}}</code>.
+</p>
+<p>
+For such a simple grammar,
+this AST is more than enough;
+actually, the tables around each single name
+are already overkilling.
+More complex grammars,
+however, may need some more structure.
+Specifically,
+it would be useful if each table had
+a <code>tag</code> field telling what non terminal
+that table represents.
+We can add such a tag using
+<a href="lpeg.html#cap-g">named group captures</a>:
+</p>
+<pre class="example">
+x = re.compile[[
+      listname <- {| {:tag: '' -> 'list':} (name s)* |}
+      name <- {| {:tag: '' -> 'id':} {[a-z][a-z]*} |}
+      s <- ' '*
+]]
+</pre>
+<p>
+With these group captures,
+a match against <code>"hi hello bye"</code>
+results in the following table:
+</p>
+<pre class="example">
+{tag="list",
+  {tag="id", "hi"},
+  {tag="id", "hello"},
+  {tag="id", "bye"}
+}
+</pre>
+
+
+<h3>Indented blocks</h3>
+<p>
+This example breaks indented blocks into tables,
+respecting the indentation:
+</p>
+<pre class="example">
+p = re.compile[[
+  block &lt;- {| {:ident:' '*:} line
+           ((=ident !' ' line) / &amp;(=ident ' ') block)* |}
+  line &lt;- {[^%nl]*} %nl
+]]
+</pre>
+<p>
+As an example,
+consider the following text:
+</p>
+<pre class="example">
+t = p:match[[
+first line
+  subline 1
+  subline 2
+second line
+third line
+  subline 3.1
+    subline 3.1.1
+  subline 3.2
+]]
+</pre>
+<p>
+The resulting table <code>t</code> will be like this:
+</p>
+<pre class="example">
+   {'first line'; {'subline 1'; 'subline 2'; ident = '  '};
+    'second line';
+    'third line'; { 'subline 3.1'; {'subline 3.1.1'; ident = '    '};
+                    'subline 3.2'; ident = '  '};
+    ident = ''}
+</pre>
+
+<h3>Macro expander</h3>
+<p>
+This example implements a simple macro expander.
+Macros must be defined as part of the pattern,
+following some simple rules:
+</p>
+<pre class="example">
+p = re.compile[[
+      text &lt;- {~ item* ~}
+      item &lt;- macro / [^()] / '(' item* ')'
+      arg &lt;- ' '* {~ (!',' item)* ~}
+      args &lt;- '(' arg (',' arg)* ')'
+      -- now we define some macros
+      macro &lt;- ('apply' args) -&gt; '%1(%2)'
+             / ('add' args) -&gt; '%1 + %2'
+             / ('mul' args) -&gt; '%1 * %2'
+]]
+
+print(p:match"add(mul(a,b), apply(f,x))")   --&gt; a * b + f(x)
+</pre>
+<p>
+A <code>text</code> is a sequence of items,
+wherein we apply a substitution capture to expand any macros.
+An <code>item</code> is either a macro,
+any character different from parentheses,
+or a parenthesized expression.
+A macro argument (<code>arg</code>) is a sequence
+of items different from a comma.
+(Note that a comma may appear inside an item,
+e.g., inside a parenthesized expression.)
+Again we do a substitution capture to expand any macro
+in the argument before expanding the outer macro.
+<code>args</code> is a list of arguments separated by commas.
+Finally we define the macros.
+Each macro is a string substitution;
+it replaces the macro name and its arguments by its corresponding string,
+with each <code>%</code><em>n</em> replaced by the <em>n</em>-th argument.
+</p>
+
+<h3>Patterns</h3>
+<p>
+This example shows the complete syntax
+of patterns accepted by <code>re</code>.
+</p>
+<pre class="example">
+p = [=[
+
+pattern         &lt;- exp !.
+exp             &lt;- S (grammar / alternative)
+
+alternative     &lt;- seq ('/' S seq)*
+seq             &lt;- prefix*
+prefix          &lt;- '&amp;' S prefix / '!' S prefix / suffix
+suffix          &lt;- primary S (([+*?]
+                            / '^' [+-]? num
+                            / '-&gt;' S (string / '{}' / name)
+                            / '&gt&gt;' S name
+                            / '=&gt;' S name) S)*
+
+primary         &lt;- '(' exp ')' / string / class / defined
+                 / '{:' (name ':')? exp ':}'
+                 / '=' name
+                 / '{}'
+                 / '{~' exp '~}'
+                 / '{|' exp '|}'
+                 / '{' exp '}'
+                 / '.'
+                 / name S !arrow
+                 / '&lt;' name '&gt;'          -- old-style non terminals
+
+grammar         &lt;- definition+
+definition      &lt;- name S arrow exp
+
+class           &lt;- '[' '^'? item (!']' item)* ']'
+item            &lt;- defined / range / .
+range           &lt;- . '-' [^]]
+
+S               &lt;- (%s / '--' [^%nl]*)*   -- spaces and comments
+name            &lt;- [A-Za-z_][A-Za-z0-9_]*
+arrow           &lt;- '&lt;-'
+num             &lt;- [0-9]+
+string          &lt;- '"' [^"]* '"' / "'" [^']* "'"
+defined         &lt;- '%' name
+
+]=]
+
+print(re.match(p, p))   -- a self description must match itself
+</pre>
+
+
+
+<h2><a name="license">License</a></h2>
+
+<p>
+This module is part of the <a href="lpeg.html">LPeg</a> package and shares
+its <a href="lpeg.html#license">license</a>.
+
+
+</div> <!-- id="content" -->
+
+</div> <!-- id="main" -->
+
+</div> <!-- id="container" -->
+
+</body>
+</html> 

3rd/lpeg/re.lua

@@ -0,0 +1,270 @@
+--
+-- Copyright 2007-2023, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
+-- written by Roberto Ierusalimschy
+--
+
+-- imported functions and modules
+local tonumber, type, print, error = tonumber, type, print, error
+local setmetatable = setmetatable
+local m = require"lpeg"
+
+-- 'm' will be used to parse expressions, and 'mm' will be used to
+-- create expressions; that is, 're' runs on 'm', creating patterns
+-- on 'mm'
+local mm = m
+
+-- patterns' metatable
+local mt = getmetatable(mm.P(0))
+
+
+local version = _VERSION
+
+-- No more global accesses after this point
+_ENV = nil     -- does no harm in Lua 5.1
+
+
+local any = m.P(1)
+
+
+-- Pre-defined names
+local Predef = { nl = m.P"\n" }
+
+
+local mem
+local fmem
+local gmem
+
+
+local function updatelocale ()
+  mm.locale(Predef)
+  Predef.a = Predef.alpha
+  Predef.c = Predef.cntrl
+  Predef.d = Predef.digit
+  Predef.g = Predef.graph
+  Predef.l = Predef.lower
+  Predef.p = Predef.punct
+  Predef.s = Predef.space
+  Predef.u = Predef.upper
+  Predef.w = Predef.alnum
+  Predef.x = Predef.xdigit
+  Predef.A = any - Predef.a
+  Predef.C = any - Predef.c
+  Predef.D = any - Predef.d
+  Predef.G = any - Predef.g
+  Predef.L = any - Predef.l
+  Predef.P = any - Predef.p
+  Predef.S = any - Predef.s
+  Predef.U = any - Predef.u
+  Predef.W = any - Predef.w
+  Predef.X = any - Predef.x
+  mem = {}    -- restart memoization
+  fmem = {}
+  gmem = {}
+  local mt = {__mode = "v"}
+  setmetatable(mem, mt)
+  setmetatable(fmem, mt)
+  setmetatable(gmem, mt)
+end
+
+
+updatelocale()
+
+
+
+local I = m.P(function (s,i) print(i, s:sub(1, i-1)); return i end)
+
+
+local function patt_error (s, i)
+  local msg = (#s < i + 20) and s:sub(i)
+                             or s:sub(i,i+20) .. "..."
+  msg = ("pattern error near '%s'"):format(msg)
+  error(msg, 2)
+end
+
+local function mult (p, n)
+  local np = mm.P(true)
+  while n >= 1 do
+    if n%2 >= 1 then np = np * p end
+    p = p * p
+    n = n/2
+  end
+  return np
+end
+
+local function equalcap (s, i, c)
+  if type(c) ~= "string" then return nil end
+  local e = #c + i
+  if s:sub(i, e - 1) == c then return e else return nil end
+end
+
+
+local S = (Predef.space + "--" * (any - Predef.nl)^0)^0
+
+local name = m.R("AZ", "az", "__") * m.R("AZ", "az", "__", "09")^0
+
+local arrow = S * "<-"
+
+local seq_follow = m.P"/" + ")" + "}" + ":}" + "~}" + "|}" + (name * arrow) + -1
+
+name = m.C(name)
+
+
+-- a defined name only have meaning in a given environment
+local Def = name * m.Carg(1)
+
+
+local function getdef (id, defs)
+  local c = defs and defs[id]
+  if not c then error("undefined name: " .. id) end
+  return c
+end
+
+-- match a name and return a group of its corresponding definition
+-- and 'f' (to be folded in 'Suffix')
+local function defwithfunc (f)
+  return m.Cg(Def / getdef * m.Cc(f))
+end
+
+
+local num = m.C(m.R"09"^1) * S / tonumber
+
+local String = "'" * m.C((any - "'")^0) * "'" +
+               '"' * m.C((any - '"')^0) * '"'
+
+
+local defined = "%" * Def / function (c,Defs)
+  local cat =  Defs and Defs[c] or Predef[c]
+  if not cat then error ("name '" .. c .. "' undefined") end
+  return cat
+end
+
+local Range = m.Cs(any * (m.P"-"/"") * (any - "]")) / mm.R
+
+local item = (defined + Range + m.C(any)) / m.P
+
+local Class =
+    "["
+  * (m.C(m.P"^"^-1))    -- optional complement symbol
+  * (item * ((item % mt.__add) - "]")^0) /
+                          function (c, p) return c == "^" and any - p or p end
+  * "]"
+
+local function adddef (t, k, exp)
+  if t[k] then
+    error("'"..k.."' already defined as a rule")
+  else
+    t[k] = exp
+  end
+  return t
+end
+
+local function firstdef (n, r) return adddef({n}, n, r) end
+
+
+local function NT (n, b)
+  if not b then
+    error("rule '"..n.."' used outside a grammar")
+  else return mm.V(n)
+  end
+end
+
+
+local exp = m.P{ "Exp",
+  Exp = S * ( m.V"Grammar"
+            + m.V"Seq" * ("/" * S * m.V"Seq" % mt.__add)^0 );
+  Seq = (m.Cc(m.P"") * (m.V"Prefix" % mt.__mul)^0)
+        * (#seq_follow + patt_error);
+  Prefix = "&" * S * m.V"Prefix" / mt.__len
+         + "!" * S * m.V"Prefix" / mt.__unm
+         + m.V"Suffix";
+  Suffix = m.V"Primary" * S *
+          ( ( m.P"+" * m.Cc(1, mt.__pow)
+            + m.P"*" * m.Cc(0, mt.__pow)
+            + m.P"?" * m.Cc(-1, mt.__pow)
+            + "^" * ( m.Cg(num * m.Cc(mult))
+                    + m.Cg(m.C(m.S"+-" * m.R"09"^1) * m.Cc(mt.__pow))
+                    )
+            + "->" * S * ( m.Cg((String + num) * m.Cc(mt.__div))
+                         + m.P"{}" * m.Cc(nil, m.Ct)
+                         + defwithfunc(mt.__div)
+                         )
+            + "=>" * S * defwithfunc(mm.Cmt)
+            + ">>" * S * defwithfunc(mt.__mod)
+            + "~>" * S * defwithfunc(mm.Cf)
+            ) % function (a,b,f) return f(a,b) end * S
+          )^0;
+  Primary = "(" * m.V"Exp" * ")"
+            + String / mm.P
+            + Class
+            + defined
+            + "{:" * (name * ":" + m.Cc(nil)) * m.V"Exp" * ":}" /
+                     function (n, p) return mm.Cg(p, n) end
+            + "=" * name / function (n) return mm.Cmt(mm.Cb(n), equalcap) end
+            + m.P"{}" / mm.Cp
+            + "{~" * m.V"Exp" * "~}" / mm.Cs
+            + "{|" * m.V"Exp" * "|}" / mm.Ct
+            + "{" * m.V"Exp" * "}" / mm.C
+            + m.P"." * m.Cc(any)
+            + (name * -arrow + "<" * name * ">") * m.Cb("G") / NT;
+  Definition = name * arrow * m.V"Exp";
+  Grammar = m.Cg(m.Cc(true), "G") *
+            ((m.V"Definition" / firstdef) * (m.V"Definition" % adddef)^0) / mm.P
+}
+
+local pattern = S * m.Cg(m.Cc(false), "G") * exp / mm.P * (-any + patt_error)
+
+
+local function compile (p, defs)
+  if mm.type(p) == "pattern" then return p end   -- already compiled
+  local cp = pattern:match(p, 1, defs)
+  if not cp then error("incorrect pattern", 3) end
+  return cp
+end
+
+local function match (s, p, i)
+  local cp = mem[p]
+  if not cp then
+    cp = compile(p)
+    mem[p] = cp
+  end
+  return cp:match(s, i or 1)
+end
+
+local function find (s, p, i)
+  local cp = fmem[p]
+  if not cp then
+    cp = compile(p) / 0
+    cp = mm.P{ mm.Cp() * cp * mm.Cp() + 1 * mm.V(1) }
+    fmem[p] = cp
+  end
+  local i, e = cp:match(s, i or 1)
+  if i then return i, e - 1
+  else return i
+  end
+end
+
+local function gsub (s, p, rep)
+  local g = gmem[p] or {}   -- ensure gmem[p] is not collected while here
+  gmem[p] = g
+  local cp = g[rep]
+  if not cp then
+    cp = compile(p)
+    cp = mm.Cs((cp / rep + 1)^0)
+    g[rep] = cp
+  end
+  return cp:match(s)
+end
+
+
+-- exported names
+local re = {
+  compile = compile,
+  match = match,
+  find = find,
+  gsub = gsub,
+  updatelocale = updatelocale,
+}
+
+if version == "Lua 5.1" then _G.re = re end
+
+return re

3rd/lua-cjson/CMakeLists.txt

@@ -1,76 +0,0 @@
-# If Lua is installed in a non-standard location, please set the LUA_DIR
-# environment variable to point to prefix for the install. Eg:
-#       Unix: export LUA_DIR=/home/user/pkg
-#       Windows: set LUA_DIR=c:\lua51
-
-project(lua-cjson C)
-cmake_minimum_required(VERSION 2.6)
-
-option(USE_INTERNAL_FPCONV "Use internal strtod() / g_fmt() code for performance")
-option(MULTIPLE_THREADS "Support multi-threaded apps with internal fpconv - recommended" ON)
-
-if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release CACHE STRING
-        "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
-        FORCE)
-endif()
-
-find_package(Lua51 REQUIRED)
-include_directories(${LUA_INCLUDE_DIR})
-
-if(NOT USE_INTERNAL_FPCONV)
-    # Use libc number conversion routines (strtod(), sprintf())
-    set(FPCONV_SOURCES fpconv.c)
-else()
-    # Use internal number conversion routines
-    add_definitions(-DUSE_INTERNAL_FPCONV)
-    set(FPCONV_SOURCES g_fmt.c dtoa.c)
-
-    include(TestBigEndian)
-    TEST_BIG_ENDIAN(IEEE_BIG_ENDIAN)
-    if(IEEE_BIG_ENDIAN)
-        add_definitions(-DIEEE_BIG_ENDIAN)
-    endif()
-
-    if(MULTIPLE_THREADS)
-        set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-        find_package(Threads REQUIRED)
-        if(NOT CMAKE_USE_PTHREADS_INIT)
-            message(FATAL_ERROR
-                    "Pthreads not found - required by MULTIPLE_THREADS option")
-        endif()
-        add_definitions(-DMULTIPLE_THREADS)
-    endif()
-endif()
-
-# Handle platforms missing isinf() macro (Eg, some Solaris systems).
-include(CheckSymbolExists)
-CHECK_SYMBOL_EXISTS(isinf math.h HAVE_ISINF)
-if(NOT HAVE_ISINF)
-    add_definitions(-DUSE_INTERNAL_ISINF)
-endif()
-
-set(_MODULE_LINK "${CMAKE_THREAD_LIBS_INIT}")
-get_filename_component(_lua_lib_dir ${LUA_LIBRARY} PATH)
-
-if(APPLE)
-    set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS
-        "${CMAKE_SHARED_MODULE_CREATE_C_FLAGS} -undefined dynamic_lookup")
-endif()
-
-if(WIN32)
-    # Win32 modules need to be linked to the Lua library.
-    set(_MODULE_LINK ${LUA_LIBRARY} ${_MODULE_LINK})
-    set(_lua_module_dir "${_lua_lib_dir}")
-    # Windows sprintf()/strtod() handle NaN/inf differently. Not supported.
-    add_definitions(-DDISABLE_INVALID_NUMBERS)
-else()
-    set(_lua_module_dir "${_lua_lib_dir}/lua/5.1")
-endif()
-
-add_library(cjson MODULE lua_cjson.c strbuf.c ${FPCONV_SOURCES})
-set_target_properties(cjson PROPERTIES PREFIX "")
-target_link_libraries(cjson ${_MODULE_LINK})
-install(TARGETS cjson DESTINATION "${_lua_module_dir}")
-
-# vi:ai et sw=4 ts=4:

3rd/lua-cjson/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2010-2012  Mark Pulford <mark@kyne.com.au>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

3rd/lua-cjson/Makefile

@@ -1,119 +0,0 @@
-##### Available defines for CJSON_CFLAGS #####
-##
-## USE_INTERNAL_ISINF:      Workaround for Solaris platforms missing isinf().
-## DISABLE_INVALID_NUMBERS: Permanently disable invalid JSON numbers:
-##                          NaN, Infinity, hex.
-##
-## Optional built-in number conversion uses the following defines:
-## USE_INTERNAL_FPCONV:     Use builtin strtod/dtoa for numeric conversions.
-## IEEE_BIG_ENDIAN:         Required on big endian architectures.
-## MULTIPLE_THREADS:        Must be set when Lua CJSON may be used in a
-##                          multi-threaded application. Requries _pthreads_.
-
-##### Build defaults #####
-LUA_VERSION =       5.1
-TARGET =            cjson.so
-PREFIX =            /usr/local
-#CFLAGS =            -g -Wall -pedantic -fno-inline
-CFLAGS =            -O3 -Wall -pedantic -DNDEBUG
-CJSON_CFLAGS =      -fpic
-CJSON_LDFLAGS =     -shared
-LUA_INCLUDE_DIR =   $(PREFIX)/include
-LUA_CMODULE_DIR =   $(PREFIX)/lib/lua/$(LUA_VERSION)
-LUA_MODULE_DIR =    $(PREFIX)/share/lua/$(LUA_VERSION)
-LUA_BIN_DIR =       $(PREFIX)/bin
-
-##### Platform overrides #####
-##
-## Tweak one of the platform sections below to suit your situation.
-##
-## See http://lua-users.org/wiki/BuildingModules for further platform
-## specific details.
-
-## Linux
-
-## FreeBSD
-#LUA_INCLUDE_DIR =   $(PREFIX)/include/lua51
-
-## MacOSX (Macports)
-#PREFIX =            /opt/local
-#CJSON_LDFLAGS =     -bundle -undefined dynamic_lookup
-
-## Solaris
-#CC           =      gcc
-#CJSON_CFLAGS =      -fpic -DUSE_INTERNAL_ISINF
-
-## Windows (MinGW)
-#TARGET =            cjson.dll
-#PREFIX =            /home/user/opt
-#CJSON_CFLAGS =      -DDISABLE_INVALID_NUMBERS
-#CJSON_LDFLAGS =     -shared -L$(PREFIX)/lib -llua51
-#LUA_BIN_SUFFIX =    .lua
-
-##### Number conversion configuration #####
-
-## Use Libc support for number conversion (default)
-FPCONV_OBJS =       fpconv.o
-
-## Use built in number conversion
-#FPCONV_OBJS =       g_fmt.o dtoa.o
-#CJSON_CFLAGS +=     -DUSE_INTERNAL_FPCONV
-
-## Compile built in number conversion for big endian architectures
-#CJSON_CFLAGS +=     -DIEEE_BIG_ENDIAN
-
-## Compile built in number conversion to support multi-threaded
-## applications (recommended)
-#CJSON_CFLAGS +=     -pthread -DMULTIPLE_THREADS
-#CJSON_LDFLAGS +=    -pthread
-
-##### End customisable sections #####
-
-TEST_FILES =        README bench.lua genutf8.pl test.lua octets-escaped.dat \
-                    example1.json example2.json example3.json example4.json \
-                    example5.json numbers.json rfc-example1.json \
-                    rfc-example2.json types.json
-DATAPERM =          644
-EXECPERM =          755
-
-ASCIIDOC =          asciidoc
-
-BUILD_CFLAGS =      -I$(LUA_INCLUDE_DIR) $(CJSON_CFLAGS)
-OBJS =              lua_cjson.o strbuf.o $(FPCONV_OBJS)
-
-.PHONY: all clean install install-extra doc
-
-.SUFFIXES: .html .txt
-
-.c.o:
-	$(CC) -c $(CFLAGS) $(CPPFLAGS) $(BUILD_CFLAGS) -o $@ $<
-
-.txt.html:
-	$(ASCIIDOC) -n -a toc $<
-
-all: $(TARGET)
-
-doc: manual.html performance.html
-
-$(TARGET): $(OBJS)
-	$(CC) $(LDFLAGS) $(CJSON_LDFLAGS) -o $@ $(OBJS)
-
-install: $(TARGET)
-	mkdir -p $(DESTDIR)/$(LUA_CMODULE_DIR)
-	cp $(TARGET) $(DESTDIR)/$(LUA_CMODULE_DIR)
-	chmod $(EXECPERM) $(DESTDIR)/$(LUA_CMODULE_DIR)/$(TARGET)
-
-install-extra:
-	mkdir -p $(DESTDIR)/$(LUA_MODULE_DIR)/cjson/tests \
-		$(DESTDIR)/$(LUA_BIN_DIR)
-	cp lua/cjson/util.lua $(DESTDIR)/$(LUA_MODULE_DIR)/cjson
-	chmod $(DATAPERM) $(DESTDIR)/$(LUA_MODULE_DIR)/cjson/util.lua
-	cp lua/lua2json.lua $(DESTDIR)/$(LUA_BIN_DIR)/lua2json$(LUA_BIN_SUFFIX)
-	chmod $(EXECPERM) $(DESTDIR)/$(LUA_BIN_DIR)/lua2json$(LUA_BIN_SUFFIX)
-	cp lua/json2lua.lua $(DESTDIR)/$(LUA_BIN_DIR)/json2lua$(LUA_BIN_SUFFIX)
-	chmod $(EXECPERM) $(DESTDIR)/$(LUA_BIN_DIR)/json2lua$(LUA_BIN_SUFFIX)
-	cd tests; cp $(TEST_FILES) $(DESTDIR)/$(LUA_MODULE_DIR)/cjson/tests
-	cd tests; chmod $(DATAPERM) $(TEST_FILES); chmod $(EXECPERM) *.lua *.pl
-
-clean:
-	rm -f *.o $(TARGET)

3rd/lua-cjson/NEWS

@@ -1,44 +0,0 @@
-Version 2.1.0 (Mar 1 2012)
-* Added cjson.safe module interface which returns nil after an error
-* Improved Makefile compatibility with Solaris make
-
-Version 2.0.0 (Jan 22 2012)
-* Improved platform compatibility for strtod/sprintf locale workaround
-* Added option to build with David Gay's dtoa.c for improved performance
-* Added support for Lua 5.2
-* Added option to encode infinity/NaN as JSON null
-* Fixed encode bug with a raised default limit and deeply nested tables
-* Updated Makefile for compatibility with non-GNU make implementations
-* Added CMake build support
-* Added HTML manual
-* Increased default nesting limit to 1000
-* Added support for re-entrant use of encode and decode
-* Added support for installing lua2json and json2lua utilities
-* Added encode_invalid_numbers() and decode_invalid_numbers()
-* Added decode_max_depth()
-* Removed registration of global cjson module table
-* Removed refuse_invalid_numbers()
-
-Version 1.0.4 (Nov 30 2011)
-* Fixed numeric conversion under locales with a comma decimal separator
-
-Version 1.0.3 (Sep 15 2011)
-* Fixed detection of objects with numeric string keys
-* Provided work around for missing isinf() on Solaris
-
-Version 1.0.2 (May 30 2011)
-* Portability improvements for Windows
-  - No longer links with -lm
-  - Use "socket" instead of "posix" for sub-second timing
-* Removed UTF-8 test dependency on Perl Text::Iconv
-* Added simple CLI commands for testing Lua <-> JSON conversions
-* Added cjson.encode_number_precision()
-
-Version 1.0.1 (May 10 2011)
-* Added build support for OSX
-* Removed unnecessary whitespace from JSON output
-* Added cjson.encode_keep_buffer()
-* Fixed memory leak on Lua stack overflow exception
-
-Version 1.0 (May 9 2011)
-* Initial release

3rd/lua-cjson/THANKS

@@ -1,9 +0,0 @@
-The following people have helped with bug reports, testing and/or
-suggestions:
-
-- Louis-Philippe Perron (@loopole)
-- Ondřej Jirman
-- Steve Donovan <steve.j.donovan@gmail.com>
-- Zhang "agentzh" Yichun <agentzh@gmail.com>
-
-Thanks!

3rd/lua-cjson/dtoa_config.h

@@ -1,74 +0,0 @@
-#ifndef _DTOA_CONFIG_H
-#define _DTOA_CONFIG_H
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-
-/* Ensure dtoa.c does not USE_LOCALE. Lua CJSON must not use locale
- * aware conversion routines. */
-#undef USE_LOCALE
-
-/* dtoa.c should not touch errno, Lua CJSON does not use it, and it
- * may not be threadsafe */
-#define NO_ERRNO
-
-#define Long    int32_t
-#define ULong   uint32_t
-#define Llong   int64_t
-#define ULLong  uint64_t
-
-#ifdef IEEE_BIG_ENDIAN
-#define IEEE_MC68k
-#else
-#define IEEE_8087
-#endif
-
-#define MALLOC(n)   xmalloc(n)
-
-static void *xmalloc(size_t size)
-{
-    void *p;
-
-    p = malloc(size);
-    if (!p) {
-        fprintf(stderr, "Out of memory");
-        abort();
-    }
-
-    return p;
-}
-
-#ifdef MULTIPLE_THREADS
-
-/* Enable locking to support multi-threaded applications */
-
-#include <pthread.h>
-
-static pthread_mutex_t private_dtoa_lock[2] = {
-    PTHREAD_MUTEX_INITIALIZER,
-    PTHREAD_MUTEX_INITIALIZER
-};
-
-#define ACQUIRE_DTOA_LOCK(n)    do {                                \
-    int r = pthread_mutex_lock(&private_dtoa_lock[n]);              \
-    if (r) {                                                        \
-        fprintf(stderr, "pthread_mutex_lock failed with %d\n", r);  \
-        abort();                                                    \
-    }                                                               \
-} while (0)
-
-#define FREE_DTOA_LOCK(n)   do {                                    \
-    int r = pthread_mutex_unlock(&private_dtoa_lock[n]);            \
-    if (r) {                                                        \
-        fprintf(stderr, "pthread_mutex_unlock failed with %d\n", r);\
-        abort();                                                    \
-    }                                                               \
-} while (0)
-
-#endif  /* MULTIPLE_THREADS */
-
-#endif  /* _DTOA_CONFIG_H */
-
-/* vi:ai et sw=4 ts=4:
- */

3rd/lua-cjson/fpconv.c

@@ -1,205 +0,0 @@
-/* fpconv - Floating point conversion routines
- *
- * Copyright (c) 2011-2012  Mark Pulford <mark@kyne.com.au>
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/* JSON uses a '.' decimal separator. strtod() / sprintf() under C libraries
- * with locale support will break when the decimal separator is a comma.
- *
- * fpconv_* will around these issues with a translation buffer if required.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <string.h>
-
-#include "fpconv.h"
-
-/* Lua CJSON assumes the locale is the same for all threads within a
- * process and doesn't change after initialisation.
- *
- * This avoids the need for per thread storage or expensive checks
- * for call. */
-static char locale_decimal_point = '.';
-
-/* In theory multibyte decimal_points are possible, but
- * Lua CJSON only supports UTF-8 and known locales only have
- * single byte decimal points ([.,]).
- *
- * localconv() may not be thread safe (=>crash), and nl_langinfo() is
- * not supported on some platforms. Use sprintf() instead - if the
- * locale does change, at least Lua CJSON won't crash. */
-static void fpconv_update_locale()
-{
-    char buf[8];
-
-    snprintf(buf, sizeof(buf), "%g", 0.5);
-
-    /* Failing this test might imply the platform has a buggy dtoa
-     * implementation or wide characters */
-    if (buf[0] != '0' || buf[2] != '5' || buf[3] != 0) {
-        fprintf(stderr, "Error: wide characters found or printf() bug.");
-        abort();
-    }
-
-    locale_decimal_point = buf[1];
-}
-
-/* Check for a valid number character: [-+0-9a-yA-Y.]
- * Eg: -0.6e+5, infinity, 0xF0.F0pF0
- *
- * Used to find the probable end of a number. It doesn't matter if
- * invalid characters are counted - strtod() will find the valid
- * number if it exists.  The risk is that slightly more memory might
- * be allocated before a parse error occurs. */
-static inline int valid_number_character(char ch)
-{
-    char lower_ch;
-
-    if ('0' <= ch && ch <= '9')
-        return 1;
-    if (ch == '-' || ch == '+' || ch == '.')
-        return 1;
-
-    /* Hex digits, exponent (e), base (p), "infinity",.. */
-    lower_ch = ch | 0x20;
-    if ('a' <= lower_ch && lower_ch <= 'y')
-        return 1;
-
-    return 0;
-}
-
-/* Calculate the size of the buffer required for a strtod locale
- * conversion. */
-static int strtod_buffer_size(const char *s)
-{
-    const char *p = s;
-
-    while (valid_number_character(*p))
-        p++;
-
-    return p - s;
-}
-
-/* Similar to strtod(), but must be passed the current locale's decimal point
- * character. Guaranteed to be called at the start of any valid number in a string */
-double fpconv_strtod(const char *nptr, char **endptr)
-{
-    char localbuf[FPCONV_G_FMT_BUFSIZE];
-    char *buf, *endbuf, *dp;
-    int buflen;
-    double value;
-
-    /* System strtod() is fine when decimal point is '.' */
-    if (locale_decimal_point == '.')
-        return strtod(nptr, endptr);
-
-    buflen = strtod_buffer_size(nptr);
-    if (!buflen) {
-        /* No valid characters found, standard strtod() return */
-        *endptr = (char *)nptr;
-        return 0;
-    }
-
-    /* Duplicate number into buffer */
-    if (buflen >= FPCONV_G_FMT_BUFSIZE) {
-        /* Handle unusually large numbers */
-        buf = malloc(buflen + 1);
-        if (!buf) {
-            fprintf(stderr, "Out of memory");
-            abort();
-        }
-    } else {
-        /* This is the common case.. */
-        buf = localbuf;
-    }
-    memcpy(buf, nptr, buflen);
-    buf[buflen] = 0;
-
-    /* Update decimal point character if found */
-    dp = strchr(buf, '.');
-    if (dp)
-        *dp = locale_decimal_point;
-
-    value = strtod(buf, &endbuf);
-    *endptr = (char *)&nptr[endbuf - buf];
-    if (buflen >= FPCONV_G_FMT_BUFSIZE)
-        free(buf);
-
-    return value;
-}
-
-/* "fmt" must point to a buffer of at least 6 characters */
-static void set_number_format(char *fmt, int precision)
-{
-    int d1, d2, i;
-
-    assert(1 <= precision && precision <= 14);
-
-    /* Create printf format (%.14g) from precision */
-    d1 = precision / 10;
-    d2 = precision % 10;
-    fmt[0] = '%';
-    fmt[1] = '.';
-    i = 2;
-    if (d1) {
-        fmt[i++] = '0' + d1;
-    }
-    fmt[i++] = '0' + d2;
-    fmt[i++] = 'g';
-    fmt[i] = 0;
-}
-
-/* Assumes there is always at least 32 characters available in the target buffer */
-int fpconv_g_fmt(char *str, double num, int precision)
-{
-    char buf[FPCONV_G_FMT_BUFSIZE];
-    char fmt[6];
-    int len;
-    char *b;
-
-    set_number_format(fmt, precision);
-
-    /* Pass through when decimal point character is dot. */
-    if (locale_decimal_point == '.')
-        return snprintf(str, FPCONV_G_FMT_BUFSIZE, fmt, num);
-
-    /* snprintf() to a buffer then translate for other decimal point characters */
-    len = snprintf(buf, FPCONV_G_FMT_BUFSIZE, fmt, num);
-
-    /* Copy into target location. Translate decimal point if required */
-    b = buf;
-    do {
-        *str++ = (*b == locale_decimal_point ? '.' : *b);
-    } while(*b++);
-
-    return len;
-}
-
-void fpconv_init()
-{
-    fpconv_update_locale();
-}
-
-/* vi:ai et sw=4 ts=4:
- */

3rd/lua-cjson/fpconv.h

@@ -1,22 +0,0 @@
-/* Lua CJSON floating point conversion routines */
-
-/* Buffer required to store the largest string representation of a double.
- *
- * Longest double printed with %.14g is 21 characters long:
- * -1.7976931348623e+308 */
-# define FPCONV_G_FMT_BUFSIZE   32
-
-#ifdef USE_INTERNAL_FPCONV
-static inline void fpconv_init()
-{
-    /* Do nothing - not required */
-}
-#else
-extern inline void fpconv_init();
-#endif
-
-extern int fpconv_g_fmt(char*, double, int);
-extern double fpconv_strtod(const char*, char**);
-
-/* vi:ai et sw=4 ts=4:
- */

3rd/lua-cjson/g_fmt.c

@@ -1,111 +0,0 @@
-/****************************************************************
- *
- * The author of this software is David M. Gay.
- *
- * Copyright (c) 1991, 1996 by Lucent Technologies.
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose without fee is hereby granted, provided that this entire notice
- * is included in all copies of any software which is or includes a copy
- * or modification of this software and in all copies of the supporting
- * documentation for such software.
- *
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
- * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
- * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- ***************************************************************/
-
-/* g_fmt(buf,x) stores the closest decimal approximation to x in buf;
- * it suffices to declare buf
- *	char buf[32];
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
- extern char *dtoa(double, int, int, int *, int *, char **);
- extern int g_fmt(char *, double, int);
- extern void freedtoa(char*);
-#ifdef __cplusplus
-	}
-#endif
-
-int
-fpconv_g_fmt(char *b, double x, int precision)
-{
-	register int i, k;
-	register char *s;
-	int decpt, j, sign;
-	char *b0, *s0, *se;
-
-	b0 = b;
-#ifdef IGNORE_ZERO_SIGN
-	if (!x) {
-		*b++ = '0';
-		*b = 0;
-		goto done;
-		}
-#endif
-	s = s0 = dtoa(x, 2, precision, &decpt, &sign, &se);
-	if (sign)
-		*b++ = '-';
-	if (decpt == 9999) /* Infinity or Nan */ {
-		while((*b++ = *s++));
-		/* "b" is used to calculate the return length. Decrement to exclude the
-		 * Null terminator from the length */
-		b--;
-		goto done0;
-		}
-	if (decpt <= -4 || decpt > precision) {
-		*b++ = *s++;
-		if (*s) {
-			*b++ = '.';
-			while((*b = *s++))
-				b++;
-			}
-		*b++ = 'e';
-		/* sprintf(b, "%+.2d", decpt - 1); */
-		if (--decpt < 0) {
-			*b++ = '-';
-			decpt = -decpt;
-			}
-		else
-			*b++ = '+';
-		for(j = 2, k = 10; 10*k <= decpt; j++, k *= 10);
-		for(;;) {
-			i = decpt / k;
-			*b++ = i + '0';
-			if (--j <= 0)
-				break;
-			decpt -= i*k;
-			decpt *= 10;
-			}
-		*b = 0;
-		}
-	else if (decpt <= 0) {
-		*b++ = '0';
-		*b++ = '.';
-		for(; decpt < 0; decpt++)
-			*b++ = '0';
-		while((*b++ = *s++));
-		b--;
-		}
-	else {
-		while((*b = *s++)) {
-			b++;
-			if (--decpt == 0 && *s)
-				*b++ = '.';
-			}
-		for(; decpt > 0; decpt--)
-			*b++ = '0';
-		*b = 0;
-		}
- done0:
-	freedtoa(s0);
-#ifdef IGNORE_ZERO_SIGN
- done:
-#endif
-	return b - b0;
-	}

3rd/lua-cjson/lua-cjson-2.1.0-1.rockspec

@@ -1,56 +0,0 @@
-package = "lua-cjson"
-version = "2.1.0-1"
-
-source = {
-    url = "http://www.kyne.com.au/~mark/software/download/lua-cjson-2.1.0.zip",
-}
-
-description = {
-    summary = "A fast JSON encoding/parsing module",
-    detailed = [[
-        The Lua CJSON module provides JSON support for Lua. It features:
-        - Fast, standards compliant encoding/parsing routines
-        - Full support for JSON with UTF-8, including decoding surrogate pairs
-        - Optional run-time support for common exceptions to the JSON specification
-          (infinity, NaN,..)
-        - No dependencies on other libraries
-    ]],
-    homepage = "http://www.kyne.com.au/~mark/software/lua-cjson.php",
-    license = "MIT"
-}
-
-dependencies = {
-    "lua >= 5.1"
-}
-
-build = {
-    type = "builtin",
-    modules = {
-        cjson = {
-            sources = { "lua_cjson.c", "strbuf.c", "fpconv.c" },
-            defines = {
--- LuaRocks does not support platform specific configuration for Solaris.
--- Uncomment the line below on Solaris platforms if required.
---                "USE_INTERNAL_ISINF"
-            }
-        }
-    },
-    install = {
-        lua = {
-            ["cjson.util"] = "lua/cjson/util.lua"
-        },
-        bin = {
-            json2lua = "lua/json2lua.lua",
-            lua2json = "lua/lua2json.lua"
-        }
-    },
-    -- Override default build options (per platform)
-    platforms = {
-        win32 = { modules = { cjson = { defines = {
-            "DISABLE_INVALID_NUMBERS"
-        } } } }
-    },
-    copy_directories = { "tests" }
-}
-
--- vi:ai et sw=4 ts=4:

3rd/lua-cjson/lua-cjson.spec

@@ -1,80 +0,0 @@
-%define luaver 5.1
-%define lualibdir %{_libdir}/lua/%{luaver}
-%define luadatadir %{_datadir}/lua/%{luaver}
-
-Name:		lua-cjson
-Version:	2.1.0
-Release:	1%{?dist}
-Summary:	A fast JSON encoding/parsing module for Lua
-
-Group:		Development/Libraries
-License:	MIT
-URL:		http://www.kyne.com.au/~mark/software/lua-cjson/
-Source0:	http://www.kyne.com.au/~mark/software/lua-cjson/download/lua-cjson-%{version}.tar.gz
-BuildRoot:	%(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
-
-BuildRequires:	lua >= %{luaver}, lua-devel >= %{luaver}
-Requires:	lua >= %{luaver}
-
-%description
-The Lua CJSON module provides JSON support for Lua. It features:
-- Fast, standards compliant encoding/parsing routines
-- Full support for JSON with UTF-8, including decoding surrogate pairs
-- Optional run-time support for common exceptions to the JSON specification
-  (infinity, NaN,..)
-- No dependencies on other libraries
-
-
-%prep
-%setup -q
-
-
-%build
-make %{?_smp_mflags} CFLAGS="%{optflags}" LUA_INCLUDE_DIR="%{_includedir}"
-
-
-%install
-rm -rf "$RPM_BUILD_ROOT"
-make install DESTDIR="$RPM_BUILD_ROOT" LUA_CMODULE_DIR="%{lualibdir}"
-make install-extra DESTDIR="$RPM_BUILD_ROOT" LUA_MODULE_DIR="%{luadatadir}" \
-	LUA_BIN_DIR="%{_bindir}"
-
-
-%clean
-rm -rf "$RPM_BUILD_ROOT"
-
-
-%preun
-/bin/rm -f "%{luadatadir}/cjson/tests/utf8.dat"
-
-
-%files
-%defattr(-,root,root,-)
-%doc LICENSE NEWS performance.html performance.txt manual.html manual.txt rfc4627.txt THANKS
-%{lualibdir}/*
-%{luadatadir}/*
-%{_bindir}/*
-
-
-%changelog
-* Thu Mar 1 2012 Mark Pulford <mark@kyne.com.au> - 2.1.0-1
-- Update for 2.1.0
-
-* Sun Jan 22 2012 Mark Pulford <mark@kyne.com.au> - 2.0.0-1
-- Update for 2.0.0
-- Install lua2json / json2lua utilities
-
-* Wed Nov 27 2011 Mark Pulford <mark@kyne.com.au> - 1.0.4-1
-- Update for 1.0.4
-
-* Wed Sep 15 2011 Mark Pulford <mark@kyne.com.au> - 1.0.3-1
-- Update for 1.0.3
-
-* Sun May 29 2011 Mark Pulford <mark@kyne.com.au> - 1.0.2-1
-- Update for 1.0.2
-
-* Sun May 10 2011 Mark Pulford <mark@kyne.com.au> - 1.0.1-1
-- Update for 1.0.1
-
-* Sun May 1 2011 Mark Pulford <mark@kyne.com.au> - 1.0-1
-- Initial package

3rd/lua-cjson/lua/cjson/util.lua

@@ -1,271 +0,0 @@
-local json = require "cjson"
-
--- Various common routines used by the Lua CJSON package
---
--- Mark Pulford <mark@kyne.com.au>
-
--- Determine with a Lua table can be treated as an array.
--- Explicitly returns "not an array" for very sparse arrays.
--- Returns:
--- -1   Not an array
--- 0    Empty table
--- >0   Highest index in the array
-local function is_array(table)
-    local max = 0
-    local count = 0
-    for k, v in pairs(table) do
-        if type(k) == "number" then
-            if k > max then max = k end
-            count = count + 1
-        else
-            return -1
-        end
-    end
-    if max > count * 2 then
-        return -1
-    end
-
-    return max
-end
-
-local serialise_value
-
-local function serialise_table(value, indent, depth)
-    local spacing, spacing2, indent2
-    if indent then
-        spacing = "\n" .. indent
-        spacing2 = spacing .. "  "
-        indent2 = indent .. "  "
-    else
-        spacing, spacing2, indent2 = " ", " ", false
-    end
-    depth = depth + 1
-    if depth > 50 then
-        return "Cannot serialise any further: too many nested tables"
-    end
-
-    local max = is_array(value)
-
-    local comma = false
-    local fragment = { "{" .. spacing2 }
-    if max > 0 then
-        -- Serialise array
-        for i = 1, max do
-            if comma then
-                table.insert(fragment, "," .. spacing2)
-            end
-            table.insert(fragment, serialise_value(value[i], indent2, depth))
-            comma = true
-        end
-    elseif max < 0 then
-        -- Serialise table
-        for k, v in pairs(value) do
-            if comma then
-                table.insert(fragment, "," .. spacing2)
-            end
-            table.insert(fragment,
-                ("[%s] = %s"):format(serialise_value(k, indent2, depth),
-                                     serialise_value(v, indent2, depth)))
-            comma = true
-        end
-    end
-    table.insert(fragment, spacing .. "}")
-
-    return table.concat(fragment)
-end
-
-function serialise_value(value, indent, depth)
-    if indent == nil then indent = "" end
-    if depth == nil then depth = 0 end
-
-    if value == json.null then
-        return "json.null"
-    elseif type(value) == "string" then
-        return ("%q"):format(value)
-    elseif type(value) == "nil" or type(value) == "number" or
-           type(value) == "boolean" then
-        return tostring(value)
-    elseif type(value) == "table" then
-        return serialise_table(value, indent, depth)
-    else
-        return "\"<" .. type(value) .. ">\""
-    end
-end
-
-local function file_load(filename)
-    local file
-    if filename == nil then
-        file = io.stdin
-    else
-        local err
-        file, err = io.open(filename, "rb")
-        if file == nil then
-            error(("Unable to read '%s': %s"):format(filename, err))
-        end
-    end
-    local data = file:read("*a")
-
-    if filename ~= nil then
-        file:close()
-    end
-
-    if data == nil then
-        error("Failed to read " .. filename)
-    end
-
-    return data
-end
-
-local function file_save(filename, data)
-    local file
-    if filename == nil then
-        file = io.stdout
-    else
-        local err
-        file, err = io.open(filename, "wb")
-        if file == nil then
-            error(("Unable to write '%s': %s"):format(filename, err))
-        end
-    end
-    file:write(data)
-    if filename ~= nil then
-        file:close()
-    end
-end
-
-local function compare_values(val1, val2)
-    local type1 = type(val1)
-    local type2 = type(val2)
-    if type1 ~= type2 then
-        return false
-    end
-
-    -- Check for NaN
-    if type1 == "number" and val1 ~= val1 and val2 ~= val2 then
-        return true
-    end
-
-    if type1 ~= "table" then
-        return val1 == val2
-    end
-
-    -- check_keys stores all the keys that must be checked in val2
-    local check_keys = {}
-    for k, _ in pairs(val1) do
-        check_keys[k] = true
-    end
-
-    for k, v in pairs(val2) do
-        if not check_keys[k] then
-            return false
-        end
-
-        if not compare_values(val1[k], val2[k]) then
-            return false
-        end
-
-        check_keys[k] = nil
-    end
-    for k, _ in pairs(check_keys) do
-        -- Not the same if any keys from val1 were not found in val2
-        return false
-    end
-    return true
-end
-
-local test_count_pass = 0
-local test_count_total = 0
-
-local function run_test_summary()
-    return test_count_pass, test_count_total
-end
-
-local function run_test(testname, func, input, should_work, output)
-    local function status_line(name, status, value)
-        local statusmap = { [true] = ":success", [false] = ":error" }
-        if status ~= nil then
-            name = name .. statusmap[status]
-        end
-        print(("[%s] %s"):format(name, serialise_value(value, false)))
-    end
-
-    local result = { pcall(func, unpack(input)) }
-    local success = table.remove(result, 1)
-
-    local correct = false
-    if success == should_work and compare_values(result, output) then
-        correct = true
-        test_count_pass = test_count_pass + 1
-    end
-    test_count_total = test_count_total + 1
-
-    local teststatus = { [true] = "PASS", [false] = "FAIL" }
-    print(("==> Test [%d] %s: %s"):format(test_count_total, testname,
-                                          teststatus[correct]))
-
-    status_line("Input", nil, input)
-    if not correct then
-        status_line("Expected", should_work, output)
-    end
-    status_line("Received", success, result)
-    print()
-
-    return correct, result
-end
-
-local function run_test_group(tests)
-    local function run_helper(name, func, input)
-        if type(name) == "string" and #name > 0 then
-            print("==> " .. name)
-        end
-        -- Not a protected call, these functions should never generate errors.
-        func(unpack(input or {}))
-        print()
-    end
-
-    for _, v in ipairs(tests) do
-        -- Run the helper if "should_work" is missing
-        if v[4] == nil then
-            run_helper(unpack(v))
-        else
-            run_test(unpack(v))
-        end
-    end
-end
-
--- Run a Lua script in a separate environment
-local function run_script(script, env)
-    local env = env or {}
-    local func
-
-    -- Use setfenv() if it exists, otherwise assume Lua 5.2 load() exists
-    if _G.setfenv then
-        func = loadstring(script)
-        if func then
-            setfenv(func, env)
-        end
-    else
-        func = load(script, nil, nil, env)
-    end
-
-    if func == nil then
-            error("Invalid syntax.")
-    end
-    func()
-
-    return env
-end
-
--- Export functions
-return {
-    serialise_value = serialise_value,
-    file_load = file_load,
-    file_save = file_save,
-    compare_values = compare_values,
-    run_test_summary = run_test_summary,
-    run_test = run_test,
-    run_test_group = run_test_group,
-    run_script = run_script
-}
-
--- vi:ai et sw=4 ts=4:

3rd/lua-cjson/lua/json2lua.lua

@@ -1,14 +0,0 @@
-#!/usr/bin/env lua
-
--- usage: json2lua.lua [json_file]
---
--- Eg:
--- echo '[ "testing" ]' | ./json2lua.lua
--- ./json2lua.lua test.json
-
-local json = require "cjson"
-local util = require "cjson.util"
-
-local json_text = util.file_load(arg[1])
-local t = json.decode(json_text)
-print(util.serialise_value(t))

3rd/lua-cjson/lua/lua2json.lua

@@ -1,20 +0,0 @@
-#!/usr/bin/env lua
-
--- usage: lua2json.lua [lua_file]
---
--- Eg:
--- echo '{ "testing" }' | ./lua2json.lua
--- ./lua2json.lua test.lua
-
-local json = require "cjson"
-local util = require "cjson.util"
-
-local env = {
-    json = { null = json.null },
-    null = json.null
-}
-
-local t = util.run_script("data = " .. util.file_load(arg[1]), env)
-print(json.encode(t.data))
-
--- vi:ai et sw=4 ts=4:

3rd/lua-cjson/manual.txt

@@ -1,611 +0,0 @@
-= Lua CJSON 2.1.0 Manual =
-Mark Pulford <mark@kyne.com.au>
-:revdate: 1st March 2012
-
-Overview
---------
-
-The Lua CJSON module provides JSON support for Lua.
-
-*Features*::
-- Fast, standards compliant encoding/parsing routines
-- Full support for JSON with UTF-8, including decoding surrogate pairs
-- Optional run-time support for common exceptions to the JSON
-  specification (infinity, NaN,..)
-- No dependencies on other libraries
-
-*Caveats*::
-- UTF-16 and UTF-32 are not supported
-
-Lua CJSON is covered by the MIT license. Review the file +LICENSE+ for
-details.
-
-The latest version of this software is available from the
-http://www.kyne.com.au/%7Emark/software/lua-cjson.php[Lua CJSON website].
-
-Feel free to email me if you have any patches, suggestions, or comments.
-
-
-Installation
-------------
-
-Lua CJSON requires either http://www.lua.org[Lua] 5.1, Lua 5.2, or
-http://www.luajit.org[LuaJIT] to build.
-
-The build method can be selected from 4 options:
-
-Make:: Unix (including Linux, BSD, Mac OSX & Solaris), Windows
-CMake:: Unix, Windows
-RPM:: Linux
-LuaRocks:: Unix, Windows
-
-
-Make
-~~~~
-
-The included +Makefile+ has generic settings.
-
-First, review and update the included makefile to suit your platform (if
-required).
-
-Next, build and install the module:
-
-[source,sh]
-make install
-
-Or install manually into your Lua module directory:
-
-[source,sh]
-make
-cp cjson.so $LUA_MODULE_DIRECTORY
-
-
-CMake
-~~~~~
-
-http://www.cmake.org[CMake] can generate build configuration for many
-different platforms (including Unix and Windows).
-
-First, generate the makefile for your platform using CMake. If CMake is
-unable to find Lua, manually set the +LUA_DIR+ environment variable to
-the base prefix of your Lua 5.1 installation.
-
-While +cmake+ is used in the example below, +ccmake+ or +cmake-gui+ may
-be used to present an interface for changing the default build options.
-
-[source,sh]
-mkdir build
-cd build
-# Optional: export LUA_DIR=$LUA51_PREFIX
-cmake ..
-
-Next, build and install the module:
-
-[source,sh]
-make install
-# Or:
-make
-cp cjson.so $LUA_MODULE_DIRECTORY
-
-Review the
-http://www.cmake.org/cmake/help/documentation.html[CMake documentation]
-for further details.
-
-
-RPM
-~~~
-
-Linux distributions using http://rpm.org[RPM] can create a package via
-the included RPM spec file. Ensure the +rpm-build+ package (or similar)
-has been installed.
-
-Build and install the module via RPM:
-
-[source,sh]
-rpmbuild -tb lua-cjson-2.1.0.tar.gz
-rpm -Uvh $LUA_CJSON_RPM
-
-
-LuaRocks
-~~~~~~~~
-
-http://luarocks.org[LuaRocks] can be used to install and manage Lua
-modules on a wide range of platforms (including Windows).
-
-First, extract the Lua CJSON source package.
-
-Next, install the module:
-
-[source,sh]
-cd lua-cjson-2.1.0
-luarocks make
-
-[NOTE]
-LuaRocks does not support platform specific configuration for Solaris.
-On Solaris, you may need to manually uncomment +USE_INTERNAL_ISINF+ in
-the rockspec before building this module.
-
-Review the http://luarocks.org/en/Documentation[LuaRocks documentation]
-for further details.
-
-
-[[build_options]]
-Build Options (#define)
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Lua CJSON offers several +#define+ build options to address portability
-issues, and enable non-default features. Some build methods may
-automatically set platform specific options if required. Other features
-should be enabled manually.
-
-USE_INTERNAL_ISINF:: Workaround for Solaris platforms missing +isinf+.
-DISABLE_INVALID_NUMBERS:: Recommended on platforms where +strtod+ /
-  +sprintf+ are not POSIX compliant (eg, Windows MinGW). Prevents
-  +cjson.encode_invalid_numbers+ and +cjson.decode_invalid_numbers+ from
-  being enabled. However, +cjson.encode_invalid_numbers+ may still be
-  set to +"null"+. When using the Lua CJSON built-in floating point
-  conversion this option is unnecessary and is ignored.
-
-
-Built-in floating point conversion
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Lua CJSON may be built with David Gay's
-http://www.netlib.org/fp/[floating point conversion routines]. This can
-increase overall performance by up to 50% on some platforms when
-converting a large amount of numeric data. However, this option reduces
-portability and is disabled by default.
-
-USE_INTERNAL_FPCONV:: Enable internal number conversion routines.
-IEEE_BIG_ENDIAN:: Must be set on big endian architectures.
-MULTIPLE_THREADS:: Must be set if Lua CJSON may be used in a
-  multi-threaded application. Requires the _pthreads_ library.
-
-
-API (Functions)
----------------
-
-Synopsis
-~~~~~~~~
-
-[source,lua]
-------------
--- Module instantiation
-local cjson = require "cjson"
-local cjson2 = cjson.new()
-local cjson_safe = require "cjson.safe"
-
--- Translate Lua value to/from JSON
-text = cjson.encode(value)
-value = cjson.decode(text)
-
--- Get and/or set Lua CJSON configuration
-setting = cjson.decode_invalid_numbers([setting])
-setting = cjson.encode_invalid_numbers([setting])
-keep = cjson.encode_keep_buffer([keep])
-depth = cjson.encode_max_depth([depth])
-depth = cjson.decode_max_depth([depth])
-convert, ratio, safe = cjson.encode_sparse_array([convert[, ratio[, safe]]])
-------------
-
-
-Module Instantiation
-~~~~~~~~~~~~~~~~~~~~
-
-[source,lua]
-------------
-local cjson = require "cjson"
-local cjson2 = cjson.new()
-local cjson_safe = require "cjson.safe"
-------------
-
-Import Lua CJSON via the Lua +require+ function. Lua CJSON does not
-register a global module table.
-
-The +cjson+ module will throw an error during JSON conversion if any
-invalid data is encountered. Refer to <<cjson_encode,+cjson.encode+>>
-and <<cjson_decode,+cjson.decode+>> for details.
-
-The +cjson.safe+ module behaves identically to the +cjson+ module,
-except when errors are encountered during JSON conversion. On error, the
-+cjson_safe.encode+ and +cjson_safe.decode+ functions will return
-+nil+ followed by the error message.
-
-+cjson.new+ can be used to instantiate an independent copy of the Lua
-CJSON module. The new module has a separate persistent encoding buffer,
-and default settings.
-
-Lua CJSON can support Lua implementations using multiple preemptive
-threads within a single Lua state provided the persistent encoding
-buffer is not shared. This can be achieved by one of the following
-methods:
-
-- Disabling the persistent encoding buffer with
-  <<encode_keep_buffer,+cjson.encode_keep_buffer+>>
-- Ensuring each thread calls <<encode,+cjson.encode+>> separately (ie,
-  treat +cjson.encode+ as non-reentrant).
-- Using a separate +cjson+ module table per preemptive thread
-  (+cjson.new+)
-
-[NOTE]
-Lua CJSON uses +strtod+ and +snprintf+ to perform numeric conversion as
-they are usually well supported, fast and bug free. However, these
-functions require a workaround for JSON encoding/parsing under locales
-using a comma decimal separator. Lua CJSON detects the current locale
-during instantiation to determine and automatically implement the
-workaround if required. Lua CJSON should be reinitialised via
-+cjson.new+ if the locale of the current process changes. Using a
-different locale per thread is not supported.
-
-
-decode
-~~~~~~
-
-[source,lua]
-------------
-value = cjson.decode(json_text)
-------------
-
-+cjson.decode+ will deserialise any UTF-8 JSON string into a Lua value
-or table.
-
-UTF-16 and UTF-32 JSON strings are not supported.
-
-+cjson.decode+ requires that any NULL (ASCII 0) and double quote (ASCII
-34) characters are escaped within strings. All escape codes will be
-decoded and other bytes will be passed transparently. UTF-8 characters
-are not validated during decoding and should be checked elsewhere if
-required.
-
-JSON +null+ will be converted to a NULL +lightuserdata+ value. This can
-be compared with +cjson.null+ for convenience.
-
-By default, numbers incompatible with the JSON specification (infinity,
-NaN, hexadecimal) can be decoded. This default can be changed with
-<<decode_invalid_numbers,+cjson.decode_invalid_numbers+>>.
-
-.Example: Decoding
-[source,lua]
-json_text = '[ true, { "foo": "bar" } ]'
-value = cjson.decode(json_text)
--- Returns: { true, { foo = "bar" } }
-
-[CAUTION]
-Care must be taken after decoding JSON objects with numeric keys. Each
-numeric key will be stored as a Lua +string+. Any subsequent code
-assuming type +number+ may break.
-
-
-[[decode_invalid_numbers]]
-decode_invalid_numbers
-~~~~~~~~~~~~~~~~~~~~~~
-
-[source,lua]
-------------
-setting = cjson.decode_invalid_numbers([setting])
--- "setting" must be a boolean. Default: true.
-------------
-
-Lua CJSON may generate an error when trying to decode numbers not
-supported by the JSON specification. _Invalid numbers_ are defined as:
-
-- infinity
-- not-a-number (NaN)
-- hexadecimal
-
-Available settings:
-
-+true+:: Accept and decode _invalid numbers_. This is the default
-  setting.
-+false+:: Throw an error when _invalid numbers_ are encountered.
-
-The current setting is always returned, and is only updated when an
-argument is provided.
-
-
-[[decode_max_depth]]
-decode_max_depth
-~~~~~~~~~~~~~~~~
-
-[source,lua]
-------------
-depth = cjson.decode_max_depth([depth])
--- "depth" must be a positive integer. Default: 1000.
-------------
-
-Lua CJSON will generate an error when parsing deeply nested JSON once
-the maximum array/object depth has been exceeded. This check prevents
-unnecessarily complicated JSON from slowing down the application, or
-crashing the application due to lack of process stack space.
-
-An error may be generated before the depth limit is hit if Lua is unable
-to allocate more objects on the Lua stack.
-
-By default, Lua CJSON will reject JSON with arrays and/or objects nested
-more than 1000 levels deep.
-
-The current setting is always returned, and is only updated when an
-argument is provided.
-
-
-[[encode]]
-encode
-~~~~~~
-
-[source,lua]
-------------
-json_text = cjson.encode(value)
-------------
-
-+cjson.encode+ will serialise a Lua value into a string containing the
-JSON representation.
-
-+cjson.encode+ supports the following types:
-
-- +boolean+
-- +lightuserdata+ (NULL value only)
-- +nil+
-- +number+
-- +string+
-- +table+
-
-The remaining Lua types will generate an error:
-
-- +function+
-- +lightuserdata+ (non-NULL values)
-- +thread+
-- +userdata+
-
-By default, numbers are encoded with 14 significant digits. Refer to
-<<encode_number_precision,+cjson.encode_number_precision+>> for details.
-
-Lua CJSON will escape the following characters within each UTF-8 string:
-
-- Control characters (ASCII 0 - 31)
-- Double quote (ASCII 34)
-- Forward slash (ASCII 47)
-- Blackslash (ASCII 92)
-- Delete (ASCII 127)
-
-All other bytes are passed transparently.
-
-[CAUTION]
-=========
-Lua CJSON will successfully encode/decode binary strings, but this is
-technically not supported by JSON and may not be compatible with other
-JSON libraries. To ensure the output is valid JSON, applications should
-ensure all Lua strings passed to +cjson.encode+ are UTF-8.
-
-Base64 is commonly used to encode binary data as the most efficient
-encoding under UTF-8 can only reduce the encoded size by a further
-&#126;8%. Lua Base64 routines can be found in the
-http://w3.impa.br/%7Ediego/software/luasocket/[LuaSocket] and
-http://www.tecgraf.puc-rio.br/%7Elhf/ftp/lua/#lbase64[lbase64] packages.
-=========
-
-Lua CJSON uses a heuristic to determine whether to encode a Lua table as
-a JSON array or an object. A Lua table with only positive integer keys
-of type +number+ will be encoded as a JSON array. All other tables will
-be encoded as a JSON object.
-
-Lua CJSON does not use metamethods when serialising tables.
-
-- +rawget+ is used to iterate over Lua arrays
-- +next+ is used to iterate over Lua objects
-
-Lua arrays with missing entries (_sparse arrays_) may optionally be
-encoded in several different ways. Refer to
-<<encode_sparse_array,+cjson.encode_sparse_array+>> for details.
-
-JSON object keys are always strings. Hence +cjson.encode+ only supports
-table keys which are type +number+ or +string+. All other types will
-generate an error.
-
-[NOTE]
-Standards compliant JSON must be encapsulated in either an object (+{}+)
-or an array (+[]+). If strictly standards compliant JSON is desired, a
-table must be passed to +cjson.encode+.
-
-By default, encoding the following Lua values will generate errors:
-
-- Numbers incompatible with the JSON specification (infinity, NaN)
-- Tables nested more than 1000 levels deep
-- Excessively sparse Lua arrays
-
-These defaults can be changed with:
-
-- <<encode_invalid_numbers,+cjson.encode_invalid_numbers+>>
-- <<encode_max_depth,+cjson.encode_max_depth+>>
-- <<encode_sparse_array,+cjson.encode_sparse_array+>>
-
-.Example: Encoding
-[source,lua]
-value = { true, { foo = "bar" } }
-json_text = cjson.encode(value)
--- Returns: '[true,{"foo":"bar"}]'
-
-
-[[encode_invalid_numbers]]
-encode_invalid_numbers
-~~~~~~~~~~~~~~~~~~~~~~
-[source,lua]
-------------
-setting = cjson.encode_invalid_numbers([setting])
--- "setting" must a boolean or "null". Default: false.
-------------
-
-Lua CJSON may generate an error when encoding floating point numbers not
-supported by the JSON specification (_invalid numbers_):
-
-- infinity
-- not-a-number (NaN)
-
-Available settings:
-
-+true+:: Allow _invalid numbers_ to be encoded. This will generate
-  non-standard JSON, but this output is supported by some libraries.
-+"null"+:: Encode _invalid numbers_ as a JSON +null+ value. This allows
-  infinity and NaN to be encoded into valid JSON.
-+false+:: Throw an error when attempting to encode _invalid numbers_.
-  This is the default setting.
-
-The current setting is always returned, and is only updated when an
-argument is provided.
-
-
-[[encode_keep_buffer]]
-encode_keep_buffer
-~~~~~~~~~~~~~~~~~~
-
-[source,lua]
-------------
-keep = cjson.encode_keep_buffer([keep])
--- "keep" must be a boolean. Default: true.
-------------
-
-Lua CJSON can reuse the JSON encoding buffer to improve performance.
-
-Available settings:
-
-+true+:: The buffer will grow to the largest size required and is not
-  freed until the Lua CJSON module is garbage collected. This is the
-  default setting.
-+false+:: Free the encode buffer after each call to +cjson.encode+.
-
-The current setting is always returned, and is only updated when an
-argument is provided.
-
-
-[[encode_max_depth]]
-encode_max_depth
-~~~~~~~~~~~~~~~~
-
-[source,lua]
-------------
-depth = cjson.encode_max_depth([depth])
--- "depth" must be a positive integer. Default: 1000.
-------------
-
-Once the maximum table depth has been exceeded Lua CJSON will generate
-an error. This prevents a deeply nested or recursive data structure from
-crashing the application.
-
-By default, Lua CJSON will generate an error when trying to encode data
-structures with more than 1000 nested tables.
-
-The current setting is always returned, and is only updated when an
-argument is provided.
-
-.Example: Recursive Lua table
-[source,lua]
-a = {}; a[1] = a
-
-
-[[encode_number_precision]]
-encode_number_precision
-~~~~~~~~~~~~~~~~~~~~~~~
-
-[source,lua]
-------------
-precision = cjson.encode_number_precision([precision])
--- "precision" must be an integer between 1 and 14. Default: 14.
-------------
-
-The amount of significant digits returned by Lua CJSON when encoding
-numbers can be changed to balance accuracy versus performance. For data
-structures containing many numbers, setting
-+cjson.encode_number_precision+ to a smaller integer, for example +3+,
-can improve encoding performance by up to 50%.
-
-By default, Lua CJSON will output 14 significant digits when converting
-a number to text.
-
-The current setting is always returned, and is only updated when an
-argument is provided.
-
-
-[[encode_sparse_array]]
-encode_sparse_array
-~~~~~~~~~~~~~~~~~~~
-
-[source,lua]
-------------
-convert, ratio, safe = cjson.encode_sparse_array([convert[, ratio[, safe]]])
--- "convert" must be a boolean. Default: false.
--- "ratio" must be a positive integer. Default: 2.
--- "safe" must be a positive integer. Default: 10.
-------------
-
-Lua CJSON classifies a Lua table into one of three kinds when encoding a
-JSON array. This is determined by the number of values missing from the
-Lua array as follows:
-
-Normal:: All values are available.
-Sparse:: At least 1 value is missing.
-Excessively sparse:: The number of values missing exceeds the configured
-  ratio.
-
-Lua CJSON encodes sparse Lua arrays as JSON arrays using JSON +null+ for
-the missing entries.
-
-An array is excessively sparse when all the following conditions are
-met:
-
-- +ratio+ > +0+
-- _maximum_index_ > +safe+
-- _maximum_index_ > _item_count_ * +ratio+
-
-Lua CJSON will never consider an array to be _excessively sparse_ when
-+ratio+ = +0+. The +safe+ limit ensures that small Lua arrays are always
-encoded as sparse arrays.
-
-By default, attempting to encode an _excessively sparse_ array will
-generate an error. If +convert+ is set to +true+, _excessively sparse_
-arrays will be converted to a JSON object.
-
-The current settings are always returned. A particular setting is only
-changed when the argument is provided (non-++nil++).
-
-.Example: Encoding a sparse array
-[source,lua]
-cjson.encode({ [3] = "data" })
--- Returns: '[null,null,"data"]'
-
-.Example: Enabling conversion to a JSON object
-[source,lua]
-cjson.encode_sparse_array(true)
-cjson.encode({ [1000] = "excessively sparse" })
--- Returns: '{"1000":"excessively sparse"}'
-
-
-API (Variables)
----------------
-
-_NAME
-~~~~~
-
-The name of the Lua CJSON module (+"cjson"+).
-
-
-_VERSION
-~~~~~~~~
-
-The version number of the Lua CJSON module (+"2.1.0"+).
-
-
-null
-~~~~
-
-Lua CJSON decodes JSON +null+ as a Lua +lightuserdata+ NULL pointer.
-+cjson.null+ is provided for comparison.
-
-
-[sect1]
-References
-----------
-
-- http://tools.ietf.org/html/rfc4627[RFC 4627]
-- http://www.json.org/[JSON website]
-
-
-// vi:ft=asciidoc tw=72:

3rd/lua-cjson/performance.html

@@ -1,617 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
-    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-<meta name="generator" content="AsciiDoc 8.4.5" />
-<title>JSON module performance comparison under Lua</title>
-<style type="text/css">
-/* Debug borders */
-p, li, dt, dd, div, pre, h1, h2, h3, h4, h5, h6 {
-/*
-  border: 1px solid red;
-*/
-}
-
-body {
-  margin: 1em 5% 1em 5%;
-}
-
-a {
-  color: blue;
-  text-decoration: underline;
-}
-a:visited {
-  color: fuchsia;
-}
-
-em {
-  font-style: italic;
-  color: navy;
-}
-
-strong {
-  font-weight: bold;
-  color: #083194;
-}
-
-tt {
-  color: navy;
-}
-
-h1, h2, h3, h4, h5, h6 {
-  color: #527bbd;
-  font-family: sans-serif;
-  margin-top: 1.2em;
-  margin-bottom: 0.5em;
-  line-height: 1.3;
-}
-
-h1, h2, h3 {
-  border-bottom: 2px solid silver;
-}
-h2 {
-  padding-top: 0.5em;
-}
-h3 {
-  float: left;
-}
-h3 + * {
-  clear: left;
-}
-
-div.sectionbody {
-  font-family: serif;
-  margin-left: 0;
-}
-
-hr {
-  border: 1px solid silver;
-}
-
-p {
-  margin-top: 0.5em;
-  margin-bottom: 0.5em;
-}
-
-ul, ol, li > p {
-  margin-top: 0;
-}
-
-pre {
-  padding: 0;
-  margin: 0;
-}
-
-span#author {
-  color: #527bbd;
-  font-family: sans-serif;
-  font-weight: bold;
-  font-size: 1.1em;
-}
-span#email {
-}
-span#revnumber, span#revdate, span#revremark {
-  font-family: sans-serif;
-}
-
-div#footer {
-  font-family: sans-serif;
-  font-size: small;
-  border-top: 2px solid silver;
-  padding-top: 0.5em;
-  margin-top: 4.0em;
-}
-div#footer-text {
-  float: left;
-  padding-bottom: 0.5em;
-}
-div#footer-badges {
-  float: right;
-  padding-bottom: 0.5em;
-}
-
-div#preamble {
-  margin-top: 1.5em;
-  margin-bottom: 1.5em;
-}
-div.tableblock, div.imageblock, div.exampleblock, div.verseblock,
-div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
-div.admonitionblock {
-  margin-top: 1.5em;
-  margin-bottom: 1.5em;
-}
-div.admonitionblock {
-  margin-top: 2.5em;
-  margin-bottom: 2.5em;
-}
-
-div.content { /* Block element content. */
-  padding: 0;
-}
-
-/* Block element titles. */
-div.title, caption.title {
-  color: #527bbd;
-  font-family: sans-serif;
-  font-weight: bold;
-  text-align: left;
-  margin-top: 1.0em;
-  margin-bottom: 0.5em;
-}
-div.title + * {
-  margin-top: 0;
-}
-
-td div.title:first-child {
-  margin-top: 0.0em;
-}
-div.content div.title:first-child {
-  margin-top: 0.0em;
-}
-div.content + div.title {
-  margin-top: 0.0em;
-}
-
-div.sidebarblock > div.content {
-  background: #ffffee;
-  border: 1px solid silver;
-  padding: 0.5em;
-}
-
-div.listingblock > div.content {
-  border: 1px solid silver;
-  background: #f4f4f4;
-  padding: 0.5em;
-}
-
-div.quoteblock {
-  padding-left: 2.0em;
-  margin-right: 10%;
-}
-div.quoteblock > div.attribution {
-  padding-top: 0.5em;
-  text-align: right;
-}
-
-div.verseblock {
-  padding-left: 2.0em;
-  margin-right: 10%;
-}
-div.verseblock > div.content {
-  white-space: pre;
-}
-div.verseblock > div.attribution {
-  padding-top: 0.75em;
-  text-align: left;
-}
-/* DEPRECATED: Pre version 8.2.7 verse style literal block. */
-div.verseblock + div.attribution {
-  text-align: left;
-}
-
-div.admonitionblock .icon {
-  vertical-align: top;
-  font-size: 1.1em;
-  font-weight: bold;
-  text-decoration: underline;
-  color: #527bbd;
-  padding-right: 0.5em;
-}
-div.admonitionblock td.content {
-  padding-left: 0.5em;
-  border-left: 2px solid silver;
-}
-
-div.exampleblock > div.content {
-  border-left: 2px solid silver;
-  padding: 0.5em;
-}
-
-div.imageblock div.content { padding-left: 0; }
-span.image img { border-style: none; }
-a.image:visited { color: white; }
-
-dl {
-  margin-top: 0.8em;
-  margin-bottom: 0.8em;
-}
-dt {
-  margin-top: 0.5em;
-  margin-bottom: 0;
-  font-style: normal;
-  color: navy;
-}
-dd > *:first-child {
-  margin-top: 0.1em;
-}
-
-ul, ol {
-    list-style-position: outside;
-}
-ol.arabic {
-  list-style-type: decimal;
-}
-ol.loweralpha {
-  list-style-type: lower-alpha;
-}
-ol.upperalpha {
-  list-style-type: upper-alpha;
-}
-ol.lowerroman {
-  list-style-type: lower-roman;
-}
-ol.upperroman {
-  list-style-type: upper-roman;
-}
-
-div.compact ul, div.compact ol,
-div.compact p, div.compact p,
-div.compact div, div.compact div {
-  margin-top: 0.1em;
-  margin-bottom: 0.1em;
-}
-
-div.tableblock > table {
-  border: 3px solid #527bbd;
-}
-thead {
-  font-family: sans-serif;
-  font-weight: bold;
-}
-tfoot {
-  font-weight: bold;
-}
-td > div.verse {
-  white-space: pre;
-}
-p.table {
-  margin-top: 0;
-}
-/* Because the table frame attribute is overriden by CSS in most browsers. */
-div.tableblock > table[frame="void"] {
-  border-style: none;
-}
-div.tableblock > table[frame="hsides"] {
-  border-left-style: none;
-  border-right-style: none;
-}
-div.tableblock > table[frame="vsides"] {
-  border-top-style: none;
-  border-bottom-style: none;
-}
-
-
-div.hdlist {
-  margin-top: 0.8em;
-  margin-bottom: 0.8em;
-}
-div.hdlist tr {
-  padding-bottom: 15px;
-}
-dt.hdlist1.strong, td.hdlist1.strong {
-  font-weight: bold;
-}
-td.hdlist1 {
-  vertical-align: top;
-  font-style: normal;
-  padding-right: 0.8em;
-  color: navy;
-}
-td.hdlist2 {
-  vertical-align: top;
-}
-div.hdlist.compact tr {
-  margin: 0;
-  padding-bottom: 0;
-}
-
-.comment {
-  background: yellow;
-}
-
-@media print {
-  div#footer-badges { display: none; }
-}
-
-div#toctitle {
-  color: #527bbd;
-  font-family: sans-serif;
-  font-size: 1.1em;
-  font-weight: bold;
-  margin-top: 1.0em;
-  margin-bottom: 0.1em;
-}
-
-div.toclevel1, div.toclevel2, div.toclevel3, div.toclevel4 {
-  margin-top: 0;
-  margin-bottom: 0;
-}
-div.toclevel2 {
-  margin-left: 2em;
-  font-size: 0.9em;
-}
-div.toclevel3 {
-  margin-left: 4em;
-  font-size: 0.9em;
-}
-div.toclevel4 {
-  margin-left: 6em;
-  font-size: 0.9em;
-}
-/* Workarounds for IE6's broken and incomplete CSS2. */
-
-div.sidebar-content {
-  background: #ffffee;
-  border: 1px solid silver;
-  padding: 0.5em;
-}
-div.sidebar-title, div.image-title {
-  color: #527bbd;
-  font-family: sans-serif;
-  font-weight: bold;
-  margin-top: 0.0em;
-  margin-bottom: 0.5em;
-}
-
-div.listingblock div.content {
-  border: 1px solid silver;
-  background: #f4f4f4;
-  padding: 0.5em;
-}
-
-div.quoteblock-attribution {
-  padding-top: 0.5em;
-  text-align: right;
-}
-
-div.verseblock-content {
-  white-space: pre;
-}
-div.verseblock-attribution {
-  padding-top: 0.75em;
-  text-align: left;
-}
-
-div.exampleblock-content {
-  border-left: 2px solid silver;
-  padding-left: 0.5em;
-}
-
-/* IE6 sets dynamically generated links as visited. */
-div#toc a:visited { color: blue; }
-</style>
-<script type="text/javascript">
-/*<![CDATA[*/
-window.onload = function(){generateToc(2)}
-/* Author: Mihai Bazon, September 2002
- * http://students.infoiasi.ro/~mishoo
- *
- * Table Of Content generator
- * Version: 0.4
- *
- * Feel free to use this script under the terms of the GNU General Public
- * License, as long as you do not remove or alter this notice.
- */
-
- /* modified by Troy D. Hanson, September 2006. License: GPL */
- /* modified by Stuart Rackham, October 2006. License: GPL */
-
-function getText(el) {
-  var text = "";
-  for (var i = el.firstChild; i != null; i = i.nextSibling) {
-    if (i.nodeType == 3 /* Node.TEXT_NODE */) // IE doesn't speak constants.
-      text += i.data;
-    else if (i.firstChild != null)
-      text += getText(i);
-  }
-  return text;
-}
-
-function TocEntry(el, text, toclevel) {
-  this.element = el;
-  this.text = text;
-  this.toclevel = toclevel;
-}
-
-function tocEntries(el, toclevels) {
-  var result = new Array;
-  var re = new RegExp('[hH]([2-'+(toclevels+1)+'])');
-  // Function that scans the DOM tree for header elements (the DOM2
-  // nodeIterator API would be a better technique but not supported by all
-  // browsers).
-  var iterate = function (el) {
-    for (var i = el.firstChild; i != null; i = i.nextSibling) {
-      if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
-        var mo = re.exec(i.tagName)
-        if (mo)
-          result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
-        iterate(i);
-      }
-    }
-  }
-  iterate(el);
-  return result;
-}
-
-// This function does the work. toclevels = 1..4.
-function generateToc(toclevels) {
-  var toc = document.getElementById("toc");
-  var entries = tocEntries(document.getElementsByTagName("body")[0], toclevels);
-  for (var i = 0; i < entries.length; ++i) {
-    var entry = entries[i];
-    if (entry.element.id == "")
-      entry.element.id = "toc" + i;
-    var a = document.createElement("a");
-    a.href = "#" + entry.element.id;
-    a.appendChild(document.createTextNode(entry.text));
-    var div = document.createElement("div");
-    div.appendChild(a);
-    div.className = "toclevel" + entry.toclevel;
-    toc.appendChild(div);
-  }
-  if (entries.length == 0)
-    document.getElementById("header").removeChild(toc);
-}
-/*]]>*/
-</script>
-</head>
-<body>
-<div id="header">
-<h1>JSON module performance comparison under Lua</h1>
-<span id="author">Mark Pulford</span><br />
-<span id="email"><tt>&lt;<a href="mailto:mark@kyne.com.au">mark@kyne.com.au</a>&gt;</tt></span><br />
-<span id="revdate">January 22, 2012</span>
-<div id="toc">
-  <div id="toctitle">Table of Contents</div>
-  <noscript><p><b>JavaScript must be enabled in your browser to display the table of contents.</b></p></noscript>
-</div>
-</div>
-<div id="preamble">
-<div class="sectionbody">
-<div class="paragraph"><p>This performance comparison aims to provide a guide of relative
-performance between several fast and popular JSON modules.</p></div>
-<div class="paragraph"><p>The examples used in this comparison were mostly sourced from the
-<a href="http://json.org">JSON website</a> and
-<a href="http://tools.ietf.org/html/rfc4627">RFC 4627</a>.</p></div>
-<div class="paragraph"><p>Performance will vary widely between platforms and data sets. These
-results should only be used as an approximation.</p></div>
-</div>
-</div>
-<h2 id="_modules">1. Modules</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>The following JSON modules for Lua were tested:</p></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<a href="http://chiselapp.com/user/dhkolf/repository/dkjson/">DKJSON 2.1</a>
-</dt>
-<dd>
-<div class="ulist"><ul>
-<li>
-<p>
-Lua implementation with no dependencies on other libraries
-</p>
-</li>
-<li>
-<p>
-Supports LPeg to improve decode performance
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<a href="https://github.com/brimworks/lua-yajl">Lua YAJL 2.0</a>
-</dt>
-<dd>
-<div class="ulist"><ul>
-<li>
-<p>
-C wrapper for the YAJL library
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<a href="http://www.kyne.com.au/%7Emark/software/lua-cjson.php">Lua CSJON 2.0.0</a>
-</dt>
-<dd>
-<div class="ulist"><ul>
-<li>
-<p>
-C implementation with no dependencies on other libraries
-</p>
-</li>
-</ul></div>
-</dd>
-</dl></div>
-</div>
-<h2 id="_summary">2. Summary</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>All modules were built and tested as follows:</p></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-DKJSON
-</dt>
-<dd>
-<p>
-Tested with/without LPeg 10.2.
-</p>
-</dd>
-<dt class="hdlist1">
-Lua YAJL
-</dt>
-<dd>
-<p>
-Tested with YAJL 2.0.4.
-</p>
-</dd>
-<dt class="hdlist1">
-Lua CJSON
-</dt>
-<dd>
-<p>
-Tested with Libc and internal floating point conversion
-  routines.
-</p>
-</dd>
-</dl></div>
-<div class="paragraph"><p>The following Lua implementations were used for this comparison:</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-<a href="http://www.lua.org">Lua 5.1.4</a> (<em>Lua</em>)
-</p>
-</li>
-<li>
-<p>
-<a href="http://www.luajit.org">LuaJIT 2.0.0-beta9</a> (<em>JIT</em>)
-</p>
-</li>
-</ul></div>
-<div class="paragraph"><p>These results show the number of JSON operations per second sustained by
-each module. All results have been normalised against the pure Lua
-DKJSON implementation.</p></div>
-<div class="literalblock">
-<div class="title">Decoding performance</div>
-<div class="content">
-<pre><tt>             | DKJSON                  | Lua YAJL   | Lua CJSON
-             | No LPeg     With LPeg   |            | Libc         Internal
-             | Lua  JIT    Lua    JIT  | Lua   JIT  | Lua   JIT    Lua   JIT
-example1     | 1x   2x     2.6x   3.4x | 7.1x  10x  | 14x   20x    14x   20x
-example2     | 1x   2.2x   2.9x   4.4x | 6.7x  9.9x | 14x   22x    14x   22x
-example3     | 1x   2.1x   3x     4.3x | 6.9x  9.3x | 14x   21x    15x   22x
-example4     | 1x   2x     2.5x   3.7x | 7.3x  10x  | 12x   19x    12x   20x
-example5     | 1x   2.2x   3x     4.5x | 7.8x  11x  | 16x   24x    16x   24x
-numbers      | 1x   2.2x   2.3x   4x   | 4.6x  5.5x | 8.9x  10x    13x   17x
-rfc-example1 | 1x   2.1x   2.8x   4.3x | 6.1x  8.1x | 13x   19x    14x   21x
-rfc-example2 | 1x   2.1x   3.1x   4.2x | 7.1x  9.2x | 15x   21x    17x   24x
-types        | 1x   2.2x   2.6x   4.3x | 5.3x  7.4x | 12x   20x    13x   21x
--------------|-------------------------|------------|-----------------------
-= Average =&gt; | 1x   2.1x   2.7x   4.1x | 6.5x  9x   | 13x   20x    14x   21x</tt></pre>
-</div></div>
-<div class="literalblock">
-<div class="title">Encoding performance</div>
-<div class="content">
-<pre><tt>             | DKJSON                  | Lua YAJL   | Lua CJSON
-             | No LPeg     With LPeg   |            | Libc         Internal
-             | Lua  JIT    Lua    JIT  | Lua   JIT  | Lua   JIT    Lua   JIT
-example1     | 1x   1.8x   0.97x  1.6x | 3.1x  5.2x | 23x   29x    23x   29x
-example2     | 1x   2x     0.97x  1.7x | 2.6x  4.3x | 22x   28x    22x   28x
-example3     | 1x   1.9x   0.98x  1.6x | 2.8x  4.3x | 13x   15x    16x   18x
-example4     | 1x   1.7x   0.96x  1.3x | 3.9x  6.1x | 15x   19x    17x   21x
-example5     | 1x   2x     0.98x  1.7x | 2.7x  4.5x | 20x   23x    20x   23x
-numbers      | 1x   2.3x   1x     2.2x | 1.3x  1.9x | 3.8x  4.1x   4.2x  4.6x
-rfc-example1 | 1x   1.9x   0.97x  1.6x | 2.2x  3.2x | 8.5x  9.3x   11x   12x
-rfc-example2 | 1x   1.9x   0.98x  1.6x | 2.6x  3.9x | 10x   11x    17x   19x
-types        | 1x   2.2x   0.97x  2x   | 1.2x  1.9x | 11x   13x    12x   14x
--------------|-------------------------|------------|-----------------------
-= Average =&gt; | 1x   1.9x   0.98x  1.7x | 2.5x  3.9x | 14x   17x    16x   19x</tt></pre>
-</div></div>
-</div>
-<div id="footer">
-<div id="footer-text">
-Last updated 2012-03-01 22:52:50 CST
-</div>
-</div>
-</body>
-</html>

3rd/lua-cjson/performance.txt

@@ -1,89 +0,0 @@
-JSON module performance comparison under Lua
-============================================
-Mark Pulford <mark@kyne.com.au>
-:revdate: January 22, 2012
-
-This performance comparison aims to provide a guide of relative
-performance between several fast and popular JSON modules.
-
-The examples used in this comparison were mostly sourced from the
-http://json.org[JSON website] and
-http://tools.ietf.org/html/rfc4627[RFC 4627].
-
-Performance will vary widely between platforms and data sets. These
-results should only be used as an approximation.
-
-
-Modules
--------
-
-The following JSON modules for Lua were tested:
-
-http://chiselapp.com/user/dhkolf/repository/dkjson/[DKJSON 2.1]::
-  - Lua implementation with no dependencies on other libraries
-  - Supports LPeg to improve decode performance
-
-https://github.com/brimworks/lua-yajl[Lua YAJL 2.0]::
-  - C wrapper for the YAJL library
-
-http://www.kyne.com.au/%7Emark/software/lua-cjson.php[Lua CSJON 2.0.0]::
-  - C implementation with no dependencies on other libraries
-
-
-Summary
--------
-
-All modules were built and tested as follows:
-
-DKJSON:: Tested with/without LPeg 10.2.
-Lua YAJL:: Tested with YAJL 2.0.4.
-Lua CJSON:: Tested with Libc and internal floating point conversion
-  routines.
-
-The following Lua implementations were used for this comparison:
-
-- http://www.lua.org[Lua 5.1.4] (_Lua_)
-- http://www.luajit.org[LuaJIT 2.0.0-beta9] (_JIT_)
-
-These results show the number of JSON operations per second sustained by
-each module. All results have been normalised against the pure Lua
-DKJSON implementation.
-
-.Decoding performance
-............................................................................
-             | DKJSON                  | Lua YAJL   | Lua CJSON
-             | No LPeg     With LPeg   |            | Libc         Internal
-             | Lua  JIT    Lua    JIT  | Lua   JIT  | Lua   JIT    Lua   JIT
-example1     | 1x   2x     2.6x   3.4x | 7.1x  10x  | 14x   20x    14x   20x
-example2     | 1x   2.2x   2.9x   4.4x | 6.7x  9.9x | 14x   22x    14x   22x
-example3     | 1x   2.1x   3x     4.3x | 6.9x  9.3x | 14x   21x    15x   22x
-example4     | 1x   2x     2.5x   3.7x | 7.3x  10x  | 12x   19x    12x   20x
-example5     | 1x   2.2x   3x     4.5x | 7.8x  11x  | 16x   24x    16x   24x
-numbers      | 1x   2.2x   2.3x   4x   | 4.6x  5.5x | 8.9x  10x    13x   17x
-rfc-example1 | 1x   2.1x   2.8x   4.3x | 6.1x  8.1x | 13x   19x    14x   21x
-rfc-example2 | 1x   2.1x   3.1x   4.2x | 7.1x  9.2x | 15x   21x    17x   24x
-types        | 1x   2.2x   2.6x   4.3x | 5.3x  7.4x | 12x   20x    13x   21x
--------------|-------------------------|------------|-----------------------
-= Average => | 1x   2.1x   2.7x   4.1x | 6.5x  9x   | 13x   20x    14x   21x
-............................................................................
-
-.Encoding performance
-.............................................................................
-             | DKJSON                  | Lua YAJL   | Lua CJSON
-             | No LPeg     With LPeg   |            | Libc         Internal
-             | Lua  JIT    Lua    JIT  | Lua   JIT  | Lua   JIT    Lua   JIT
-example1     | 1x   1.8x   0.97x  1.6x | 3.1x  5.2x | 23x   29x    23x   29x
-example2     | 1x   2x     0.97x  1.7x | 2.6x  4.3x | 22x   28x    22x   28x
-example3     | 1x   1.9x   0.98x  1.6x | 2.8x  4.3x | 13x   15x    16x   18x
-example4     | 1x   1.7x   0.96x  1.3x | 3.9x  6.1x | 15x   19x    17x   21x
-example5     | 1x   2x     0.98x  1.7x | 2.7x  4.5x | 20x   23x    20x   23x
-numbers      | 1x   2.3x   1x     2.2x | 1.3x  1.9x | 3.8x  4.1x   4.2x  4.6x
-rfc-example1 | 1x   1.9x   0.97x  1.6x | 2.2x  3.2x | 8.5x  9.3x   11x   12x
-rfc-example2 | 1x   1.9x   0.98x  1.6x | 2.6x  3.9x | 10x   11x    17x   19x
-types        | 1x   2.2x   0.97x  2x   | 1.2x  1.9x | 11x   13x    12x   14x
--------------|-------------------------|------------|-----------------------
-= Average => | 1x   1.9x   0.98x  1.7x | 2.5x  3.9x | 14x   17x    16x   19x
-.............................................................................
-
-
-// vi:ft=asciidoc tw=72:

3rd/lua-cjson/rfc4627.txt

@@ -1,563 +0,0 @@
-
-
-
-
-
-
-Network Working Group                                       D. Crockford
-Request for Comments: 4627                                      JSON.org
-Category: Informational                                        July 2006
-
-
- The application/json Media Type for JavaScript Object Notation (JSON)
-
-Status of This Memo
-
-   This memo provides information for the Internet community.  It does
-   not specify an Internet standard of any kind.  Distribution of this
-   memo is unlimited.
-
-Copyright Notice
-
-   Copyright (C) The Internet Society (2006).
-
-Abstract
-
-   JavaScript Object Notation (JSON) is a lightweight, text-based,
-   language-independent data interchange format.  It was derived from
-   the ECMAScript Programming Language Standard.  JSON defines a small
-   set of formatting rules for the portable representation of structured
-   data.
-
-1.  Introduction
-
-   JavaScript Object Notation (JSON) is a text format for the
-   serialization of structured data.  It is derived from the object
-   literals of JavaScript, as defined in the ECMAScript Programming
-   Language Standard, Third Edition [ECMA].
-
-   JSON can represent four primitive types (strings, numbers, booleans,
-   and null) and two structured types (objects and arrays).
-
-   A string is a sequence of zero or more Unicode characters [UNICODE].
-
-   An object is an unordered collection of zero or more name/value
-   pairs, where a name is a string and a value is a string, number,
-   boolean, null, object, or array.
-
-   An array is an ordered sequence of zero or more values.
-
-   The terms "object" and "array" come from the conventions of
-   JavaScript.
-
-   JSON's design goals were for it to be minimal, portable, textual, and
-   a subset of JavaScript.
-
-
-
-Crockford                    Informational                      [Page 1]
-
-RFC 4627                          JSON                         July 2006
-
-
-1.1.  Conventions Used in This Document
-
-   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
-   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
-   document are to be interpreted as described in [RFC2119].
-
-   The grammatical rules in this document are to be interpreted as
-   described in [RFC4234].
-
-2.  JSON Grammar
-
-   A JSON text is a sequence of tokens.  The set of tokens includes six
-   structural characters, strings, numbers, and three literal names.
-
-   A JSON text is a serialized object or array.
-
-      JSON-text = object / array
-
-   These are the six structural characters:
-
-      begin-array     = ws %x5B ws  ; [ left square bracket
-
-      begin-object    = ws %x7B ws  ; { left curly bracket
-
-      end-array       = ws %x5D ws  ; ] right square bracket
-
-      end-object      = ws %x7D ws  ; } right curly bracket
-
-      name-separator  = ws %x3A ws  ; : colon
-
-      value-separator = ws %x2C ws  ; , comma
-
-   Insignificant whitespace is allowed before or after any of the six
-   structural characters.
-
-      ws = *(
-                %x20 /              ; Space
-                %x09 /              ; Horizontal tab
-                %x0A /              ; Line feed or New line
-                %x0D                ; Carriage return
-            )
-
-2.1.  Values
-
-   A JSON value MUST be an object, array, number, or string, or one of
-   the following three literal names:
-
-      false null true
-
-
-
-Crockford                    Informational                      [Page 2]
-
-RFC 4627                          JSON                         July 2006
-
-
-   The literal names MUST be lowercase.  No other literal names are
-   allowed.
-
-         value = false / null / true / object / array / number / string
-
-         false = %x66.61.6c.73.65   ; false
-
-         null  = %x6e.75.6c.6c      ; null
-
-         true  = %x74.72.75.65      ; true
-
-2.2.  Objects
-
-   An object structure is represented as a pair of curly brackets
-   surrounding zero or more name/value pairs (or members).  A name is a
-   string.  A single colon comes after each name, separating the name
-   from the value.  A single comma separates a value from a following
-   name.  The names within an object SHOULD be unique.
-
-      object = begin-object [ member *( value-separator member ) ]
-      end-object
-
-      member = string name-separator value
-
-2.3.  Arrays
-
-   An array structure is represented as square brackets surrounding zero
-   or more values (or elements).  Elements are separated by commas.
-
-      array = begin-array [ value *( value-separator value ) ] end-array
-
-2.4.  Numbers
-
-   The representation of numbers is similar to that used in most
-   programming languages.  A number contains an integer component that
-   may be prefixed with an optional minus sign, which may be followed by
-   a fraction part and/or an exponent part.
-
-   Octal and hex forms are not allowed.  Leading zeros are not allowed.
-
-   A fraction part is a decimal point followed by one or more digits.
-
-   An exponent part begins with the letter E in upper or lowercase,
-   which may be followed by a plus or minus sign.  The E and optional
-   sign are followed by one or more digits.
-
-   Numeric values that cannot be represented as sequences of digits
-   (such as Infinity and NaN) are not permitted.
-
-
-
-Crockford                    Informational                      [Page 3]
-
-RFC 4627                          JSON                         July 2006
-
-
-         number = [ minus ] int [ frac ] [ exp ]
-
-         decimal-point = %x2E       ; .
-
-         digit1-9 = %x31-39         ; 1-9
-
-         e = %x65 / %x45            ; e E
-
-         exp = e [ minus / plus ] 1*DIGIT
-
-         frac = decimal-point 1*DIGIT
-
-         int = zero / ( digit1-9 *DIGIT )
-
-         minus = %x2D               ; -
-
-         plus = %x2B                ; +
-
-         zero = %x30                ; 0
-
-2.5.  Strings
-
-   The representation of strings is similar to conventions used in the C
-   family of programming languages.  A string begins and ends with
-   quotation marks.  All Unicode characters may be placed within the
-   quotation marks except for the characters that must be escaped:
-   quotation mark, reverse solidus, and the control characters (U+0000
-   through U+001F).
-
-   Any character may be escaped.  If the character is in the Basic
-   Multilingual Plane (U+0000 through U+FFFF), then it may be
-   represented as a six-character sequence: a reverse solidus, followed
-   by the lowercase letter u, followed by four hexadecimal digits that
-   encode the character's code point.  The hexadecimal letters A though
-   F can be upper or lowercase.  So, for example, a string containing
-   only a single reverse solidus character may be represented as
-   "\u005C".
-
-   Alternatively, there are two-character sequence escape
-   representations of some popular characters.  So, for example, a
-   string containing only a single reverse solidus character may be
-   represented more compactly as "\\".
-
-   To escape an extended character that is not in the Basic Multilingual
-   Plane, the character is represented as a twelve-character sequence,
-   encoding the UTF-16 surrogate pair.  So, for example, a string
-   containing only the G clef character (U+1D11E) may be represented as
-   "\uD834\uDD1E".
-
-
-
-Crockford                    Informational                      [Page 4]
-
-RFC 4627                          JSON                         July 2006
-
-
-         string = quotation-mark *char quotation-mark
-
-         char = unescaped /
-                escape (
-                    %x22 /          ; "    quotation mark  U+0022
-                    %x5C /          ; \    reverse solidus U+005C
-                    %x2F /          ; /    solidus         U+002F
-                    %x62 /          ; b    backspace       U+0008
-                    %x66 /          ; f    form feed       U+000C
-                    %x6E /          ; n    line feed       U+000A
-                    %x72 /          ; r    carriage return U+000D
-                    %x74 /          ; t    tab             U+0009
-                    %x75 4HEXDIG )  ; uXXXX                U+XXXX
-
-         escape = %x5C              ; \
-
-         quotation-mark = %x22      ; "
-
-         unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
-
-3.  Encoding
-
-   JSON text SHALL be encoded in Unicode.  The default encoding is
-   UTF-8.
-
-   Since the first two characters of a JSON text will always be ASCII
-   characters [RFC0020], it is possible to determine whether an octet
-   stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
-   at the pattern of nulls in the first four octets.
-
-           00 00 00 xx  UTF-32BE
-           00 xx 00 xx  UTF-16BE
-           xx 00 00 00  UTF-32LE
-           xx 00 xx 00  UTF-16LE
-           xx xx xx xx  UTF-8
-
-4.  Parsers
-
-   A JSON parser transforms a JSON text into another representation.  A
-   JSON parser MUST accept all texts that conform to the JSON grammar.
-   A JSON parser MAY accept non-JSON forms or extensions.
-
-   An implementation may set limits on the size of texts that it
-   accepts.  An implementation may set limits on the maximum depth of
-   nesting.  An implementation may set limits on the range of numbers.
-   An implementation may set limits on the length and character contents
-   of strings.
-
-
-
-
-Crockford                    Informational                      [Page 5]
-
-RFC 4627                          JSON                         July 2006
-
-
-5. Generators
-
-   A JSON generator produces JSON text.  The resulting text MUST
-   strictly conform to the JSON grammar.
-
-6. IANA Considerations
-
-   The MIME media type for JSON text is application/json.
-
-   Type name: application
-
-   Subtype name: json
-
-   Required parameters: n/a
-
-   Optional parameters: n/a
-
-   Encoding considerations: 8bit if UTF-8; binary if UTF-16 or UTF-32
-
-      JSON may be represented using UTF-8, UTF-16, or UTF-32.  When JSON
-      is written in UTF-8, JSON is 8bit compatible.  When JSON is
-      written in UTF-16 or UTF-32, the binary content-transfer-encoding
-      must be used.
-
-   Security considerations:
-
-   Generally there are security issues with scripting languages.  JSON
-   is a subset of JavaScript, but it is a safe subset that excludes
-   assignment and invocation.
-
-   A JSON text can be safely passed into JavaScript's eval() function
-   (which compiles and executes a string) if all the characters not
-   enclosed in strings are in the set of characters that form JSON
-   tokens.  This can be quickly determined in JavaScript with two
-   regular expressions and calls to the test and replace methods.
-
-      var my_JSON_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
-             text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
-         eval('(' + text + ')');
-
-   Interoperability considerations: n/a
-
-   Published specification: RFC 4627
-
-
-
-
-
-
-
-
-Crockford                    Informational                      [Page 6]
-
-RFC 4627                          JSON                         July 2006
-
-
-   Applications that use this media type:
-
-      JSON has been used to exchange data between applications written
-      in all of these programming languages: ActionScript, C, C#,
-      ColdFusion, Common Lisp, E, Erlang, Java, JavaScript, Lua,
-      Objective CAML, Perl, PHP, Python, Rebol, Ruby, and Scheme.
-
-   Additional information:
-
-      Magic number(s): n/a
-      File extension(s): .json
-      Macintosh file type code(s): TEXT
-
-   Person & email address to contact for further information:
-      Douglas Crockford
-      douglas@crockford.com
-
-   Intended usage: COMMON
-
-   Restrictions on usage: none
-
-   Author:
-      Douglas Crockford
-      douglas@crockford.com
-
-   Change controller:
-      Douglas Crockford
-      douglas@crockford.com
-
-7. Security Considerations
-
-   See Security Considerations in Section 6.
-
-8. Examples
-
-   This is a JSON object:
-
-   {
-      "Image": {
-          "Width":  800,
-          "Height": 600,
-          "Title":  "View from 15th Floor",
-          "Thumbnail": {
-              "Url":    "http://www.example.com/image/481989943",
-              "Height": 125,
-              "Width":  "100"
-          },
-          "IDs": [116, 943, 234, 38793]
-
-
-
-Crockford                    Informational                      [Page 7]
-
-RFC 4627                          JSON                         July 2006
-
-
-        }
-   }
-
-   Its Image member is an object whose Thumbnail member is an object
-   and whose IDs member is an array of numbers.
-
-   This is a JSON array containing two objects:
-
-   [
-      {
-         "precision": "zip",
-         "Latitude":  37.7668,
-         "Longitude": -122.3959,
-         "Address":   "",
-         "City":      "SAN FRANCISCO",
-         "State":     "CA",
-         "Zip":       "94107",
-         "Country":   "US"
-      },
-      {
-         "precision": "zip",
-         "Latitude":  37.371991,
-         "Longitude": -122.026020,
-         "Address":   "",
-         "City":      "SUNNYVALE",
-         "State":     "CA",
-         "Zip":       "94085",
-         "Country":   "US"
-      }
-   ]
-
-9. References
-
-9.1.  Normative References
-
-   [ECMA]    European Computer Manufacturers Association, "ECMAScript
-             Language Specification 3rd Edition", December 1999,
-             <http://www.ecma-international.org/publications/files/
-             ecma-st/ECMA-262.pdf>.
-
-   [RFC0020] Cerf, V., "ASCII format for network interchange", RFC 20,
-             October 1969.
-
-   [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
-             Requirement Levels", BCP 14, RFC 2119, March 1997.
-
-   [RFC4234] Crocker, D. and P.  Overell, "Augmented BNF for Syntax
-             Specifications: ABNF", RFC 4234, October 2005.
-
-
-
-Crockford                    Informational                      [Page 8]
-
-RFC 4627                          JSON                         July 2006
-
-
-   [UNICODE] The Unicode Consortium, "The Unicode Standard Version 4.0",
-             2003, <http://www.unicode.org/versions/Unicode4.1.0/>.
-
-Author's Address
-
-   Douglas Crockford
-   JSON.org
-   EMail: douglas@crockford.com
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Crockford                    Informational                      [Page 9]
-
-RFC 4627                          JSON                         July 2006
-
-
-Full Copyright Statement
-
-   Copyright (C) The Internet Society (2006).
-
-   This document is subject to the rights, licenses and restrictions
-   contained in BCP 78, and except as set forth therein, the authors
-   retain all their rights.
-
-   This document and the information contained herein are provided on an
-   "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
-   OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET
-   ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,
-   INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
-   INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
-   WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
-
-Intellectual Property
-
-   The IETF takes no position regarding the validity or scope of any
-   Intellectual Property Rights or other rights that might be claimed to
-   pertain to the implementation or use of the technology described in
-   this document or the extent to which any license under such rights
-   might or might not be available; nor does it represent that it has
-   made any independent effort to identify any such rights.  Information
-   on the procedures with respect to rights in RFC documents can be
-   found in BCP 78 and BCP 79.
-
-   Copies of IPR disclosures made to the IETF Secretariat and any
-   assurances of licenses to be made available, or the result of an
-   attempt made to obtain a general license or permission for the use of
-   such proprietary rights by implementers or users of this
-   specification can be obtained from the IETF on-line IPR repository at
-   http://www.ietf.org/ipr.
-
-   The IETF invites any interested party to bring to its attention any
-   copyrights, patents or patent applications, or other proprietary
-   rights that may cover technology that may be required to implement
-   this standard.  Please address the information to the IETF at
-   ietf-ipr@ietf.org.
-
-Acknowledgement
-
-   Funding for the RFC Editor function is provided by the IETF
-   Administrative Support Activity (IASA).
-
-
-
-
-
-
-
-Crockford                    Informational                     [Page 10]
-

3rd/lua-cjson/runtests.sh

@@ -1,92 +0,0 @@
-#!/bin/sh
-
-PLATFORM="`uname -s`"
-[ "$1" ] && VERSION="$1" || VERSION="2.1.0"
-
-set -e
-
-# Portable "ggrep -A" replacement.
-# Work around Solaris awk record limit of 2559 bytes.
-# contextgrep PATTERN POST_MATCH_LINES
-contextgrep() {
-    cut -c -2500 | awk "/$1/ { count = ($2 + 1) } count > 0 { count--; print }"
-}
-
-do_tests() {
-    echo
-    cd tests
-    lua -e 'print("Testing Lua CJSON version " .. require("cjson")._VERSION)'
-    ./test.lua | contextgrep 'FAIL|Summary' 3 | grep -v PASS | cut -c -150
-    cd ..
-}
-
-echo "===== Setting LuaRocks PATH ====="
-eval "`luarocks path`"
-
-echo "===== Building UTF-8 test data ====="
-( cd tests && ./genutf8.pl; )
-
-echo "===== Cleaning old build data ====="
-make clean
-rm -f tests/cjson.so
-
-echo "===== Verifying cjson.so is not installed ====="
-
-cd tests
-if lua -e 'require "cjson"' 2>/dev/null
-then
-    cat <<EOT
-Please ensure you do not have the Lua CJSON module installed before
-running these tests.
-EOT
-    exit
-fi
-cd ..
-
-echo "===== Testing LuaRocks build ====="
-luarocks make --local
-do_tests
-luarocks remove --local lua-cjson
-make clean
-
-echo "===== Testing Makefile build ====="
-make
-cp -r lua/cjson cjson.so tests
-do_tests
-make clean
-rm -rf tests/cjson{,.so}
-
-echo "===== Testing Cmake build ====="
-mkdir build
-cd build
-cmake ..
-make
-cd ..
-cp -r lua/cjson build/cjson.so tests
-do_tests
-rm -rf build tests/cjson{,.so}
-
-if [ "$PLATFORM" = "Linux" ]
-then
-    echo "===== Testing RPM build ====="
-    SRCTGZ=""
-    TGZ=lua-cjson-$VERSION.tar.gz
-    for D in .. packages .
-    do
-        [ -r "$D/$TGZ" ] && SRCTGZ="$D/$TGZ"
-    done
-    if [ "$SRCTGZ" ]
-    then
-        LOG=/tmp/build.$$
-        rpmbuild -tb "$SRCTGZ" > "$LOG"
-        RPM="`awk '/^Wrote: / && ! /debuginfo/ { print $2}' < "$LOG"`"
-        sudo -- rpm -Uvh \"$RPM\"
-        do_tests
-        sudo -- rpm -e lua-cjson
-        rm -f "$LOG"
-    else
-        echo "==> skipping, $TGZ not found"
-    fi
-fi
-
-# vi:ai et sw=4 ts=4:

3rd/lua-cjson/strbuf.c

@@ -1,251 +0,0 @@
-/* strbuf - String buffer routines
- *
- * Copyright (c) 2010-2012  Mark Pulford <mark@kyne.com.au>
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-
-#include "strbuf.h"
-
-static void die(const char *fmt, ...)
-{
-    va_list arg;
-
-    va_start(arg, fmt);
-    vfprintf(stderr, fmt, arg);
-    va_end(arg);
-    fprintf(stderr, "\n");
-
-    exit(-1);
-}
-
-void strbuf_init(strbuf_t *s, int len)
-{
-    int size;
-
-    if (len <= 0)
-        size = STRBUF_DEFAULT_SIZE;
-    else
-        size = len + 1;         /* \0 terminator */
-
-    s->buf = NULL;
-    s->size = size;
-    s->length = 0;
-    s->increment = STRBUF_DEFAULT_INCREMENT;
-    s->dynamic = 0;
-    s->reallocs = 0;
-    s->debug = 0;
-
-    s->buf = malloc(size);
-    if (!s->buf)
-        die("Out of memory");
-
-    strbuf_ensure_null(s);
-}
-
-strbuf_t *strbuf_new(int len)
-{
-    strbuf_t *s;
-
-    s = malloc(sizeof(strbuf_t));
-    if (!s)
-        die("Out of memory");
-
-    strbuf_init(s, len);
-
-    /* Dynamic strbuf allocation / deallocation */
-    s->dynamic = 1;
-
-    return s;
-}
-
-void strbuf_set_increment(strbuf_t *s, int increment)
-{
-    /* Increment > 0:  Linear buffer growth rate
-     * Increment < -1: Exponential buffer growth rate */
-    if (increment == 0 || increment == -1)
-        die("BUG: Invalid string increment");
-
-    s->increment = increment;
-}
-
-static inline void debug_stats(strbuf_t *s)
-{
-    if (s->debug) {
-        fprintf(stderr, "strbuf(%lx) reallocs: %d, length: %d, size: %d\n",
-                (long)s, s->reallocs, s->length, s->size);
-    }
-}
-
-/* If strbuf_t has not been dynamically allocated, strbuf_free() can
- * be called any number of times strbuf_init() */
-void strbuf_free(strbuf_t *s)
-{
-    debug_stats(s);
-
-    if (s->buf) {
-        free(s->buf);
-        s->buf = NULL;
-    }
-    if (s->dynamic)
-        free(s);
-}
-
-char *strbuf_free_to_string(strbuf_t *s, int *len)
-{
-    char *buf;
-
-    debug_stats(s);
-
-    strbuf_ensure_null(s);
-
-    buf = s->buf;
-    if (len)
-        *len = s->length;
-
-    if (s->dynamic)
-        free(s);
-
-    return buf;
-}
-
-static int calculate_new_size(strbuf_t *s, int len)
-{
-    int reqsize, newsize;
-
-    if (len <= 0)
-        die("BUG: Invalid strbuf length requested");
-
-    /* Ensure there is room for optional NULL termination */
-    reqsize = len + 1;
-
-    /* If the user has requested to shrink the buffer, do it exactly */
-    if (s->size > reqsize)
-        return reqsize;
-
-    newsize = s->size;
-    if (s->increment < 0) {
-        /* Exponential sizing */
-        while (newsize < reqsize)
-            newsize *= -s->increment;
-    } else {
-        /* Linear sizing */
-        newsize = ((newsize + s->increment - 1) / s->increment) * s->increment;
-    }
-
-    return newsize;
-}
-
-
-/* Ensure strbuf can handle a string length bytes long (ignoring NULL
- * optional termination). */
-void strbuf_resize(strbuf_t *s, int len)
-{
-    int newsize;
-
-    newsize = calculate_new_size(s, len);
-
-    if (s->debug > 1) {
-        fprintf(stderr, "strbuf(%lx) resize: %d => %d\n",
-                (long)s, s->size, newsize);
-    }
-
-    s->size = newsize;
-    s->buf = realloc(s->buf, s->size);
-    if (!s->buf)
-        die("Out of memory");
-    s->reallocs++;
-}
-
-void strbuf_append_string(strbuf_t *s, const char *str)
-{
-    int space, i;
-
-    space = strbuf_empty_length(s);
-
-    for (i = 0; str[i]; i++) {
-        if (space < 1) {
-            strbuf_resize(s, s->length + 1);
-            space = strbuf_empty_length(s);
-        }
-
-        s->buf[s->length] = str[i];
-        s->length++;
-        space--;
-    }
-}
-
-/* strbuf_append_fmt() should only be used when an upper bound
- * is known for the output string. */
-void strbuf_append_fmt(strbuf_t *s, int len, const char *fmt, ...)
-{
-    va_list arg;
-    int fmt_len;
-
-    strbuf_ensure_empty_length(s, len);
-
-    va_start(arg, fmt);
-    fmt_len = vsnprintf(s->buf + s->length, len, fmt, arg);
-    va_end(arg);
-
-    if (fmt_len < 0)
-        die("BUG: Unable to convert number");  /* This should never happen.. */
-
-    s->length += fmt_len;
-}
-
-/* strbuf_append_fmt_retry() can be used when the there is no known
- * upper bound for the output string. */
-void strbuf_append_fmt_retry(strbuf_t *s, const char *fmt, ...)
-{
-    va_list arg;
-    int fmt_len, try;
-    int empty_len;
-
-    /* If the first attempt to append fails, resize the buffer appropriately
-     * and try again */
-    for (try = 0; ; try++) {
-        va_start(arg, fmt);
-        /* Append the new formatted string */
-        /* fmt_len is the length of the string required, excluding the
-         * trailing NULL */
-        empty_len = strbuf_empty_length(s);
-        /* Add 1 since there is also space to store the terminating NULL. */
-        fmt_len = vsnprintf(s->buf + s->length, empty_len + 1, fmt, arg);
-        va_end(arg);
-
-        if (fmt_len <= empty_len)
-            break;  /* SUCCESS */
-        if (try > 0)
-            die("BUG: length of formatted string changed");
-
-        strbuf_resize(s, s->length + fmt_len);
-    }
-
-    s->length += fmt_len;
-}
-
-/* vi:ai et sw=4 ts=4:
- */

3rd/lua-cjson/strbuf.h

@@ -1,154 +0,0 @@
-/* strbuf - String buffer routines
- *
- * Copyright (c) 2010-2012  Mark Pulford <mark@kyne.com.au>
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <stdlib.h>
-#include <stdarg.h>
-
-/* Size: Total bytes allocated to *buf
- * Length: String length, excluding optional NULL terminator.
- * Increment: Allocation increments when resizing the string buffer.
- * Dynamic: True if created via strbuf_new()
- */
-
-typedef struct {
-    char *buf;
-    int size;
-    int length;
-    int increment;
-    int dynamic;
-    int reallocs;
-    int debug;
-} strbuf_t;
-
-#ifndef STRBUF_DEFAULT_SIZE
-#define STRBUF_DEFAULT_SIZE 1023
-#endif
-#ifndef STRBUF_DEFAULT_INCREMENT
-#define STRBUF_DEFAULT_INCREMENT -2
-#endif
-
-/* Initialise */
-extern strbuf_t *strbuf_new(int len);
-extern void strbuf_init(strbuf_t *s, int len);
-extern void strbuf_set_increment(strbuf_t *s, int increment);
-
-/* Release */
-extern void strbuf_free(strbuf_t *s);
-extern char *strbuf_free_to_string(strbuf_t *s, int *len);
-
-/* Management */
-extern void strbuf_resize(strbuf_t *s, int len);
-static int strbuf_empty_length(strbuf_t *s);
-static int strbuf_length(strbuf_t *s);
-static char *strbuf_string(strbuf_t *s, int *len);
-static void strbuf_ensure_empty_length(strbuf_t *s, int len);
-static char *strbuf_empty_ptr(strbuf_t *s);
-static void strbuf_extend_length(strbuf_t *s, int len);
-
-/* Update */
-extern void strbuf_append_fmt(strbuf_t *s, int len, const char *fmt, ...);
-extern void strbuf_append_fmt_retry(strbuf_t *s, const char *format, ...);
-static void strbuf_append_mem(strbuf_t *s, const char *c, int len);
-extern void strbuf_append_string(strbuf_t *s, const char *str);
-static void strbuf_append_char(strbuf_t *s, const char c);
-static void strbuf_ensure_null(strbuf_t *s);
-
-/* Reset string for before use */
-static inline void strbuf_reset(strbuf_t *s)
-{
-    s->length = 0;
-}
-
-static inline int strbuf_allocated(strbuf_t *s)
-{
-    return s->buf != NULL;
-}
-
-/* Return bytes remaining in the string buffer
- * Ensure there is space for a NULL terminator. */
-static inline int strbuf_empty_length(strbuf_t *s)
-{
-    return s->size - s->length - 1;
-}
-
-static inline void strbuf_ensure_empty_length(strbuf_t *s, int len)
-{
-    if (len > strbuf_empty_length(s))
-        strbuf_resize(s, s->length + len);
-}
-
-static inline char *strbuf_empty_ptr(strbuf_t *s)
-{
-    return s->buf + s->length;
-}
-
-static inline void strbuf_extend_length(strbuf_t *s, int len)
-{
-    s->length += len;
-}
-
-static inline int strbuf_length(strbuf_t *s)
-{
-    return s->length;
-}
-
-static inline void strbuf_append_char(strbuf_t *s, const char c)
-{
-    strbuf_ensure_empty_length(s, 1);
-    s->buf[s->length++] = c;
-}
-
-static inline void strbuf_append_char_unsafe(strbuf_t *s, const char c)
-{
-    s->buf[s->length++] = c;
-}
-
-static inline void strbuf_append_mem(strbuf_t *s, const char *c, int len)
-{
-    strbuf_ensure_empty_length(s, len);
-    memcpy(s->buf + s->length, c, len);
-    s->length += len;
-}
-
-static inline void strbuf_append_mem_unsafe(strbuf_t *s, const char *c, int len)
-{
-    memcpy(s->buf + s->length, c, len);
-    s->length += len;
-}
-
-static inline void strbuf_ensure_null(strbuf_t *s)
-{
-    s->buf[s->length] = 0;
-}
-
-static inline char *strbuf_string(strbuf_t *s, int *len)
-{
-    if (len)
-        *len = s->length;
-
-    return s->buf;
-}
-
-/* vi:ai et sw=4 ts=4:
- */

3rd/lua-cjson/tests/README

@@ -1,4 +0,0 @@
-These JSON examples were taken from the JSON website
-(http://json.org/example.html) and RFC 4627.
-
-Used with permission.

3rd/lua-cjson/tests/bench.lua

@@ -1,131 +0,0 @@
-#!/usr/bin/env lua
-
--- This benchmark script measures wall clock time and should be
--- run on an unloaded system.
---
--- Your Mileage May Vary.
---
--- Mark Pulford <mark@kyne.com.au>
-
-local json_module = os.getenv("JSON_MODULE") or "cjson"
-
-require "socket"
-local json = require(json_module)
-local util = require "cjson.util"
-
-local function find_func(mod, funcnames)
-    for _, v in ipairs(funcnames) do
-        if mod[v] then
-            return mod[v]
-        end
-    end
-
-    return nil
-end
-
-local json_encode = find_func(json, { "encode", "Encode", "to_string", "stringify", "json" })
-local json_decode = find_func(json, { "decode", "Decode", "to_value", "parse" })
-
-local function average(t)
-    local total = 0
-    for _, v in ipairs(t) do
-        total = total + v
-    end
-    return total / #t
-end
-
-function benchmark(tests, seconds, rep)
-    local function bench(func, iter)
-        -- Use socket.gettime() to measure microsecond resolution
-        -- wall clock time.
-        local t = socket.gettime()
-        for i = 1, iter do
-            func(i)
-        end
-        t = socket.gettime() - t
-
-        -- Don't trust any results when the run lasted for less than a
-        -- millisecond - return nil.
-        if t < 0.001 then
-            return nil
-        end
-
-        return (iter / t)
-    end
-
-    -- Roughly calculate the number of interations required
-    -- to obtain a particular time period.
-    local function calc_iter(func, seconds)
-        local iter = 1
-        local rate
-        -- Warm up the bench function first.
-        func()
-        while not rate do
-            rate = bench(func, iter)
-            iter = iter * 10
-        end
-        return math.ceil(seconds * rate)
-    end
-
-    local test_results = {}
-    for name, func in pairs(tests) do
-        -- k(number), v(string)
-        -- k(string), v(function)
-        -- k(number), v(function)
-        if type(func) == "string" then
-            name = func
-            func = _G[name]
-        end
-
-        local iter = calc_iter(func, seconds)
-
-        local result = {}
-        for i = 1, rep do
-            result[i] = bench(func, iter)
-        end
-
-        -- Remove the slowest half (round down) of the result set
-        table.sort(result)
-        for i = 1, math.floor(#result / 2) do
-            table.remove(result, 1)
-        end
-
-        test_results[name] = average(result)
-    end
-
-    return test_results
-end
-
-function bench_file(filename)
-    local data_json = util.file_load(filename)
-    local data_obj = json_decode(data_json)
-
-    local function test_encode()
-        json_encode(data_obj)
-    end
-    local function test_decode()
-        json_decode(data_json)
-    end
-
-    local tests = {}
-    if json_encode then tests.encode = test_encode end
-    if json_decode then tests.decode = test_decode end
-
-    return benchmark(tests, 0.1, 5)
-end
-
--- Optionally load any custom configuration required for this module
-local success, data = pcall(util.file_load, ("bench-%s.lua"):format(json_module))
-if success then
-    util.run_script(data, _G)
-    configure(json)
-end
-
-for i = 1, #arg do
-    local results = bench_file(arg[i])
-    for k, v in pairs(results) do
-        print(("%s\t%s\t%d"):format(arg[i], k, v))
-    end
-end
-
--- vi:ai et sw=4 ts=4:

3rd/lua-cjson/tests/example1.json

@@ -1,22 +0,0 @@
-{
-    "glossary": {
-        "title": "example glossary",
-                "GlossDiv": {
-            "title": "S",
-                        "GlossList": {
-                "GlossEntry": {
-                    "ID": "SGML",
-                                        "SortAs": "SGML",
-                                        "GlossTerm": "Standard Generalized Mark up Language",
-                                        "Acronym": "SGML",
-                                        "Abbrev": "ISO 8879:1986",
-                                        "GlossDef": {
-                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
-                                                "GlossSeeAlso": ["GML", "XML"]
-                    },
-                                        "GlossSee": "markup"
-                }
-            }
-        }
-    }
-}

3rd/lua-cjson/tests/example2.json

@@ -1,11 +0,0 @@
-{"menu": {
-  "id": "file",
-  "value": "File",
-  "popup": {
-    "menuitem": [
-      {"value": "New", "onclick": "CreateNewDoc()"},
-      {"value": "Open", "onclick": "OpenDoc()"},
-      {"value": "Close", "onclick": "CloseDoc()"}
-    ]
-  }
-}}

3rd/lua-cjson/tests/example3.json

@@ -1,26 +0,0 @@
-{"widget": {
-    "debug": "on",
-    "window": {
-        "title": "Sample Konfabulator Widget",
-        "name": "main_window",
-        "width": 500,
-        "height": 500
-    },
-    "image": {
-        "src": "Images/Sun.png",
-        "name": "sun1",
-        "hOffset": 250,
-        "vOffset": 250,
-        "alignment": "center"
-    },
-    "text": {
-        "data": "Click Here",
-        "size": 36,
-        "style": "bold",
-        "name": "text1",
-        "hOffset": 250,
-        "vOffset": 100,
-        "alignment": "center",
-        "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
-    }
-}}

3rd/lua-cjson/tests/example4.json

@@ -1,88 +0,0 @@
-{"web-app": {
-  "servlet": [
-    {
-      "servlet-name": "cofaxCDS",
-      "servlet-class": "org.cofax.cds.CDSServlet",
-      "init-param": {
-        "configGlossary:installationAt": "Philadelphia, PA",
-        "configGlossary:adminEmail": "ksm@pobox.com",
-        "configGlossary:poweredBy": "Cofax",
-        "configGlossary:poweredByIcon": "/images/cofax.gif",
-        "configGlossary:staticPath": "/content/static",
-        "templateProcessorClass": "org.cofax.WysiwygTemplate",
-        "templateLoaderClass": "org.cofax.FilesTemplateLoader",
-        "templatePath": "templates",
-        "templateOverridePath": "",
-        "defaultListTemplate": "listTemplate.htm",
-        "defaultFileTemplate": "articleTemplate.htm",
-        "useJSP": false,
-        "jspListTemplate": "listTemplate.jsp",
-        "jspFileTemplate": "articleTemplate.jsp",
-        "cachePackageTagsTrack": 200,
-        "cachePackageTagsStore": 200,
-        "cachePackageTagsRefresh": 60,
-        "cacheTemplatesTrack": 100,
-        "cacheTemplatesStore": 50,
-        "cacheTemplatesRefresh": 15,
-        "cachePagesTrack": 200,
-        "cachePagesStore": 100,
-        "cachePagesRefresh": 10,
-        "cachePagesDirtyRead": 10,
-        "searchEngineListTemplate": "forSearchEnginesList.htm",
-        "searchEngineFileTemplate": "forSearchEngines.htm",
-        "searchEngineRobotsDb": "WEB-INF/robots.db",
-        "useDataStore": true,
-        "dataStoreClass": "org.cofax.SqlDataStore",
-        "redirectionClass": "org.cofax.SqlRedirection",
-        "dataStoreName": "cofax",
-        "dataStoreDriver": "com.microsoft.jdbc.sqlserver.SQLServerDriver",
-        "dataStoreUrl": "jdbc:microsoft:sqlserver://LOCALHOST:1433;DatabaseName=goon",
-        "dataStoreUser": "sa",
-        "dataStorePassword": "dataStoreTestQuery",
-        "dataStoreTestQuery": "SET NOCOUNT ON;select test='test';",
-        "dataStoreLogFile": "/usr/local/tomcat/logs/datastore.log",
-        "dataStoreInitConns": 10,
-        "dataStoreMaxConns": 100,
-        "dataStoreConnUsageLimit": 100,
-        "dataStoreLogLevel": "debug",
-        "maxUrlLength": 500}},
-    {
-      "servlet-name": "cofaxEmail",
-      "servlet-class": "org.cofax.cds.EmailServlet",
-      "init-param": {
-      "mailHost": "mail1",
-      "mailHostOverride": "mail2"}},
-    {
-      "servlet-name": "cofaxAdmin",
-      "servlet-class": "org.cofax.cds.AdminServlet"},
-
-    {
-      "servlet-name": "fileServlet",
-      "servlet-class": "org.cofax.cds.FileServlet"},
-    {
-      "servlet-name": "cofaxTools",
-      "servlet-class": "org.cofax.cms.CofaxToolsServlet",
-      "init-param": {
-        "templatePath": "toolstemplates/",
-        "log": 1,
-        "logLocation": "/usr/local/tomcat/logs/CofaxTools.log",
-        "logMaxSize": "",
-        "dataLog": 1,
-        "dataLogLocation": "/usr/local/tomcat/logs/dataLog.log",
-        "dataLogMaxSize": "",
-        "removePageCache": "/content/admin/remove?cache=pages&id=",
-        "removeTemplateCache": "/content/admin/remove?cache=templates&id=",
-        "fileTransferFolder": "/usr/local/tomcat/webapps/content/fileTransferFolder",
-        "lookInContext": 1,
-        "adminGroupID": 4,
-        "betaServer": true}}],
-  "servlet-mapping": {
-    "cofaxCDS": "/",
-    "cofaxEmail": "/cofaxutil/aemail/*",
-    "cofaxAdmin": "/admin/*",
-    "fileServlet": "/static/*",
-    "cofaxTools": "/tools/*"},
-
-  "taglib": {
-    "taglib-uri": "cofax.tld",
-    "taglib-location": "/WEB-INF/tlds/cofax.tld"}}}

3rd/lua-cjson/tests/example5.json

@@ -1,27 +0,0 @@
-{"menu": {
-    "header": "SVG Viewer",
-    "items": [
-        {"id": "Open"},
-        {"id": "OpenNew", "label": "Open New"},
-        null,
-        {"id": "ZoomIn", "label": "Zoom In"},
-        {"id": "ZoomOut", "label": "Zoom Out"},
-        {"id": "OriginalView", "label": "Original View"},
-        null,
-        {"id": "Quality"},
-        {"id": "Pause"},
-        {"id": "Mute"},
-        null,
-        {"id": "Find", "label": "Find..."},
-        {"id": "FindAgain", "label": "Find Again"},
-        {"id": "Copy"},
-        {"id": "CopyAgain", "label": "Copy Again"},
-        {"id": "CopySVG", "label": "Copy SVG"},
-        {"id": "ViewSVG", "label": "View SVG"},
-        {"id": "ViewSource", "label": "View Source"},
-        {"id": "SaveAs", "label": "Save As"},
-        null,
-        {"id": "Help"},
-        {"id": "About", "label": "About Adobe CVG Viewer..."}
-    ]
-}}

3rd/lua-cjson/tests/genutf8.pl

@@ -1,23 +0,0 @@
-#!/usr/bin/env perl
-
-# Create test comparison data using a different UTF-8 implementation.
-
-# The generated utf8.dat file must have the following MD5 sum:
-#       cff03b039d850f370a7362f3313e5268
-
-use strict;
-
-# 0xD800 - 0xDFFF are used to encode supplementary codepoints
-# 0x10000 - 0x10FFFF are supplementary codepoints
-my (@codepoints) = (0 .. 0xD7FF, 0xE000 .. 0x10FFFF);
-
-my $utf8 = pack("U*", @codepoints);
-defined($utf8) or die "Unable create UTF-8 string\n";
-
-open(FH, ">:utf8", "utf8.dat")
-    or die "Unable to open utf8.dat: $!\n";
-print FH $utf8
-    or die "Unable to write utf8.dat\n";
-close(FH);
-
-# vi:ai et sw=4 ts=4:

3rd/lua-cjson/tests/numbers.json

@@ -1,7 +0,0 @@
-[ 0.110001,
-  0.12345678910111,
-  0.412454033640,
-  2.6651441426902,
-  2.718281828459,
-  3.1415926535898,
-  2.1406926327793 ]

3rd/lua-cjson/tests/octets-escaped.dat

@@ -1 +0,0 @@
-"\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\"#$%&'()*+,-.\/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u007f€亗儎厗噲墛媽崕彁憭摂晼棙櫄洔潪煚、￥ウЖ┆<D096><E29486><EFBFBD>辈炒刀犯购患骄坷谅媚牌侨墒颂臀闲岩釉罩棕仝圮蒉哙徕沅彐玷殛腱眍镳耱篝貊鼬<E8B28A><E9BCAC><EFBFBD><EFBFBD>"

3rd/lua-cjson/tests/rfc-example1.json

@@ -1,13 +0,0 @@
-{
-   "Image": {
-       "Width":  800,
-       "Height": 600,
-       "Title":  "View from 15th Floor",
-       "Thumbnail": {
-           "Url":    "http://www.example.com/image/481989943",
-           "Height": 125,
-           "Width":  "100"
-       },
-       "IDs": [116, 943, 234, 38793]
-     }
-}

3rd/lua-cjson/tests/rfc-example2.json

@@ -1,22 +0,0 @@
-[
-   {
-      "precision": "zip",
-      "Latitude":  37.7668,
-      "Longitude": -122.3959,
-      "Address":   "",
-      "City":      "SAN FRANCISCO",
-      "State":     "CA",
-      "Zip":       "94107",
-      "Country":   "US"
-   },
-   {
-      "precision": "zip",
-      "Latitude":  37.371991,
-      "Longitude": -122.026020,
-      "Address":   "",
-      "City":      "SUNNYVALE",
-      "State":     "CA",
-      "Zip":       "94085",
-      "Country":   "US"
-   }
-]

3rd/lua-cjson/tests/test.lua

@@ -1,423 +0,0 @@
-#!/usr/bin/env lua
-
--- Lua CJSON tests
---
--- Mark Pulford <mark@kyne.com.au>
---
--- Note: The output of this script is easier to read with "less -S"
-
-local json = require "cjson"
-local json_safe = require "cjson.safe"
-local util = require "cjson.util"
-
-local function gen_raw_octets()
-    local chars = {}
-    for i = 0, 255 do chars[i + 1] = string.char(i) end
-    return table.concat(chars)
-end
-
--- Generate every UTF-16 codepoint, including supplementary codes
-local function gen_utf16_escaped()
-    -- Create raw table escapes
-    local utf16_escaped = {}
-    local count = 0
-
-    local function append_escape(code)
-        local esc = ('\\u%04X'):format(code)
-        table.insert(utf16_escaped, esc)
-    end
-
-    table.insert(utf16_escaped, '"')
-    for i = 0, 0xD7FF do
-        append_escape(i)
-    end
-    -- Skip 0xD800 - 0xDFFF since they are used to encode supplementary
-    -- codepoints
-    for i = 0xE000, 0xFFFF do
-        append_escape(i)
-    end
-    -- Append surrogate pair for each supplementary codepoint
-    for high = 0xD800, 0xDBFF do
-        for low = 0xDC00, 0xDFFF do
-            append_escape(high)
-            append_escape(low)
-        end
-    end
-    table.insert(utf16_escaped, '"')
-
-    return table.concat(utf16_escaped)
-end
-
-function load_testdata()
-    local data = {}
-
-    -- Data for 8bit raw <-> escaped octets tests
-    data.octets_raw = gen_raw_octets()
-    data.octets_escaped = util.file_load("octets-escaped.dat")
-
-    -- Data for \uXXXX -> UTF-8 test
-    data.utf16_escaped = gen_utf16_escaped()
-
-    -- Load matching data for utf16_escaped
-    local utf8_loaded
-    utf8_loaded, data.utf8_raw = pcall(util.file_load, "utf8.dat")
-    if not utf8_loaded then
-        data.utf8_raw = "Failed to load utf8.dat - please run genutf8.pl"
-    end
-
-    data.table_cycle = {}
-    data.table_cycle[1] = data.table_cycle
-
-    local big = {}
-    for i = 1, 1100 do
-        big = { { 10, false, true, json.null }, "string", a = big }
-    end
-    data.deeply_nested_data = big
-
-    return data
-end
-
-function test_decode_cycle(filename)
-    local obj1 = json.decode(util.file_load(filename))
-    local obj2 = json.decode(json.encode(obj1))
-    return util.compare_values(obj1, obj2)
-end
-
--- Set up data used in tests
-local Inf = math.huge;
-local NaN = math.huge * 0;
-
-local testdata = load_testdata()
-
-local cjson_tests = {
-    -- Test API variables
-    { "Check module name, version",
-      function () return json._NAME, json._VERSION end, { },
-      true, { "cjson", "2.1.0" } },
-
-    -- Test decoding simple types
-    { "Decode string",
-      json.decode, { '"test string"' }, true, { "test string" } },
-    { "Decode numbers",
-      json.decode, { '[ 0.0, -5e3, -1, 0.3e-3, 1023.2, 0e10 ]' },
-      true, { { 0.0, -5000, -1, 0.0003, 1023.2, 0 } } },
-    { "Decode null",
-      json.decode, { 'null' }, true, { json.null } },
-    { "Decode true",
-      json.decode, { 'true' }, true, { true } },
-    { "Decode false",
-      json.decode, { 'false' }, true, { false } },
-    { "Decode object with numeric keys",
-      json.decode, { '{ "1": "one", "3": "three" }' },
-      true, { { ["1"] = "one", ["3"] = "three" } } },
-    { "Decode object with string keys",
-      json.decode, { '{ "a": "a", "b": "b" }' },
-      true, { { a = "a", b = "b" } } },
-    { "Decode array",
-      json.decode, { '[ "one", null, "three" ]' },
-      true, { { "one", json.null, "three" } } },
-
-    -- Test decoding errors
-    { "Decode UTF-16BE [throw error]",
-      json.decode, { '\0"\0"' },
-      false, { "JSON parser does not support UTF-16 or UTF-32" } },
-    { "Decode UTF-16LE [throw error]",
-      json.decode, { '"\0"\0' },
-      false, { "JSON parser does not support UTF-16 or UTF-32" } },
-    { "Decode UTF-32BE [throw error]",
-      json.decode, { '\0\0\0"' },
-      false, { "JSON parser does not support UTF-16 or UTF-32" } },
-    { "Decode UTF-32LE [throw error]",
-      json.decode, { '"\0\0\0' },
-      false, { "JSON parser does not support UTF-16 or UTF-32" } },
-    { "Decode partial JSON [throw error]",
-      json.decode, { '{ "unexpected eof": ' },
-      false, { "Expected value but found T_END at character 21" } },
-    { "Decode with extra comma [throw error]",
-      json.decode, { '{ "extra data": true }, false' },
-      false, { "Expected the end but found T_COMMA at character 23" } },
-    { "Decode invalid escape code [throw error]",
-      json.decode, { [[ { "bad escape \q code" } ]] },
-      false, { "Expected object key string but found invalid escape code at character 16" } },
-    { "Decode invalid unicode escape [throw error]",
-      json.decode, { [[ { "bad unicode \u0f6 escape" } ]] },
-      false, { "Expected object key string but found invalid unicode escape code at character 17" } },
-    { "Decode invalid keyword [throw error]",
-      json.decode, { ' [ "bad barewood", test ] ' },
-      false, { "Expected value but found invalid token at character 20" } },
-    { "Decode invalid number #1 [throw error]",
-      json.decode, { '[ -+12 ]' },
-      false, { "Expected value but found invalid number at character 3" } },
-    { "Decode invalid number #2 [throw error]",
-      json.decode, { '-v' },
-      false, { "Expected value but found invalid number at character 1" } },
-    { "Decode invalid number exponent [throw error]",
-      json.decode, { '[ 0.4eg10 ]' },
-      false, { "Expected comma or array end but found invalid token at character 6" } },
-
-    -- Test decoding nested arrays / objects
-    { "Set decode_max_depth(5)",
-      json.decode_max_depth, { 5 }, true, { 5 } },
-    { "Decode array at nested limit",
-      json.decode, { '[[[[[ "nested" ]]]]]' },
-      true, { {{{{{ "nested" }}}}} } },
-    { "Decode array over nested limit [throw error]",
-      json.decode, { '[[[[[[ "nested" ]]]]]]' },
-      false, { "Found too many nested data structures (6) at character 6" } },
-    { "Decode object at nested limit",
-      json.decode, { '{"a":{"b":{"c":{"d":{"e":"nested"}}}}}' },
-      true, { {a={b={c={d={e="nested"}}}}} } },
-    { "Decode object over nested limit [throw error]",
-      json.decode, { '{"a":{"b":{"c":{"d":{"e":{"f":"nested"}}}}}}' },
-      false, { "Found too many nested data structures (6) at character 26" } },
-    { "Set decode_max_depth(1000)",
-      json.decode_max_depth, { 1000 }, true, { 1000 } },
-    { "Decode deeply nested array [throw error]",
-      json.decode, { string.rep("[", 1100) .. '1100' .. string.rep("]", 1100)},
-      false, { "Found too many nested data structures (1001) at character 1001" } },
-
-    -- Test encoding nested tables
-    { "Set encode_max_depth(5)",
-      json.encode_max_depth, { 5 }, true, { 5 } },
-    { "Encode nested table as array at nested limit",
-      json.encode, { {{{{{"nested"}}}}} }, true, { '[[[[["nested"]]]]]' } },
-    { "Encode nested table as array after nested limit [throw error]",
-      json.encode, { { {{{{{"nested"}}}}} } },
-      false, { "Cannot serialise, excessive nesting (6)" } },
-    { "Encode nested table as object at nested limit",
-      json.encode, { {a={b={c={d={e="nested"}}}}} },
-      true, { '{"a":{"b":{"c":{"d":{"e":"nested"}}}}}' } },
-    { "Encode nested table as object over nested limit [throw error]",
-      json.encode, { {a={b={c={d={e={f="nested"}}}}}} },
-      false, { "Cannot serialise, excessive nesting (6)" } },
-    { "Encode table with cycle [throw error]",
-      json.encode, { testdata.table_cycle },
-      false, { "Cannot serialise, excessive nesting (6)" } },
-    { "Set encode_max_depth(1000)",
-      json.encode_max_depth, { 1000 }, true, { 1000 } },
-    { "Encode deeply nested data [throw error]",
-      json.encode, { testdata.deeply_nested_data },
-      false, { "Cannot serialise, excessive nesting (1001)" } },
-
-    -- Test encoding simple types
-    { "Encode null",
-      json.encode, { json.null }, true, { 'null' } },
-    { "Encode true",
-      json.encode, { true }, true, { 'true' } },
-    { "Encode false",
-      json.encode, { false }, true, { 'false' } },
-    { "Encode empty object",
-      json.encode, { { } }, true, { '{}' } },
-    { "Encode integer",
-      json.encode, { 10 }, true, { '10' } },
-    { "Encode string",
-      json.encode, { "hello" }, true, { '"hello"' } },
-    { "Encode Lua function [throw error]",
-      json.encode, { function () end },
-      false, { "Cannot serialise function: type not supported" } },
-
-    -- Test decoding invalid numbers
-    { "Set decode_invalid_numbers(true)",
-      json.decode_invalid_numbers, { true }, true, { true } },
-    { "Decode hexadecimal",
-      json.decode, { '0x6.ffp1' }, true, { 13.9921875 } },
-    { "Decode numbers with leading zero",
-      json.decode, { '[ 0123, 00.33 ]' }, true, { { 123, 0.33 } } },
-    { "Decode +-Inf",
-      json.decode, { '[ +Inf, Inf, -Inf ]' }, true, { { Inf, Inf, -Inf } } },
-    { "Decode +-Infinity",
-      json.decode, { '[ +Infinity, Infinity, -Infinity ]' },
-      true, { { Inf, Inf, -Inf } } },
-    { "Decode +-NaN",
-      json.decode, { '[ +NaN, NaN, -NaN ]' }, true, { { NaN, NaN, NaN } } },
-    { "Decode Infrared (not infinity) [throw error]",
-      json.decode, { 'Infrared' },
-      false, { "Expected the end but found invalid token at character 4" } },
-    { "Decode Noodle (not NaN) [throw error]",
-      json.decode, { 'Noodle' },
-      false, { "Expected value but found invalid token at character 1" } },
-    { "Set decode_invalid_numbers(false)",
-      json.decode_invalid_numbers, { false }, true, { false } },
-    { "Decode hexadecimal [throw error]",
-      json.decode, { '0x6' },
-      false, { "Expected value but found invalid number at character 1" } },
-    { "Decode numbers with leading zero [throw error]",
-      json.decode, { '[ 0123, 00.33 ]' },
-      false, { "Expected value but found invalid number at character 3" } },
-    { "Decode +-Inf [throw error]",
-      json.decode, { '[ +Inf, Inf, -Inf ]' },
-      false, { "Expected value but found invalid token at character 3" } },
-    { "Decode +-Infinity [throw error]",
-      json.decode, { '[ +Infinity, Infinity, -Infinity ]' },
-      false, { "Expected value but found invalid token at character 3" } },
-    { "Decode +-NaN [throw error]",
-      json.decode, { '[ +NaN, NaN, -NaN ]' },
-      false, { "Expected value but found invalid token at character 3" } },
-    { 'Set decode_invalid_numbers("on")',
-      json.decode_invalid_numbers, { "on" }, true, { true } },
-
-    -- Test encoding invalid numbers
-    { "Set encode_invalid_numbers(false)",
-      json.encode_invalid_numbers, { false }, true, { false } },
-    { "Encode NaN [throw error]",
-      json.encode, { NaN },
-      false, { "Cannot serialise number: must not be NaN or Inf" } },
-    { "Encode Infinity [throw error]",
-      json.encode, { Inf },
-      false, { "Cannot serialise number: must not be NaN or Inf" } },
-    { "Set encode_invalid_numbers(\"null\")",
-      json.encode_invalid_numbers, { "null" }, true, { "null" } },
-    { "Encode NaN as null",
-      json.encode, { NaN }, true, { "null" } },
-    { "Encode Infinity as null",
-      json.encode, { Inf }, true, { "null" } },
-    { "Set encode_invalid_numbers(true)",
-      json.encode_invalid_numbers, { true }, true, { true } },
-    { "Encode NaN",
-      json.encode, { NaN }, true, { "nan" } },
-    { "Encode Infinity",
-      json.encode, { Inf }, true, { "inf" } },
-    { 'Set encode_invalid_numbers("off")',
-      json.encode_invalid_numbers, { "off" }, true, { false } },
-
-    -- Test encoding tables
-    { "Set encode_sparse_array(true, 2, 3)",
-      json.encode_sparse_array, { true, 2, 3 }, true, { true, 2, 3 } },
-    { "Encode sparse table as array #1",
-      json.encode, { { [3] = "sparse test" } },
-      true, { '[null,null,"sparse test"]' } },
-    { "Encode sparse table as array #2",
-      json.encode, { { [1] = "one", [4] = "sparse test" } },
-      true, { '["one",null,null,"sparse test"]' } },
-    { "Encode sparse array as object",
-      json.encode, { { [1] = "one", [5] = "sparse test" } },
-      true, { '{"1":"one","5":"sparse test"}' } },
-    { "Encode table with numeric string key as object",
-      json.encode, { { ["2"] = "numeric string key test" } },
-      true, { '{"2":"numeric string key test"}' } },
-    { "Set encode_sparse_array(false)",
-      json.encode_sparse_array, { false }, true, { false, 2, 3 } },
-    { "Encode table with incompatible key [throw error]",
-      json.encode, { { [false] = "wrong" } },
-      false, { "Cannot serialise boolean: table key must be a number or string" } },
-
-    -- Test escaping
-    { "Encode all octets (8-bit clean)",
-      json.encode, { testdata.octets_raw }, true, { testdata.octets_escaped } },
-    { "Decode all escaped octets",
-      json.decode, { testdata.octets_escaped }, true, { testdata.octets_raw } },
-    { "Decode single UTF-16 escape",
-      json.decode, { [["\uF800"]] }, true, { "\239\160\128" } },
-    { "Decode all UTF-16 escapes (including surrogate combinations)",
-      json.decode, { testdata.utf16_escaped }, true, { testdata.utf8_raw } },
-    { "Decode swapped surrogate pair [throw error]",
-      json.decode, { [["\uDC00\uD800"]] },
-      false, { "Expected value but found invalid unicode escape code at character 2" } },
-    { "Decode duplicate high surrogate [throw error]",
-      json.decode, { [["\uDB00\uDB00"]] },
-      false, { "Expected value but found invalid unicode escape code at character 2" } },
-    { "Decode duplicate low surrogate [throw error]",
-      json.decode, { [["\uDB00\uDB00"]] },
-      false, { "Expected value but found invalid unicode escape code at character 2" } },
-    { "Decode missing low surrogate [throw error]",
-      json.decode, { [["\uDB00"]] },
-      false, { "Expected value but found invalid unicode escape code at character 2" } },
-    { "Decode invalid low surrogate [throw error]",
-      json.decode, { [["\uDB00\uD"]] },
-      false, { "Expected value but found invalid unicode escape code at character 2" } },
-
-    -- Test locale support
-    --
-    -- The standard Lua interpreter is ANSI C online doesn't support locales
-    -- by default. Force a known problematic locale to test strtod()/sprintf().
-    { "Set locale to cs_CZ (comma separator)", function ()
-        os.setlocale("cs_CZ")
-        json.new()
-    end },
-    { "Encode number under comma locale",
-      json.encode, { 1.5 }, true, { '1.5' } },
-    { "Decode number in array under comma locale",
-      json.decode, { '[ 10, "test" ]' }, true, { { 10, "test" } } },
-    { "Revert locale to POSIX", function ()
-        os.setlocale("C")
-        json.new()
-    end },
-
-    -- Test encode_keep_buffer() and enable_number_precision()
-    { "Set encode_keep_buffer(false)",
-      json.encode_keep_buffer, { false }, true, { false } },
-    { "Set encode_number_precision(3)",
-      json.encode_number_precision, { 3 }, true, { 3 } },
-    { "Encode number with precision 3",
-      json.encode, { 1/3 }, true, { "0.333" } },
-    { "Set encode_number_precision(14)",
-      json.encode_number_precision, { 14 }, true, { 14 } },
-    { "Set encode_keep_buffer(true)",
-      json.encode_keep_buffer, { true }, true, { true } },
-
-    -- Test config API errors
-    -- Function is listed as '?' due to pcall
-    { "Set encode_number_precision(0) [throw error]",
-      json.encode_number_precision, { 0 },
-      false, { "bad argument #1 to '?' (expected integer between 1 and 14)" } },
-    { "Set encode_number_precision(\"five\") [throw error]",
-      json.encode_number_precision, { "five" },
-      false, { "bad argument #1 to '?' (number expected, got string)" } },
-    { "Set encode_keep_buffer(nil, true) [throw error]",
-      json.encode_keep_buffer, { nil, true },
-      false, { "bad argument #2 to '?' (found too many arguments)" } },
-    { "Set encode_max_depth(\"wrong\") [throw error]",
-      json.encode_max_depth, { "wrong" },
-      false, { "bad argument #1 to '?' (number expected, got string)" } },
-    { "Set decode_max_depth(0) [throw error]",
-      json.decode_max_depth, { "0" },
-      false, { "bad argument #1 to '?' (expected integer between 1 and 2147483647)" } },
-    { "Set encode_invalid_numbers(-2) [throw error]",
-      json.encode_invalid_numbers, { -2 },
-      false, { "bad argument #1 to '?' (invalid option '-2')" } },
-    { "Set decode_invalid_numbers(true, false) [throw error]",
-      json.decode_invalid_numbers, { true, false },
-      false, { "bad argument #2 to '?' (found too many arguments)" } },
-    { "Set encode_sparse_array(\"not quite on\") [throw error]",
-      json.encode_sparse_array, { "not quite on" },
-      false, { "bad argument #1 to '?' (invalid option 'not quite on')" } },
-
-    { "Reset Lua CJSON configuration", function () json = json.new() end },
-    -- Wrap in a function to ensure the table returned by json.new() is used
-    { "Check encode_sparse_array()",
-      function (...) return json.encode_sparse_array(...) end, { },
-      true, { false, 2, 10 } },
-
-    { "Encode (safe) simple value",
-      json_safe.encode, { true },
-      true, { "true" } },
-    { "Encode (safe) argument validation [throw error]",
-      json_safe.encode, { "arg1", "arg2" },
-      false, { "bad argument #1 to '?' (expected 1 argument)" } },
-    { "Decode (safe) error generation",
-      json_safe.decode, { "Oops" },
-      true, { nil, "Expected value but found invalid token at character 1" } },
-    { "Decode (safe) error generation after new()",
-      function(...) return json_safe.new().decode(...) end, { "Oops" },
-      true, { nil, "Expected value but found invalid token at character 1" } },
-}
-
-print(("==> Testing Lua CJSON version %s\n"):format(json._VERSION))
-
-util.run_test_group(cjson_tests)
-
-for _, filename in ipairs(arg) do
-    util.run_test("Decode cycle " .. filename, test_decode_cycle, { filename },
-                  true, { true })
-end
-
-local pass, total = util.run_test_summary()
-
-if pass == total then
-    print("==> Summary: all tests succeeded")
-else
-    print(("==> Summary: %d/%d tests failed"):format(total - pass, total))
-    os.exit(1)
-end
-
--- vi:ai et sw=4 ts=4:

3rd/lua-cjson/tests/types.json

@@ -1 +0,0 @@
-{ "array": [ 10, true, null ] }

3rd/lua-int64/Makefile

@@ -1,6 +0,0 @@
-install :
-	gcc -g -Wall -fPIC --shared -o int64.so int64.c 
-
-clean :
-	rm int64.so
-

3rd/lua-int64/README

@@ -1,2 +0,0 @@
-See https://github.com/cloudwu/lua-int64
-It will remove when Lua upgrade to 5.3 .

3rd/lua-int64/int64.c

@@ -1,317 +0,0 @@
-#include <lua.h>
-#include <lauxlib.h>
-#include <stdint.h>
-#include <math.h>
-#include <stdlib.h>
-#include <stdbool.h>
-
-static int64_t
-_int64(lua_State *L, int index) {
-	int type = lua_type(L,index);
-	int64_t n = 0;
-	switch(type) {
-	case LUA_TNUMBER: {
-		lua_Number d = lua_tonumber(L,index);
-		n = (int64_t)d;
-		break;
-	}
-	case LUA_TSTRING: {
-		size_t len = 0;
-		const uint8_t * str = (const uint8_t *)lua_tolstring(L, index, &len);
-		if (len>8) {
-			return luaL_error(L, "The string (length = %d) is not an int64 string", len);
-		}
-		int i = 0;
-		uint64_t n64 = 0;
-		for (i=0;i<(int)len;i++) {
-			n64 |= (uint64_t)str[i] << (i*8);
-		}
-		n = (int64_t)n64;
-		break;
-	}
-	case LUA_TLIGHTUSERDATA: {
-		void * p = lua_touserdata(L,index);
-		n = (intptr_t)p;
-		break;
-	}
-	default:
-		return luaL_error(L, "argument %d error type %s", index, lua_typename(L,type));
-	}
-	return n;
-}
-
-static inline void
-_pushint64(lua_State *L, int64_t n) {
-	void * p = (void *)(intptr_t)n;
-	lua_pushlightuserdata(L,p);
-}
-
-static int
-int64_add(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	_pushint64(L, a+b);
-	
-	return 1;
-}
-
-static int
-int64_sub(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	_pushint64(L, a-b);
-	
-	return 1;
-}
-
-static int
-int64_mul(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	_pushint64(L, a * b);
-	
-	return 1;
-}
-
-static int
-int64_div(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	if (b == 0) {
-		return luaL_error(L, "div by zero");
-	}
-	_pushint64(L, a / b);
-	
-	return 1;
-}
-
-static int
-int64_mod(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	if (b == 0) {
-		return luaL_error(L, "mod by zero");
-	}
-	_pushint64(L, a % b);
-	
-	return 1;
-}
-
-static int64_t
-_pow64(int64_t a, int64_t b) {
-	if (b == 1) {
-		return a;
-	}
-	int64_t a2 = a * a;
-	if (b % 2 == 1) {
-		return _pow64(a2, b/2) * a;
-	} else {
-		return _pow64(a2, b/2);
-	}
-}
-
-static int
-int64_pow(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	int64_t p;
-	if (b > 0) {
-		p = _pow64(a,b);
-	} else if (b == 0) {
-		p = 1;
-	} else {
-		return luaL_error(L, "pow by nagtive number %d",(int)b);
-	} 
-	_pushint64(L, p);
-
-	return 1;
-}
-
-static int
-int64_unm(lua_State *L) {
-	int64_t a = _int64(L,1);
-	_pushint64(L, -a);
-	return 1;
-}
-
-static int
-int64_new(lua_State *L) {
-	int top = lua_gettop(L);
-	int64_t n;
-	switch(top) {
-		case 0 : 
-			lua_pushlightuserdata(L,NULL);
-			break;
-		case 1 :
-			n = _int64(L,1);
-			_pushint64(L,n);
-			break;
-		default: {
-			int base = luaL_checkinteger(L,2);
-			if (base < 2) {
-				luaL_error(L, "base must be >= 2");
-			}
-			const char * str = luaL_checkstring(L, 1);
-			n = strtoll(str, NULL, base);
-			_pushint64(L,n);
-			break;
-		}
-	}
-	return 1;
-}
-
-static int
-int64_eq(lua_State *L) {
-	// __eq metamethod can't be invoke by lightuserdata 
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	lua_pushboolean(L,a == b);
-	return 1;
-}
-
-static int
-int64_lt(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	lua_pushboolean(L,a < b);
-	return 1;
-}
-
-static int
-int64_le(lua_State *L) {
-	int64_t a = _int64(L,1);
-	int64_t b = _int64(L,2);
-	lua_pushboolean(L,a <= b);
-	return 1;
-}
-
-static int
-int64_len(lua_State *L) {
-	int64_t a = _int64(L,1);
-	lua_pushnumber(L,(lua_Number)a);
-	return 1;
-}
-
-static int
-tostring(lua_State *L) {
-	static char hex[16] = "0123456789ABCDEF";
-	uintptr_t n = (uintptr_t)lua_touserdata(L,1);
-	if (lua_gettop(L) == 1) {
-		luaL_Buffer b;
-		luaL_buffinit(L , &b);
-		luaL_addstring(&b, "int64: 0x");
-		int i;
-		bool strip = true;
-		for (i=15;i>=0;i--) {
-			int c = (n >> (i*4)) & 0xf;
-			if (strip && c ==0) {
-				continue;
-			}
-			strip = false;
-			luaL_addchar(&b, hex[c]);
-		}
-		if (strip) {
-			luaL_addchar(&b , '0');
-		}
-		luaL_pushresult(&b);
-	} else {
-		int base = luaL_checkinteger(L,2);
-		int shift =0, mask =0;
-		switch(base) {
-		case 0: {
-			unsigned char buffer[8];
-			int i;
-			for (i=0;i<8;i++) {
-				buffer[i] = (n >> (i*8)) & 0xff;
-			}
-			lua_pushlstring(L,(const char *)buffer, 8);
-			return 1;
-			}
-		case 10: {
-			int64_t dec = (int64_t)n;
-			luaL_Buffer b;
-			luaL_buffinit(L , &b);
-			if (dec<0) {
-				luaL_addchar(&b, '-');
-				dec = -dec;
-			}
-			int buffer[32];
-			int i;
-			for (i=0;i<32;i++) {
-				buffer[i] = dec%10;
-				dec /= 10;
-				if (dec == 0)
-					break;
-			}
-			while (i>=0) {
-				luaL_addchar(&b, hex[buffer[i]]);
-				--i;
-			}
-			luaL_pushresult(&b);
-			return 1;
-		}
-		case 2:
-			shift = 1;
-			mask = 1;
-			break;
-		case 8:
-			shift = 3;
-			mask = 7;
-			break;
-		case 16:
-			shift = 4;
-			mask = 0xf;
-			break;
-		default:
-			luaL_error(L, "Unsupport base %d",base);
-			break;
-		}
-		int i;
-		char buffer[64];
-		for (i=0;i<64;i+=shift) {
-			buffer[i/shift] = hex[(n>>(64-shift-i)) & mask];
-		}
-		lua_pushlstring(L, buffer, 64 / shift);
-	}
-	return 1;
-}
-
-static void
-make_mt(lua_State *L) {
-	luaL_Reg lib[] = {
-		{ "__add", int64_add },
-		{ "__sub", int64_sub },
-		{ "__mul", int64_mul },
-		{ "__div", int64_div },
-		{ "__mod", int64_mod },
-		{ "__unm", int64_unm },
-		{ "__pow", int64_pow },
-		{ "__eq", int64_eq },
-		{ "__lt", int64_lt },
-		{ "__le", int64_le },
-		{ "__len", int64_len },
-		{ "__tostring", tostring },
-		{ NULL, NULL },
-	};
-	luaL_newlib(L,lib);
-}
-
-int
-luaopen_int64(lua_State *L) {
-	if (sizeof(intptr_t)!=sizeof(int64_t)) {
-		return luaL_error(L, "Only support 64bit architecture");
-	}
-	lua_pushlightuserdata(L,NULL);
-	make_mt(L);
-	lua_setmetatable(L,-2);
-	lua_pop(L,1);
-
-	lua_newtable(L);
-	lua_pushcfunction(L, int64_new);
-	lua_setfield(L, -2, "new");
-	lua_pushcfunction(L, tostring);
-	lua_setfield(L, -2, "tostring");
-
-	return 1;
-}
-

3rd/lua-int64/test.lua

@@ -1,17 +0,0 @@
-lib = require "int64"
-
-local int64 = lib.new
-print(lib.tostring(int64 "\1\2\3\4\5\6\7\8"))
-
-a = 1 + int64(1)
-b = int64 "\16" + int64("9",10)
-print(lib.tostring(a,10), lib.tostring(b,2))
-print("+", a+b)
-print("-", lib.tostring(a-b,10))
-print("*", a*b)
-print("/", a/b)
-print("%", a%b)
-print("^", a^b)
-print("==", a == b)
-print(">", a > b)
-print("#", #a)

3rd/lua/Makefile

@@ -1,187 +0,0 @@
-# Makefile for building Lua
-# See ../doc/readme.html for installation and customization instructions.
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= none
-
-CC= gcc
-CFLAGS= -O2 -Wall -DLUA_COMPAT_ALL $(SYSCFLAGS) $(MYCFLAGS)
-LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
-LIBS= -lm $(SYSLIBS) $(MYLIBS)
-
-AR= ar rcu
-RANLIB= ranlib
-RM= rm -f
-
-SYSCFLAGS=
-SYSLDFLAGS=
-SYSLIBS=
-
-MYCFLAGS=
-MYLDFLAGS=
-MYLIBS=
-MYOBJS=
-
-# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
-
-PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
-
-LUA_A=	liblua.a
-CORE_O=	lapi.o lcode.o lctype.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o \
-	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
-BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
-
-LUA_T=	lua
-LUA_O=	lua.o
-
-LUAC_T=	luac
-LUAC_O=	luac.o
-
-ALL_O= $(BASE_O) $(LUA_O) $(LUAC_O)
-ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
-ALL_A= $(LUA_A)
-
-# Targets start here.
-default: $(PLAT)
-
-all:	$(ALL_T)
-
-o:	$(ALL_O)
-
-a:	$(ALL_A)
-
-$(LUA_A): $(BASE_O)
-	$(AR) $@ $(BASE_O)
-	$(RANLIB) $@
-
-$(LUA_T): $(LUA_O) $(LUA_A)
-	$(CC) -o $@ $(LDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
-
-$(LUAC_T): $(LUAC_O) $(LUA_A)
-	$(CC) -o $@ $(LDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
-
-clean:
-	$(RM) $(ALL_T) $(ALL_O)
-
-depend:
-	@$(CC) $(CFLAGS) -MM l*.c
-
-echo:
-	@echo "PLAT= $(PLAT)"
-	@echo "CC= $(CC)"
-	@echo "CFLAGS= $(CFLAGS)"
-	@echo "LDFLAGS= $(SYSLDFLAGS)"
-	@echo "LIBS= $(LIBS)"
-	@echo "AR= $(AR)"
-	@echo "RANLIB= $(RANLIB)"
-	@echo "RM= $(RM)"
-
-# Convenience targets for popular platforms
-ALL= all
-
-none:
-	@echo "Please do 'make PLATFORM' where PLATFORM is one of these:"
-	@echo "   $(PLATS)"
-
-aix:
-	$(MAKE) $(ALL) CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl" SYSLDFLAGS="-brtl -bexpall"
-
-ansi:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_ANSI"
-
-bsd:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-Wl,-E"
-
-freebsd:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -lreadline"
-
-generic: $(ALL)
-
-linux:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl -lreadline"
-
-macosx:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline" CC=cc
-
-mingw:
-	$(MAKE) "LUA_A=lua52.dll" "LUA_T=lua.exe" \
-	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
-	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
-	$(MAKE) "LUAC_T=luac.exe" luac.exe
-
-posix:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"
-
-solaris:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl"
-
-# list targets that do not create files (but not all makes understand .PHONY)
-.PHONY: all $(PLATS) default o a clean depend echo none
-
-# DO NOT DELETE
-
-lapi.o: lapi.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 lstring.h ltable.h lundump.h \
- lvm.h
-lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
-lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h
-lbitlib.o: lbitlib.c lua.h luaconf.h lauxlib.h lualib.h
-lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
- lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
- lstring.h ltable.h lvm.h
-lcorolib.o: lcorolib.c lua.h luaconf.h lauxlib.h lualib.h
-lctype.o: lctype.c lctype.h lua.h luaconf.h llimits.h
-ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
-ldebug.o: ldebug.c lua.h luaconf.h lapi.h llimits.h lstate.h lobject.h \
- ltm.h lzio.h lmem.h lcode.h llex.h lopcodes.h lparser.h ldebug.h ldo.h \
- lfunc.h lstring.h lgc.h ltable.h lvm.h
-ldo.o: ldo.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 lopcodes.h lparser.h \
- lstring.h ltable.h lundump.h lvm.h
-ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
- lzio.h lmem.h lundump.h
-lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h \
- lstate.h ltm.h lzio.h lmem.h
-lgc.o: lgc.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 lstring.h ltable.h
-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
-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
-loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h
-lobject.o: lobject.c lua.h luaconf.h lctype.h llimits.h ldebug.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h lvm.h
-lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
-loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
-lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
- lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lfunc.h \
- lstring.h lgc.h ltable.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 \
- ltm.h lzio.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
-ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
-ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
- lmem.h lstring.h lgc.h ltable.h
-lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h
-luac.o: luac.c lua.h luaconf.h lauxlib.h lobject.h llimits.h lstate.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
-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 \
- lzio.h
-

3rd/lua/README

@@ -1,3 +1,6 @@
-This is a modify version of lua 5.2.3 (http://www.lua.org/ftp/lua-5.2.3.tar.gz) .
+This is a modify version of lua 5.4.3 .
 
-For detail : http://lua-users.org/lists/lua-l/2014-03/msg00489.html
+For detail ,
+  Shared Proto : http://lua-users.org/lists/lua-l/2014-03/msg00489.html
+  Shared short string table : http://blog.codingnow.com/2015/08/lua_vm_share_string.html
+  Signal for debug use : http://blog.codingnow.com/2015/03/skynet_signal.html

3rd/lua/README.md

@@ -0,0 +1,7 @@
+# Lua
+
+This is the repository of Lua development code, as seen by the Lua team. It contains the full history of all commits but is mirrored irregularly. For complete information about Lua, visit [Lua.org](https://www.lua.org/).
+
+Please **do not** send pull requests. To report issues, post a message to the [Lua mailing list](https://www.lua.org/lua-l.html).
+
+Download official Lua releases from [Lua.org](https://www.lua.org/download.html).

3rd/lua/lapi.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lapi.h $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */
@@ -11,14 +11,42 @@
 #include "llimits.h"
 #include "lstate.h"
 
-#define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \
-				"stack overflow");}
 
+/* Increments 'L->top.p', checking for stack overflows */
+#define api_incr_top(L)	{L->top.p++; \
+			 api_check(L, L->top.p <= L->ci->top.p, \
+					"stack overflow");}
+
+
+/*
+** If a call returns too many multiple returns, the callee may not have
+** stack space to accommodate all results. In this case, this macro
+** increases its stack space ('L->ci->top.p').
+*/
 #define adjustresults(L,nres) \
-    { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
+    { if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \
+	L->ci->top.p = L->top.p; }
 
-#define api_checknelems(L,n)	api_check(L, (n) < (L->top - L->ci->func), \
-				  "not enough elements in the stack")
 
+/* Ensure the stack has at least 'n' elements */
+#define api_checknelems(L,n) \
+	api_check(L, (n) < (L->top.p - L->ci->func.p), \
+			  "not enough elements in the stack")
+
+
+/*
+** To reduce the overhead of returning from C functions, the presence of
+** to-be-closed variables in these functions is coded in the CallInfo's
+** field 'nresults', in a way that functions with no to-be-closed variables
+** with zero, one, or "all" wanted results have no overhead. Functions
+** with other number of wanted results, as well as functions with
+** variables to be closed, have an extra check.
+*/
+
+#define hastocloseCfunc(n)	((n) < LUA_MULTRET)
+
+/* Map [-1, inf) (range of 'nresults') into (-inf, -2] */
+#define codeNresults(n)		(-(n) - 3)
+#define decodeNresults(n)	(-(n) - 3)
 
 #endif

3rd/lua/lauxlib.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lauxlib.h $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -12,44 +12,60 @@
 #include <stddef.h>
 #include <stdio.h>
 
+#include "luaconf.h"
 #include "lua.h"
 
 
+/* global table */
+#define LUA_GNAME	"_G"
 
-/* extra error code for `luaL_load' */
+
+typedef struct luaL_Buffer luaL_Buffer;
+
+
+/* extra error code for 'luaL_loadfilex' */
 #define LUA_ERRFILE     (LUA_ERRERR+1)
 
 
+/* key, in the registry, for table of loaded modules */
+#define LUA_LOADED_TABLE	"_LOADED"
+
+
+/* key, in the registry, for table of preloaded loaders */
+#define LUA_PRELOAD_TABLE	"_PRELOAD"
+
+
 typedef struct luaL_Reg {
   const char *name;
   lua_CFunction func;
 } luaL_Reg;
 
 
-LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
-#define luaL_checkversion(L)	luaL_checkversion_(L, LUA_VERSION_NUM)
+#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
+#define luaL_checkversion(L)  \
+	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
 
 LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
 LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
 LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
-LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
-LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
+LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
                                                           size_t *l);
-LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
                                           const char *def, size_t *l);
-LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
-LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
 
-LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
-LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
                                           lua_Integer def);
-LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);
-LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,
-                                            lua_Unsigned def);
 
 LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
-LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
-LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
 
 LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
 LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
@@ -59,13 +75,14 @@ LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
 LUALIB_API void (luaL_where) (lua_State *L, int lvl);
 LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
 
-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[]);
 
 LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
 LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
 
-/* pre-defined references */
+
+/* predefined references */
 #define LUA_NOREF       (-2)
 #define LUA_REFNIL      (-1)
 
@@ -74,6 +91,8 @@ LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
 
 LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
                                                const char *mode);
+LUALIB_API int (luaL_loadfilex_) (lua_State *L, const char *filename,
+                                               const char *mode);
 
 #define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
 
@@ -83,10 +102,12 @@ LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
 
 LUALIB_API lua_State *(luaL_newstate) (void);
 
-LUALIB_API int (luaL_len) (lua_State *L, int idx);
+LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
 
-LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
-                                                  const char *r);
+LUALIB_API void (luaL_addgsub) (luaL_Buffer *b, const char *s,
+                                     const char *p, const char *r);
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s,
+                                    const char *p, const char *r);
 
 LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
 
@@ -108,16 +129,17 @@ LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
 #define luaL_newlibtable(L,l)	\
   lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
 
-#define luaL_newlib(L,l)	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+#define luaL_newlib(L,l)  \
+  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,arg,extramsg)	\
+	((void)(luai_likely(cond) || luaL_argerror(L, (arg), (extramsg))))
+
+#define luaL_argexpected(L,cond,arg,tname)	\
+	((void)(luai_likely(cond) || luaL_typeerror(L, (arg), (tname))))
 
-#define luaL_argcheck(L, cond,numarg,extramsg)	\
-		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
 #define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
 #define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
-#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
-#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
-#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
-#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
 
 #define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
 
@@ -134,19 +156,54 @@ LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
 #define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
 
 
+/*
+** Perform arithmetic operations on lua_Integer values with wrap-around
+** semantics, as the Lua core does.
+*/
+#define luaL_intop(op,v1,v2)  \
+	((lua_Integer)((lua_Unsigned)(v1) op (lua_Unsigned)(v2)))
+
+
+/* push the value used to represent failure/error */
+#define luaL_pushfail(L)	lua_pushnil(L)
+
+
+/*
+** Internal assertions for in-house debugging
+*/
+#if !defined(lua_assert)
+
+#if defined LUAI_ASSERT
+  #include <assert.h>
+  #define lua_assert(c)		assert(c)
+#else
+  #define lua_assert(c)		((void)0)
+#endif
+
+#endif
+
+
+
 /*
 ** {======================================================
 ** Generic Buffer manipulation
 ** =======================================================
 */
 
-typedef struct luaL_Buffer {
+struct luaL_Buffer {
   char *b;  /* buffer address */
   size_t size;  /* buffer size */
   size_t n;  /* number of characters in buffer */
   lua_State *L;
-  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
-} luaL_Buffer;
+  union {
+    LUAI_MAXALIGN;  /* ensure maximum alignment for buffer */
+    char b[LUAL_BUFFERSIZE];  /* initial buffer */
+  } init;
+};
+
+
+#define luaL_bufflen(bf)	((bf)->n)
+#define luaL_buffaddr(bf)	((bf)->b)
 
 
 #define luaL_addchar(B,c) \
@@ -155,6 +212,8 @@ typedef struct luaL_Buffer {
 
 #define luaL_addsize(B,s)	((B)->n += (s))
 
+#define luaL_buffsub(B,s)	((B)->n -= (s))
+
 LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
 LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
 LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
@@ -192,19 +251,51 @@ typedef struct luaL_Stream {
 
 /* }====================================================== */
 
+/*
+** {==================================================================
+** "Abstraction Layer" for basic report of messages and errors
+** ===================================================================
+*/
+
+/* print a string */
+#if !defined(lua_writestring)
+#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
+#endif
+
+/* print a newline and flush the output */
+#if !defined(lua_writeline)
+#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
+#endif
+
+/* print an error message */
+#if !defined(lua_writestringerror)
+#define lua_writestringerror(s,p) \
+        (fprintf(stderr, (s), (p)), fflush(stderr))
+#endif
+
+/* }================================================================== */
 
 
-/* compatibility with old module system */
-#if defined(LUA_COMPAT_MODULE)
+/*
+** {============================================================
+** Compatibility with deprecated conversions
+** =============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
 
-LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
-                                   int sizehint);
-LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
-                                const luaL_Reg *l, int nup);
+#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
+#define luaL_optunsigned(L,a,d)	\
+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
 
-#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
 
 #endif
+/* }============================================================ */
+
 
 
 #endif

3rd/lua/lbaselib.c

@@ -1,9 +1,13 @@
 /*
-** $Id: lbaselib.c,v 1.276.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lbaselib.c $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
 
+#define lbaselib_c
+#define LUA_LIB
+
+#include "lprefix.h"
 
 
 #include <ctype.h>
@@ -11,9 +15,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define lbaselib_c
-#define LUA_LIB
-
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -23,74 +24,98 @@
 static int luaB_print (lua_State *L) {
   int n = lua_gettop(L);  /* number of arguments */
   int i;
-  lua_getglobal(L, "tostring");
-  for (i=1; i<=n; i++) {
-    const char *s;
+  for (i = 1; i <= n; i++) {  /* for each argument */
     size_t l;
-    lua_pushvalue(L, -1);  /* function to be called */
-    lua_pushvalue(L, i);   /* value to print */
-    lua_call(L, 1, 1);
-    s = lua_tolstring(L, -1, &l);  /* get result */
-    if (s == NULL)
-      return luaL_error(L,
-         LUA_QL("tostring") " must return a string to " LUA_QL("print"));
-    if (i>1) luai_writestring("\t", 1);
-    luai_writestring(s, l);
+    const char *s = luaL_tolstring(L, i, &l);  /* convert it to string */
+    if (i > 1)  /* not the first element? */
+      lua_writestring("\t", 1);  /* add a tab before it */
+    lua_writestring(s, l);  /* print it */
     lua_pop(L, 1);  /* pop result */
   }
-  luai_writeline();
+  lua_writeline();
+  return 0;
+}
+
+
+/*
+** Creates a warning with all given arguments.
+** Check first for errors; otherwise an error may interrupt
+** the composition of a warning, leaving it unfinished.
+*/
+static int luaB_warn (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int i;
+  luaL_checkstring(L, 1);  /* at least one argument */
+  for (i = 2; i <= n; i++)
+    luaL_checkstring(L, i);  /* make sure all arguments are strings */
+  for (i = 1; i < n; i++)  /* compose warning */
+    lua_warning(L, lua_tostring(L, i), 1);
+  lua_warning(L, lua_tostring(L, n), 0);  /* close warning */
   return 0;
 }
 
 
 #define SPACECHARS	" \f\n\r\t\v"
 
+static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
+  lua_Unsigned n = 0;
+  int neg = 0;
+  s += strspn(s, SPACECHARS);  /* skip initial spaces */
+  if (*s == '-') { s++; neg = 1; }  /* handle sign */
+  else if (*s == '+') s++;
+  if (!isalnum((unsigned char)*s))  /* no digit? */
+    return NULL;
+  do {
+    int digit = (isdigit((unsigned char)*s)) ? *s - '0'
+                   : (toupper((unsigned char)*s) - 'A') + 10;
+    if (digit >= base) return NULL;  /* invalid numeral */
+    n = n * base + digit;
+    s++;
+  } while (isalnum((unsigned char)*s));
+  s += strspn(s, SPACECHARS);  /* skip trailing spaces */
+  *pn = (lua_Integer)((neg) ? (0u - n) : n);
+  return s;
+}
+
+
 static int luaB_tonumber (lua_State *L) {
-  if (lua_isnoneornil(L, 2)) {  /* standard conversion */
-    int isnum;
-    lua_Number n = lua_tonumberx(L, 1, &isnum);
-    if (isnum) {
-      lua_pushnumber(L, n);
+  if (lua_isnoneornil(L, 2)) {  /* standard conversion? */
+    if (lua_type(L, 1) == LUA_TNUMBER) {  /* already a number? */
+      lua_settop(L, 1);  /* yes; return it */
       return 1;
-    }  /* else not a number; must be something */
-    luaL_checkany(L, 1);
+    }
+    else {
+      size_t l;
+      const char *s = lua_tolstring(L, 1, &l);
+      if (s != NULL && lua_stringtonumber(L, s) == l + 1)
+        return 1;  /* successful conversion to number */
+      /* else not a number */
+      luaL_checkany(L, 1);  /* (but there must be some parameter) */
+    }
   }
   else {
     size_t l;
-    const char *s = luaL_checklstring(L, 1, &l);
-    const char *e = s + l;  /* end point for 's' */
-    int base = luaL_checkint(L, 2);
-    int neg = 0;
+    const char *s;
+    lua_Integer n = 0;  /* to avoid warnings */
+    lua_Integer base = luaL_checkinteger(L, 2);
+    luaL_checktype(L, 1, LUA_TSTRING);  /* no numbers as strings */
+    s = lua_tolstring(L, 1, &l);
     luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    s += strspn(s, SPACECHARS);  /* skip initial spaces */
-    if (*s == '-') { s++; neg = 1; }  /* handle signal */
-    else if (*s == '+') s++;
-    if (isalnum((unsigned char)*s)) {
-      lua_Number n = 0;
-      do {
-        int digit = (isdigit((unsigned char)*s)) ? *s - '0'
-                       : toupper((unsigned char)*s) - 'A' + 10;
-        if (digit >= base) break;  /* invalid numeral; force a fail */
-        n = n * (lua_Number)base + (lua_Number)digit;
-        s++;
-      } while (isalnum((unsigned char)*s));
-      s += strspn(s, SPACECHARS);  /* skip trailing spaces */
-      if (s == e) {  /* no invalid trailing characters? */
-        lua_pushnumber(L, (neg) ? -n : n);
-        return 1;
-      }  /* else not a number */
+    if (b_str2int(s, (int)base, &n) == s + l) {
+      lua_pushinteger(L, n);
+      return 1;
     }  /* else not a number */
-  }
-  lua_pushnil(L);  /* not a number */
+  }  /* else not a number */
+  luaL_pushfail(L);  /* not a number */
   return 1;
 }
 
 
 static int luaB_error (lua_State *L) {
-  int level = luaL_optint(L, 2, 1);
+  int level = (int)luaL_optinteger(L, 2, 1);
   lua_settop(L, 1);
-  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
-    luaL_where(L, level);
+  if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
+    luaL_where(L, level);   /* add extra information */
     lua_pushvalue(L, 1);
     lua_concat(L, 2);
   }
@@ -112,9 +137,8 @@ static int luaB_getmetatable (lua_State *L) {
 static int luaB_setmetatable (lua_State *L) {
   int t = lua_type(L, 2);
   luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
-                    "nil or table expected");
-  if (luaL_getmetafield(L, 1, "__metatable"))
+  luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
+  if (l_unlikely(luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL))
     return luaL_error(L, "cannot change a protected metatable");
   lua_settop(L, 2);
   lua_setmetatable(L, 1);
@@ -132,8 +156,8 @@ static int luaB_rawequal (lua_State *L) {
 
 static int luaB_rawlen (lua_State *L) {
   int t = lua_type(L, 1);
-  luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
-                   "table or string expected");
+  luaL_argexpected(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
+                      "table or string");
   lua_pushinteger(L, lua_rawlen(L, 1));
   return 1;
 }
@@ -157,56 +181,86 @@ static int luaB_rawset (lua_State *L) {
 }
 
 
-static int luaB_collectgarbage (lua_State *L) {
-  static const char *const opts[] = {"stop", "restart", "collect",
-    "count", "step", "setpause", "setstepmul",
-    "setmajorinc", "isrunning", "generational", "incremental", 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};
-  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_pushinteger(L, b);
-      return 2;
-    }
-    case LUA_GCSTEP: case LUA_GCISRUNNING: {
-      lua_pushboolean(L, res);
-      return 1;
-    }
-    default: {
-      lua_pushinteger(L, res);
-      return 1;
-    }
-  }
-}
-
-
-static int luaB_type (lua_State *L) {
-  luaL_checkany(L, 1);
-  lua_pushstring(L, luaL_typename(L, 1));
+static int pushmode (lua_State *L, int oldmode) {
+  if (oldmode == -1)
+    luaL_pushfail(L);  /* invalid call to 'lua_gc' */
+  else
+    lua_pushstring(L, (oldmode == LUA_GCINC) ? "incremental"
+                                             : "generational");
   return 1;
 }
 
 
-static int pairsmeta (lua_State *L, const char *method, int iszero,
-                      lua_CFunction iter) {
-  if (!luaL_getmetafield(L, 1, method)) {  /* no metamethod? */
-    luaL_checktype(L, 1, LUA_TTABLE);  /* argument must be a table */
-    lua_pushcfunction(L, iter);  /* will return generator, */
-    lua_pushvalue(L, 1);  /* state, */
-    if (iszero) lua_pushinteger(L, 0);  /* and initial value */
-    else lua_pushnil(L);
+/*
+** check whether call to 'lua_gc' was valid (not inside a finalizer)
+*/
+#define checkvalres(res) { if (res == -1) break; }
+
+static int luaB_collectgarbage (lua_State *L) {
+  static const char *const opts[] = {"stop", "restart", "collect",
+    "count", "step", "setpause", "setstepmul",
+    "isrunning", "generational", "incremental", NULL};
+  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
+    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
+    LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
+  int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
+  switch (o) {
+    case LUA_GCCOUNT: {
+      int k = lua_gc(L, o);
+      int b = lua_gc(L, LUA_GCCOUNTB);
+      checkvalres(k);
+      lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024));
+      return 1;
+    }
+    case LUA_GCSTEP: {
+      int step = (int)luaL_optinteger(L, 2, 0);
+      int res = lua_gc(L, o, step);
+      checkvalres(res);
+      lua_pushboolean(L, res);
+      return 1;
+    }
+    case LUA_GCSETPAUSE:
+    case LUA_GCSETSTEPMUL: {
+      int p = (int)luaL_optinteger(L, 2, 0);
+      int previous = lua_gc(L, o, p);
+      checkvalres(previous);
+      lua_pushinteger(L, previous);
+      return 1;
+    }
+    case LUA_GCISRUNNING: {
+      int res = lua_gc(L, o);
+      checkvalres(res);
+      lua_pushboolean(L, res);
+      return 1;
+    }
+    case LUA_GCGEN: {
+      int minormul = (int)luaL_optinteger(L, 2, 0);
+      int majormul = (int)luaL_optinteger(L, 3, 0);
+      return pushmode(L, lua_gc(L, o, minormul, majormul));
+    }
+    case LUA_GCINC: {
+      int pause = (int)luaL_optinteger(L, 2, 0);
+      int stepmul = (int)luaL_optinteger(L, 3, 0);
+      int stepsize = (int)luaL_optinteger(L, 4, 0);
+      return pushmode(L, lua_gc(L, o, pause, stepmul, stepsize));
+    }
+    default: {
+      int res = lua_gc(L, o);
+      checkvalres(res);
+      lua_pushinteger(L, res);
+      return 1;
+    }
   }
-  else {
-    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
-    lua_call(L, 1, 3);  /* get 3 values from metamethod */
-  }
-  return 3;
+  luaL_pushfail(L);  /* invalid call (inside a finalizer) */
+  return 1;
+}
+
+
+static int luaB_type (lua_State *L) {
+  int t = lua_type(L, 1);
+  luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
+  lua_pushstring(L, lua_typename(L, t));
+  return 1;
 }
 
 
@@ -222,28 +276,52 @@ static int luaB_next (lua_State *L) {
 }
 
 
+static int pairscont (lua_State *L, int status, lua_KContext k) {
+  (void)L; (void)status; (void)k;  /* unused */
+  return 3;
+}
+
 static int luaB_pairs (lua_State *L) {
-  return pairsmeta(L, "__pairs", 0, luaB_next);
+  luaL_checkany(L, 1);
+  if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) {  /* no metamethod? */
+    lua_pushcfunction(L, luaB_next);  /* will return generator, */
+    lua_pushvalue(L, 1);  /* state, */
+    lua_pushnil(L);  /* and initial value */
+  }
+  else {
+    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
+    lua_callk(L, 1, 3, 0, pairscont);  /* get 3 values from metamethod */
+  }
+  return 3;
 }
 
 
+/*
+** Traversal function for 'ipairs'
+*/
 static int ipairsaux (lua_State *L) {
-  int i = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  i++;  /* next value */
+  lua_Integer i = luaL_checkinteger(L, 2);
+  i = luaL_intop(+, i, 1);
   lua_pushinteger(L, i);
-  lua_rawgeti(L, 1, i);
-  return (lua_isnil(L, -1)) ? 1 : 2;
+  return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;
 }
 
 
+/*
+** 'ipairs' function. Returns 'ipairsaux', given "table", 0.
+** (The given "table" may not be a table.)
+*/
 static int luaB_ipairs (lua_State *L) {
-  return pairsmeta(L, "__ipairs", 1, ipairsaux);
+  luaL_checkany(L, 1);
+  lua_pushcfunction(L, ipairsaux);  /* iteration function */
+  lua_pushvalue(L, 1);  /* state */
+  lua_pushinteger(L, 0);  /* initial value */
+  return 3;
 }
 
 
 static int load_aux (lua_State *L, int status, int envidx) {
-  if (status == LUA_OK) {
+  if (l_likely(status == LUA_OK)) {
     if (envidx != 0) {  /* 'env' parameter? */
       lua_pushvalue(L, envidx);  /* environment for loaded function */
       if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */
@@ -252,9 +330,9 @@ static int load_aux (lua_State *L, int status, int envidx) {
     return 1;
   }
   else {  /* error (message is on top of the stack) */
-    lua_pushnil(L);
+    luaL_pushfail(L);
     lua_insert(L, -2);  /* put before error message */
-    return 2;  /* return nil plus error message */
+    return 2;  /* return fail plus error message */
   }
 }
 
@@ -284,7 +362,7 @@ static int luaB_loadfile (lua_State *L) {
 
 
 /*
-** Reader for generic `load' function: `lua_load' uses the
+** Reader for generic 'load' function: 'lua_load' uses the
 ** stack for internal stuff, so the reader cannot change the
 ** stack top. Instead, it keeps its resulting string in a
 ** reserved slot inside the stack.
@@ -299,7 +377,7 @@ static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
     *size = 0;
     return NULL;
   }
-  else if (!lua_isstring(L, -1))
+  else if (l_unlikely(!lua_isstring(L, -1)))
     luaL_error(L, "reader function must return a string");
   lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */
   return lua_tolstring(L, RESERVEDSLOT, size);
@@ -328,7 +406,8 @@ static int luaB_load (lua_State *L) {
 /* }====================================================== */
 
 
-static int dofilecont (lua_State *L) {
+static int dofilecont (lua_State *L, int d1, lua_KContext d2) {
+  (void)d1;  (void)d2;  /* only to match 'lua_Kfunction' prototype */
   return lua_gettop(L) - 1;
 }
 
@@ -336,17 +415,23 @@ static int dofilecont (lua_State *L) {
 static int luaB_dofile (lua_State *L) {
   const char *fname = luaL_optstring(L, 1, NULL);
   lua_settop(L, 1);
-  if (luaL_loadfile(L, fname) != LUA_OK)
+  if (l_unlikely(luaL_loadfile(L, fname) != LUA_OK))
     return lua_error(L);
   lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
-  return dofilecont(L);
+  return dofilecont(L, 0, 0);
 }
 
 
 static int luaB_assert (lua_State *L) {
-  if (!lua_toboolean(L, 1))
-    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
-  return lua_gettop(L);
+  if (l_likely(lua_toboolean(L, 1)))  /* condition is true? */
+    return lua_gettop(L);  /* return all arguments */
+  else {  /* error */
+    luaL_checkany(L, 1);  /* there must be a condition */
+    lua_remove(L, 1);  /* remove it */
+    lua_pushliteral(L, "assertion failed!");  /* default message */
+    lua_settop(L, 1);  /* leave only message (default if no other one) */
+    return luaB_error(L);  /* call 'error' */
+  }
 }
 
 
@@ -357,53 +442,57 @@ static int luaB_select (lua_State *L) {
     return 1;
   }
   else {
-    int i = luaL_checkint(L, 1);
+    lua_Integer i = luaL_checkinteger(L, 1);
     if (i < 0) i = n + i;
     else if (i > n) i = n;
     luaL_argcheck(L, 1 <= i, 1, "index out of range");
-    return n - i;
+    return n - (int)i;
   }
 }
 
 
-static int finishpcall (lua_State *L, int status) {
-  if (!lua_checkstack(L, 1)) {  /* no space for extra boolean? */
-    lua_settop(L, 0);  /* create space for return values */
-    lua_pushboolean(L, 0);
-    lua_pushstring(L, "stack overflow");
+/*
+** Continuation function for 'pcall' and 'xpcall'. Both functions
+** already pushed a 'true' before doing the call, so in case of success
+** 'finishpcall' only has to return everything in the stack minus
+** 'extra' values (where 'extra' is exactly the number of items to be
+** ignored).
+*/
+static int finishpcall (lua_State *L, int status, lua_KContext extra) {
+  if (l_unlikely(status != LUA_OK && status != LUA_YIELD)) {  /* error? */
+    lua_pushboolean(L, 0);  /* first result (false) */
+    lua_pushvalue(L, -2);  /* error message */
     return 2;  /* return false, msg */
   }
-  lua_pushboolean(L, status);  /* first result (status) */
-  lua_replace(L, 1);  /* put first result in first slot */
-  return lua_gettop(L);
-}
-
-
-static int pcallcont (lua_State *L) {
-  int status = lua_getctx(L, NULL);
-  return finishpcall(L, (status == LUA_YIELD));
+  else
+    return lua_gettop(L) - (int)extra;  /* return all results */
 }
 
 
 static int luaB_pcall (lua_State *L) {
   int status;
   luaL_checkany(L, 1);
-  lua_pushnil(L);
-  lua_insert(L, 1);  /* create space for status result */
-  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, pcallcont);
-  return finishpcall(L, (status == LUA_OK));
+  lua_pushboolean(L, 1);  /* first result if no errors */
+  lua_insert(L, 1);  /* put it in place */
+  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
+  return finishpcall(L, status, 0);
 }
 
 
+/*
+** Do a protected call with error handling. After 'lua_rotate', the
+** stack will have <f, err, true, f, [args...]>; so, the function passes
+** 2 to 'finishpcall' to skip the 2 first values when returning results.
+*/
 static int luaB_xpcall (lua_State *L) {
   int status;
   int n = lua_gettop(L);
-  luaL_argcheck(L, n >= 2, 2, "value expected");
-  lua_pushvalue(L, 1);  /* exchange function... */
-  lua_copy(L, 2, 1);  /* ...and error handler */
-  lua_replace(L, 2);
-  status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 0, pcallcont);
-  return finishpcall(L, (status == LUA_OK));
+  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
+  lua_pushboolean(L, 1);  /* first result */
+  lua_pushvalue(L, 1);  /* function */
+  lua_rotate(L, 3, 2);  /* move them below function's arguments */
+  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
+  return finishpcall(L, status, 2);
 }
 
 
@@ -423,13 +512,11 @@ static const luaL_Reg base_funcs[] = {
   {"ipairs", luaB_ipairs},
   {"loadfile", luaB_loadfile},
   {"load", luaB_load},
-#if defined(LUA_COMPAT_LOADSTRING)
-  {"loadstring", luaB_load},
-#endif
   {"next", luaB_next},
   {"pairs", luaB_pairs},
   {"pcall", luaB_pcall},
   {"print", luaB_print},
+  {"warn", luaB_warn},
   {"rawequal", luaB_rawequal},
   {"rawlen", luaB_rawlen},
   {"rawget", luaB_rawget},
@@ -440,19 +527,23 @@ static const luaL_Reg base_funcs[] = {
   {"tostring", luaB_tostring},
   {"type", luaB_type},
   {"xpcall", luaB_xpcall},
+  /* placeholders */
+  {LUA_GNAME, NULL},
+  {"_VERSION", NULL},
   {NULL, NULL}
 };
 
 
 LUAMOD_API int luaopen_base (lua_State *L) {
-  /* set global _G */
-  lua_pushglobaltable(L);
-  lua_pushglobaltable(L);
-  lua_setfield(L, -2, "_G");
   /* open lib into global table */
+  lua_pushglobaltable(L);
   luaL_setfuncs(L, base_funcs, 0);
+  /* set global _G */
+  lua_pushvalue(L, -1);
+  lua_setfield(L, -2, LUA_GNAME);
+  /* set global _VERSION */
   lua_pushliteral(L, LUA_VERSION);
-  lua_setfield(L, -2, "_VERSION");  /* set global _VERSION */
+  lua_setfield(L, -2, "_VERSION");
   return 1;
 }
 

3rd/lua/lbitlib.c

@@ -1,212 +0,0 @@
-/*
-** $Id: lbitlib.c,v 1.18.1.2 2013/07/09 18:01:41 roberto Exp $
-** Standard library for bitwise operations
-** See Copyright Notice in lua.h
-*/
-
-#define lbitlib_c
-#define LUA_LIB
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/* number of bits to consider in a number */
-#if !defined(LUA_NBITS)
-#define LUA_NBITS	32
-#endif
-
-
-#define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
-
-/* macro to trim extra bits */
-#define trim(x)		((x) & ALLONES)
-
-
-/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
-#define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
-
-
-typedef lua_Unsigned b_uint;
-
-
-
-static b_uint andaux (lua_State *L) {
-  int i, n = lua_gettop(L);
-  b_uint r = ~(b_uint)0;
-  for (i = 1; i <= n; i++)
-    r &= luaL_checkunsigned(L, i);
-  return trim(r);
-}
-
-
-static int b_and (lua_State *L) {
-  b_uint r = andaux(L);
-  lua_pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_test (lua_State *L) {
-  b_uint r = andaux(L);
-  lua_pushboolean(L, r != 0);
-  return 1;
-}
-
-
-static int b_or (lua_State *L) {
-  int i, n = lua_gettop(L);
-  b_uint r = 0;
-  for (i = 1; i <= n; i++)
-    r |= luaL_checkunsigned(L, i);
-  lua_pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_xor (lua_State *L) {
-  int i, n = lua_gettop(L);
-  b_uint r = 0;
-  for (i = 1; i <= n; i++)
-    r ^= luaL_checkunsigned(L, i);
-  lua_pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_not (lua_State *L) {
-  b_uint r = ~luaL_checkunsigned(L, 1);
-  lua_pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_shift (lua_State *L, b_uint r, int i) {
-  if (i < 0) {  /* shift right? */
-    i = -i;
-    r = trim(r);
-    if (i >= LUA_NBITS) r = 0;
-    else r >>= i;
-  }
-  else {  /* shift left */
-    if (i >= LUA_NBITS) r = 0;
-    else r <<= i;
-    r = trim(r);
-  }
-  lua_pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_lshift (lua_State *L) {
-  return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkint(L, 2));
-}
-
-
-static int b_rshift (lua_State *L) {
-  return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkint(L, 2));
-}
-
-
-static int b_arshift (lua_State *L) {
-  b_uint r = luaL_checkunsigned(L, 1);
-  int i = luaL_checkint(L, 2);
-  if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1))))
-    return b_shift(L, r, -i);
-  else {  /* arithmetic shift for 'negative' number */
-    if (i >= LUA_NBITS) r = ALLONES;
-    else
-      r = trim((r >> i) | ~(~(b_uint)0 >> i));  /* add signal bit */
-    lua_pushunsigned(L, r);
-    return 1;
-  }
-}
-
-
-static int b_rot (lua_State *L, int i) {
-  b_uint r = luaL_checkunsigned(L, 1);
-  i &= (LUA_NBITS - 1);  /* i = i % NBITS */
-  r = trim(r);
-  if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */
-    r = (r << i) | (r >> (LUA_NBITS - i));
-  lua_pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_lrot (lua_State *L) {
-  return b_rot(L, luaL_checkint(L, 2));
-}
-
-
-static int b_rrot (lua_State *L) {
-  return b_rot(L, -luaL_checkint(L, 2));
-}
-
-
-/*
-** get field and width arguments for field-manipulation functions,
-** checking whether they are valid.
-** ('luaL_error' called without 'return' to avoid later warnings about
-** 'width' being used uninitialized.)
-*/
-static int fieldargs (lua_State *L, int farg, int *width) {
-  int f = luaL_checkint(L, farg);
-  int w = luaL_optint(L, farg + 1, 1);
-  luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
-  luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
-  if (f + w > LUA_NBITS)
-    luaL_error(L, "trying to access non-existent bits");
-  *width = w;
-  return f;
-}
-
-
-static int b_extract (lua_State *L) {
-  int w;
-  b_uint r = luaL_checkunsigned(L, 1);
-  int f = fieldargs(L, 2, &w);
-  r = (r >> f) & mask(w);
-  lua_pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_replace (lua_State *L) {
-  int w;
-  b_uint r = luaL_checkunsigned(L, 1);
-  b_uint v = luaL_checkunsigned(L, 2);
-  int f = fieldargs(L, 3, &w);
-  int m = mask(w);
-  v &= m;  /* erase bits outside given width */
-  r = (r & ~(m << f)) | (v << f);
-  lua_pushunsigned(L, r);
-  return 1;
-}
-
-
-static const luaL_Reg bitlib[] = {
-  {"arshift", b_arshift},
-  {"band", b_and},
-  {"bnot", b_not},
-  {"bor", b_or},
-  {"bxor", b_xor},
-  {"btest", b_test},
-  {"extract", b_extract},
-  {"lrotate", b_lrot},
-  {"lshift", b_lshift},
-  {"replace", b_replace},
-  {"rrotate", b_rrot},
-  {"rshift", b_rshift},
-  {NULL, NULL}
-};
-
-
-
-LUAMOD_API int luaopen_bit32 (lua_State *L) {
-  luaL_newlib(L, bitlib);
-  return 1;
-}
-

3rd/lua/lcode.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lcode.h $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -24,35 +24,53 @@
 ** grep "ORDER OPR" if you change these enums  (ORDER OP)
 */
 typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
+  /* arithmetic operators */
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
+  OPR_DIV, OPR_IDIV,
+  /* bitwise operators */
+  OPR_BAND, OPR_BOR, OPR_BXOR,
+  OPR_SHL, OPR_SHR,
+  /* string operator */
   OPR_CONCAT,
+  /* comparison operators */
   OPR_EQ, OPR_LT, OPR_LE,
   OPR_NE, OPR_GT, OPR_GE,
+  /* logical operators */
   OPR_AND, OPR_OR,
   OPR_NOBINOPR
 } BinOpr;
 
 
-typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+/* true if operation is foldable (that is, it is arithmetic or bitwise) */
+#define foldbinop(op)	((op) <= OPR_SHR)
 
 
-#define getcode(fs,e)	((fs)->f->sp->code[(e)->u.info])
+#define luaK_codeABC(fs,o,a,b,c)	luaK_codeABCk(fs,o,a,b,c,0)
+
+
+typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+
+
+/* get (pointer to) instruction of given 'expdesc' */
+#define getinstruction(fs,e)	((fs)->f->code[(e)->u.info])
 
-#define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
 
 #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
 
 #define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
 
+LUAI_FUNC int luaK_code (FuncState *fs, Instruction i);
 LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
-LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
-LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);
+LUAI_FUNC int luaK_codeAsBx (FuncState *fs, OpCode o, int A, int Bx);
+LUAI_FUNC int luaK_codeABCk (FuncState *fs, OpCode o, int A,
+                                            int B, int C, int k);
+LUAI_FUNC int luaK_isKint (expdesc *e);
+LUAI_FUNC int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v);
 LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
 LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
 LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
 LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
-LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
-LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
+LUAI_FUNC void luaK_int (FuncState *fs, int reg, lua_Integer n);
 LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
 LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
 LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
@@ -70,14 +88,17 @@ LUAI_FUNC int luaK_jump (FuncState *fs);
 LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
 LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
 LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
-LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
 LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
 LUAI_FUNC int luaK_getlabel (FuncState *fs);
 LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
 LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
 LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
                             expdesc *v2, int line);
+LUAI_FUNC void luaK_settablesize (FuncState *fs, int pc,
+                                  int ra, int asize, int hsize);
 LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
+LUAI_FUNC void luaK_finish (FuncState *fs);
+LUAI_FUNC l_noret luaK_semerror (LexState *ls, const char *msg);
 
 
 #endif

3rd/lua/lcorolib.c

@@ -1,37 +1,44 @@
 /*
-** $Id: lcorolib.c,v 1.5.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lcorolib.c $
 ** Coroutine Library
 ** See Copyright Notice in lua.h
 */
 
-
-#include <stdlib.h>
-
-
 #define lcorolib_c
 #define LUA_LIB
 
+#include "lprefix.h"
+
+
+#include <stdlib.h>
+
 #include "lua.h"
 
 #include "lauxlib.h"
 #include "lualib.h"
 
 
+static lua_State *getco (lua_State *L) {
+  lua_State *co = lua_tothread(L, 1);
+  luaL_argexpected(L, co, 1, "thread");
+  return co;
+}
+
+
+/*
+** Resumes a coroutine. Returns the number of results for non-error
+** cases or -1 for errors.
+*/
 static int auxresume (lua_State *L, lua_State *co, int narg) {
-  int status;
-  if (!lua_checkstack(co, narg)) {
+  int status, nres;
+  if (l_unlikely(!lua_checkstack(co, narg))) {
     lua_pushliteral(L, "too many arguments to resume");
     return -1;  /* error flag */
   }
-  if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
-    lua_pushliteral(L, "cannot resume dead coroutine");
-    return -1;  /* error flag */
-  }
   lua_xmove(L, co, narg);
-  status = lua_resume(co, L, narg);
-  if (status == LUA_OK || status == LUA_YIELD) {
-    int nres = lua_gettop(co);
-    if (!lua_checkstack(L, nres + 1)) {
+  status = lua_resume(co, L, narg, &nres);
+  if (l_likely(status == LUA_OK || status == LUA_YIELD)) {
+    if (l_unlikely(!lua_checkstack(L, nres + 1))) {
       lua_pop(co, nres);  /* remove results anyway */
       lua_pushliteral(L, "too many results to resume");
       return -1;  /* error flag */
@@ -47,11 +54,10 @@ static int auxresume (lua_State *L, lua_State *co, int narg) {
 
 
 static int luaB_coresume (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
+  lua_State *co = getco(L);
   int r;
-  luaL_argcheck(L, co, 1, "coroutine expected");
   r = auxresume(L, co, lua_gettop(L) - 1);
-  if (r < 0) {
+  if (l_unlikely(r < 0)) {
     lua_pushboolean(L, 0);
     lua_insert(L, -2);
     return 2;  /* return false + error message */
@@ -59,7 +65,7 @@ static int luaB_coresume (lua_State *L) {
   else {
     lua_pushboolean(L, 1);
     lua_insert(L, -(r + 1));
-    return r + 1;  /* return true + `resume' returns */
+    return r + 1;  /* return true + 'resume' returns */
   }
 }
 
@@ -67,9 +73,16 @@ static int luaB_coresume (lua_State *L) {
 static int luaB_auxwrap (lua_State *L) {
   lua_State *co = lua_tothread(L, lua_upvalueindex(1));
   int r = auxresume(L, co, lua_gettop(L));
-  if (r < 0) {
-    if (lua_isstring(L, -1)) {  /* error object is a string? */
-      luaL_where(L, 1);  /* add extra info */
+  if (l_unlikely(r < 0)) {  /* error? */
+    int stat = lua_status(co);
+    if (stat != LUA_OK && stat != LUA_YIELD) {  /* error in the coroutine? */
+      stat = lua_closethread(co, L);  /* close its tbc variables */
+      lua_assert(stat != LUA_OK);
+      lua_xmove(co, L, 1);  /* move error message to the caller */
+    }
+    if (stat != LUA_ERRMEM &&  /* not a memory error and ... */
+        lua_type(L, -1) == LUA_TSTRING) {  /* ... error object is a string? */
+      luaL_where(L, 1);  /* add extra info, if available */
       lua_insert(L, -2);
       lua_concat(L, 2);
     }
@@ -101,30 +114,48 @@ static int luaB_yield (lua_State *L) {
 }
 
 
-static int luaB_costatus (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  luaL_argcheck(L, co, 1, "coroutine expected");
-  if (L == co) lua_pushliteral(L, "running");
+#define COS_RUN		0
+#define COS_DEAD	1
+#define COS_YIELD	2
+#define COS_NORM	3
+
+
+static const char *const statname[] =
+  {"running", "dead", "suspended", "normal"};
+
+
+static int auxstatus (lua_State *L, lua_State *co) {
+  if (L == co) return COS_RUN;
   else {
     switch (lua_status(co)) {
       case LUA_YIELD:
-        lua_pushliteral(L, "suspended");
-        break;
+        return COS_YIELD;
       case LUA_OK: {
         lua_Debug ar;
-        if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
-          lua_pushliteral(L, "normal");  /* it is running */
+        if (lua_getstack(co, 0, &ar))  /* does it have frames? */
+          return COS_NORM;  /* it is running */
         else if (lua_gettop(co) == 0)
-            lua_pushliteral(L, "dead");
+            return COS_DEAD;
         else
-          lua_pushliteral(L, "suspended");  /* initial state */
-        break;
+          return COS_YIELD;  /* initial state */
       }
       default:  /* some error occurred */
-        lua_pushliteral(L, "dead");
-        break;
+        return COS_DEAD;
     }
   }
+}
+
+
+static int luaB_costatus (lua_State *L) {
+  lua_State *co = getco(L);
+  lua_pushstring(L, statname[auxstatus(L, co)]);
+  return 1;
+}
+
+
+static int luaB_yieldable (lua_State *L) {
+  lua_State *co = lua_isnone(L, 1) ? L : getco(L);
+  lua_pushboolean(L, lua_isyieldable(co));
   return 1;
 }
 
@@ -136,6 +167,28 @@ static int luaB_corunning (lua_State *L) {
 }
 
 
+static int luaB_close (lua_State *L) {
+  lua_State *co = getco(L);
+  int status = auxstatus(L, co);
+  switch (status) {
+    case COS_DEAD: case COS_YIELD: {
+      status = lua_closethread(co, L);
+      if (status == LUA_OK) {
+        lua_pushboolean(L, 1);
+        return 1;
+      }
+      else {
+        lua_pushboolean(L, 0);
+        lua_xmove(co, L, 1);  /* move error message */
+        return 2;
+      }
+    }
+    default:  /* normal or running coroutine */
+      return luaL_error(L, "cannot close a %s coroutine", statname[status]);
+  }
+}
+
+
 static const luaL_Reg co_funcs[] = {
   {"create", luaB_cocreate},
   {"resume", luaB_coresume},
@@ -143,6 +196,8 @@ static const luaL_Reg co_funcs[] = {
   {"status", luaB_costatus},
   {"wrap", luaB_cowrap},
   {"yield", luaB_yield},
+  {"isyieldable", luaB_yieldable},
+  {"close", luaB_close},
   {NULL, NULL}
 };
 

3rd/lua/lctype.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lctype.c $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
@@ -7,12 +7,24 @@
 #define lctype_c
 #define LUA_CORE
 
+#include "lprefix.h"
+
+
 #include "lctype.h"
 
 #if !LUA_USE_CTYPE	/* { */
 
 #include <limits.h>
 
+
+#if defined (LUA_UCID)		/* accept UniCode IDentifiers? */
+/* consider all non-ascii codepoints to be alphabetic */
+#define NONA		0x01
+#else
+#define NONA		0x00	/* default */
+#endif
+
+
 LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
   0x00,  /* EOZ */
   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */
@@ -31,22 +43,22 @@ LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */
   0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 8. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 9. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* a. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* b. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* c. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* d. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* e. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* f. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* 8. */
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* 9. */
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* a. */
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* b. */
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
+  0x00,  0x00,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* c. */
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* d. */
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* e. */
+  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
+  NONA,  NONA,  NONA,  NONA,  NONA,  0x00,  0x00,  0x00,	/* f. */
+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00
 };
 
 #endif			/* } */

3rd/lua/lctype.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lctype.h $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
@@ -13,7 +13,7 @@
 /*
 ** WARNING: the functions defined here do not necessarily correspond
 ** to the similar functions in the standard C ctype.h. They are
-** optimized for the specific needs of Lua
+** optimized for the specific needs of Lua.
 */
 
 #if !defined(LUA_USE_CTYPE)
@@ -61,14 +61,20 @@
 #define lisprint(c)	testprop(c, MASK(PRINTBIT))
 #define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))
 
+
 /*
-** this 'ltolower' only works for alphabetic characters
+** In ASCII, this 'ltolower' is correct for alphabetic characters and
+** for '.'. That is enough for Lua needs. ('check_exp' ensures that
+** the character either is an upper-case letter or is unchanged by
+** the transformation, which holds for lower-case letters and '.'.)
 */
-#define ltolower(c)	((c) | ('A' ^ 'a'))
+#define ltolower(c)  \
+  check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')),  \
+            (c) | ('A' ^ 'a'))
 
 
-/* two more entries for 0 and -1 (EOZ) */
-LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
+/* one entry for each character and for -1 (EOZ) */
+LUAI_DDEC(const lu_byte luai_ctype_[UCHAR_MAX + 2];)
 
 
 #else			/* }{ */

3rd/lua/ldblib.c

@@ -1,26 +1,42 @@
 /*
-** $Id: ldblib.c,v 1.132.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: ldblib.c $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 
+#define ldblib_c
+#define LUA_LIB
+
+#include "lprefix.h"
+
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define ldblib_c
-#define LUA_LIB
-
 #include "lua.h"
 
 #include "lauxlib.h"
 #include "lualib.h"
 
 
-#define HOOKKEY		"_HKEY"
+/*
+** The hook table at registry[HOOKKEY] maps threads to their current
+** hook function.
+*/
+static const char *const HOOKKEY = "_HOOKKEY";
 
 
+/*
+** If L1 != L, L1 can be in any state, and therefore there are no
+** guarantees about its stack space; any push in L1 must be
+** checked.
+*/
+static void checkstack (lua_State *L, lua_State *L1, int n) {
+  if (l_unlikely(L != L1 && !lua_checkstack(L1, n)))
+    luaL_error(L, "stack overflow");
+}
+
 
 static int db_getregistry (lua_State *L) {
   lua_pushvalue(L, LUA_REGISTRYINDEX);
@@ -39,8 +55,7 @@ static int db_getmetatable (lua_State *L) {
 
 static int db_setmetatable (lua_State *L) {
   int t = lua_type(L, 2);
-  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
-                    "nil or table expected");
+  luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
   lua_settop(L, 2);
   lua_setmetatable(L, 1);
   return 1;  /* return 1st argument */
@@ -48,44 +63,34 @@ static int db_setmetatable (lua_State *L) {
 
 
 static int db_getuservalue (lua_State *L) {
+  int n = (int)luaL_optinteger(L, 2, 1);
   if (lua_type(L, 1) != LUA_TUSERDATA)
-    lua_pushnil(L);
-  else
-    lua_getuservalue(L, 1);
+    luaL_pushfail(L);
+  else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) {
+    lua_pushboolean(L, 1);
+    return 2;
+  }
   return 1;
 }
 
 
 static int db_setuservalue (lua_State *L) {
-  if (lua_type(L, 1) == LUA_TLIGHTUSERDATA)
-    luaL_argerror(L, 1, "full userdata expected, got light userdata");
+  int n = (int)luaL_optinteger(L, 3, 1);
   luaL_checktype(L, 1, LUA_TUSERDATA);
-  if (!lua_isnoneornil(L, 2))
-    luaL_checktype(L, 2, LUA_TTABLE);
+  luaL_checkany(L, 2);
   lua_settop(L, 2);
-  lua_setuservalue(L, 1);
+  if (!lua_setiuservalue(L, 1, n))
+    luaL_pushfail(L);
   return 1;
 }
 
 
-static void settabss (lua_State *L, const char *i, const char *v) {
-  lua_pushstring(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static void settabsi (lua_State *L, const char *i, int v) {
-  lua_pushinteger(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
-static void settabsb (lua_State *L, const char *i, int v) {
-  lua_pushboolean(L, v);
-  lua_setfield(L, -2, i);
-}
-
-
+/*
+** Auxiliary function used by several library functions: check for
+** an optional thread as function's first argument and set 'arg' with
+** 1 if this argument is present (so that functions can skip it to
+** access their other arguments)
+*/
 static lua_State *getthread (lua_State *L, int *arg) {
   if (lua_isthread(L, 1)) {
     *arg = 1;
@@ -93,46 +98,78 @@ static lua_State *getthread (lua_State *L, int *arg) {
   }
   else {
     *arg = 0;
-    return L;
+    return L;  /* function will operate over current thread */
   }
 }
 
 
+/*
+** Variations of 'lua_settable', used by 'db_getinfo' to put results
+** from 'lua_getinfo' into result table. Key is always a string;
+** value can be a string, an int, or a boolean.
+*/
+static void settabss (lua_State *L, const char *k, const char *v) {
+  lua_pushstring(L, v);
+  lua_setfield(L, -2, k);
+}
+
+static void settabsi (lua_State *L, const char *k, int v) {
+  lua_pushinteger(L, v);
+  lua_setfield(L, -2, k);
+}
+
+static void settabsb (lua_State *L, const char *k, int v) {
+  lua_pushboolean(L, v);
+  lua_setfield(L, -2, k);
+}
+
+
+/*
+** In function 'db_getinfo', the call to 'lua_getinfo' may push
+** results on the stack; later it creates the result table to put
+** these objects. Function 'treatstackoption' puts the result from
+** 'lua_getinfo' on top of the result table so that it can call
+** 'lua_setfield'.
+*/
 static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
-  if (L == L1) {
-    lua_pushvalue(L, -2);
-    lua_remove(L, -3);
-  }
+  if (L == L1)
+    lua_rotate(L, -2, 1);  /* exchange object and table */
   else
-    lua_xmove(L1, L, 1);
-  lua_setfield(L, -2, fname);
+    lua_xmove(L1, L, 1);  /* move object to the "main" stack */
+  lua_setfield(L, -2, fname);  /* put object into table */
 }
 
 
+/*
+** Calls 'lua_getinfo' and collects all results in a new table.
+** L1 needs stack space for an optional input (function) plus
+** two optional outputs (function and line table) from function
+** 'lua_getinfo'.
+*/
 static int db_getinfo (lua_State *L) {
   lua_Debug ar;
   int arg;
   lua_State *L1 = getthread(L, &arg);
-  const char *options = luaL_optstring(L, arg+2, "flnStu");
-  if (lua_isnumber(L, arg+1)) {
-    if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
-      lua_pushnil(L);  /* level out of range */
+  const char *options = luaL_optstring(L, arg+2, "flnSrtu");
+  checkstack(L, L1, 3);
+  luaL_argcheck(L, options[0] != '>', arg + 2, "invalid option '>'");
+  if (lua_isfunction(L, arg + 1)) {  /* info about a function? */
+    options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */
+    lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */
+    lua_xmove(L, L1, 1);
+  }
+  else {  /* stack level */
+    if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
+      luaL_pushfail(L);  /* level out of range */
       return 1;
     }
   }
-  else if (lua_isfunction(L, arg+1)) {
-    lua_pushfstring(L, ">%s", options);
-    options = lua_tostring(L, -1);
-    lua_pushvalue(L, arg+1);
-    lua_xmove(L, L1, 1);
-  }
-  else
-    return luaL_argerror(L, arg+1, "function or level expected");
   if (!lua_getinfo(L1, options, &ar))
     return luaL_argerror(L, arg+2, "invalid option");
-  lua_createtable(L, 0, 2);
+  lua_newtable(L);  /* table to collect results */
   if (strchr(options, 'S')) {
-    settabss(L, "source", ar.source);
+    lua_pushlstring(L, ar.source, ar.srclen);
+    lua_setfield(L, -2, "source");
     settabss(L, "short_src", ar.short_src);
     settabsi(L, "linedefined", ar.linedefined);
     settabsi(L, "lastlinedefined", ar.lastlinedefined);
@@ -149,6 +186,10 @@ static int db_getinfo (lua_State *L) {
     settabss(L, "name", ar.name);
     settabss(L, "namewhat", ar.namewhat);
   }
+  if (strchr(options, 'r')) {
+    settabsi(L, "ftransfer", ar.ftransfer);
+    settabsi(L, "ntransfer", ar.ntransfer);
+  }
   if (strchr(options, 't'))
     settabsb(L, "istailcall", ar.istailcall);
   if (strchr(options, 'L'))
@@ -162,26 +203,28 @@ static int db_getinfo (lua_State *L) {
 static int db_getlocal (lua_State *L) {
   int arg;
   lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  const char *name;
-  int nvar = luaL_checkint(L, arg+2);  /* local-variable index */
+  int nvar = (int)luaL_checkinteger(L, arg + 2);  /* local-variable index */
   if (lua_isfunction(L, arg + 1)) {  /* function argument? */
     lua_pushvalue(L, arg + 1);  /* push function */
     lua_pushstring(L, lua_getlocal(L, NULL, nvar));  /* push local name */
-    return 1;
+    return 1;  /* return only name (there is no value) */
   }
   else {  /* stack-level argument */
-    if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+    lua_Debug ar;
+    const char *name;
+    int level = (int)luaL_checkinteger(L, arg + 1);
+    if (l_unlikely(!lua_getstack(L1, level, &ar)))  /* out of range? */
       return luaL_argerror(L, arg+1, "level out of range");
+    checkstack(L, L1, 1);
     name = lua_getlocal(L1, &ar, nvar);
     if (name) {
-      lua_xmove(L1, L, 1);  /* push local value */
+      lua_xmove(L1, L, 1);  /* move local value */
       lua_pushstring(L, name);  /* push name */
-      lua_pushvalue(L, -2);  /* re-order */
+      lua_rotate(L, -2, 1);  /* re-order */
       return 2;
     }
     else {
-      lua_pushnil(L);  /* no name (nor value) */
+      luaL_pushfail(L);  /* no name (nor value) */
       return 1;
     }
   }
@@ -190,26 +233,36 @@ static int db_getlocal (lua_State *L) {
 
 static int db_setlocal (lua_State *L) {
   int arg;
+  const char *name;
   lua_State *L1 = getthread(L, &arg);
   lua_Debug ar;
-  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+  int level = (int)luaL_checkinteger(L, arg + 1);
+  int nvar = (int)luaL_checkinteger(L, arg + 2);
+  if (l_unlikely(!lua_getstack(L1, level, &ar)))  /* out of range? */
     return luaL_argerror(L, arg+1, "level out of range");
   luaL_checkany(L, arg+3);
   lua_settop(L, arg+3);
+  checkstack(L, L1, 1);
   lua_xmove(L, L1, 1);
-  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
+  name = lua_setlocal(L1, &ar, nvar);
+  if (name == NULL)
+    lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */
+  lua_pushstring(L, name);
   return 1;
 }
 
 
+/*
+** get (if 'get' is true) or set an upvalue from a closure
+*/
 static int auxupvalue (lua_State *L, int get) {
   const char *name;
-  int n = luaL_checkint(L, 2);
-  luaL_checktype(L, 1, LUA_TFUNCTION);
+  int n = (int)luaL_checkinteger(L, 2);  /* upvalue index */
+  luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */
   name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
   if (name == NULL) return 0;
   lua_pushstring(L, name);
-  lua_insert(L, -(get+1));
+  lua_insert(L, -(get+1));  /* no-op if get is false */
   return get + 1;
 }
 
@@ -225,27 +278,37 @@ static int db_setupvalue (lua_State *L) {
 }
 
 
-static int checkupval (lua_State *L, int argf, int argnup) {
-  lua_Debug ar;
-  int nup = luaL_checkint(L, argnup);
-  luaL_checktype(L, argf, LUA_TFUNCTION);
-  lua_pushvalue(L, argf);
-  lua_getinfo(L, ">u", &ar);
-  luaL_argcheck(L, 1 <= nup && nup <= ar.nups, argnup, "invalid upvalue index");
-  return nup;
+/*
+** Check whether a given upvalue from a given closure exists and
+** returns its index
+*/
+static void *checkupval (lua_State *L, int argf, int argnup, int *pnup) {
+  void *id;
+  int nup = (int)luaL_checkinteger(L, argnup);  /* upvalue index */
+  luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */
+  id = lua_upvalueid(L, argf, nup);
+  if (pnup) {
+    luaL_argcheck(L, id != NULL, argnup, "invalid upvalue index");
+    *pnup = nup;
+  }
+  return id;
 }
 
 
 static int db_upvalueid (lua_State *L) {
-  int n = checkupval(L, 1, 2);
-  lua_pushlightuserdata(L, lua_upvalueid(L, 1, n));
+  void *id = checkupval(L, 1, 2, NULL);
+  if (id != NULL)
+    lua_pushlightuserdata(L, id);
+  else
+    luaL_pushfail(L);
   return 1;
 }
 
 
 static int db_upvaluejoin (lua_State *L) {
-  int n1 = checkupval(L, 1, 2);
-  int n2 = checkupval(L, 3, 4);
+  int n1, n2;
+  checkupval(L, 1, 2, &n1);
+  checkupval(L, 3, 4, &n2);
   luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
   luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
   lua_upvaluejoin(L, 1, n1, 3, n2);
@@ -253,26 +316,29 @@ static int db_upvaluejoin (lua_State *L) {
 }
 
 
-#define gethooktable(L)	luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)
-
-
+/*
+** Call hook function registered at hook table for the current
+** thread (if there is one)
+*/
 static void hookf (lua_State *L, lua_Debug *ar) {
   static const char *const hooknames[] =
     {"call", "return", "line", "count", "tail call"};
-  gethooktable(L);
+  lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
   lua_pushthread(L);
-  lua_rawget(L, -2);
-  if (lua_isfunction(L, -1)) {
-    lua_pushstring(L, hooknames[(int)ar->event]);
+  if (lua_rawget(L, -2) == LUA_TFUNCTION) {  /* is there a hook function? */
+    lua_pushstring(L, hooknames[(int)ar->event]);  /* push event name */
     if (ar->currentline >= 0)
-      lua_pushinteger(L, ar->currentline);
+      lua_pushinteger(L, ar->currentline);  /* push current line */
     else lua_pushnil(L);
     lua_assert(lua_getinfo(L, "lS", ar));
-    lua_call(L, 2, 0);
+    lua_call(L, 2, 0);  /* call hook function */
   }
 }
 
 
+/*
+** Convert a string mask (for 'sethook') into a bit mask
+*/
 static int makemask (const char *smask, int count) {
   int mask = 0;
   if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
@@ -283,6 +349,9 @@ static int makemask (const char *smask, int count) {
 }
 
 
+/*
+** Convert a bit mask (for 'gethook') into a string mask
+*/
 static char *unmakemask (int mask, char *smask) {
   int i = 0;
   if (mask & LUA_MASKCALL) smask[i++] = 'c';
@@ -297,26 +366,28 @@ static int db_sethook (lua_State *L) {
   int arg, mask, count;
   lua_Hook func;
   lua_State *L1 = getthread(L, &arg);
-  if (lua_isnoneornil(L, arg+1)) {
+  if (lua_isnoneornil(L, arg+1)) {  /* no hook? */
     lua_settop(L, arg+1);
     func = NULL; mask = 0; count = 0;  /* turn off hooks */
   }
   else {
     const char *smask = luaL_checkstring(L, arg+2);
     luaL_checktype(L, arg+1, LUA_TFUNCTION);
-    count = luaL_optint(L, arg+3, 0);
+    count = (int)luaL_optinteger(L, arg + 3, 0);
     func = hookf; mask = makemask(smask, count);
   }
-  if (gethooktable(L) == 0) {  /* creating hook table? */
-    lua_pushstring(L, "k");
+  if (!luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)) {
+    /* table just created; initialize it */
+    lua_pushliteral(L, "k");
     lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */
     lua_pushvalue(L, -1);
-    lua_setmetatable(L, -2);  /* setmetatable(hooktable) = hooktable */
+    lua_setmetatable(L, -2);  /* metatable(hooktable) = hooktable */
   }
-  lua_pushthread(L1); lua_xmove(L1, L, 1);
-  lua_pushvalue(L, arg+1);
-  lua_rawset(L, -3);  /* set new hook */
-  lua_sethook(L1, func, mask, count);  /* set hooks */
+  checkstack(L, L1, 1);
+  lua_pushthread(L1); lua_xmove(L1, L, 1);  /* key (thread) */
+  lua_pushvalue(L, arg + 1);  /* value (hook function) */
+  lua_rawset(L, -3);  /* hooktable[L1] = new Lua hook */
+  lua_sethook(L1, func, mask, count);
   return 0;
 }
 
@@ -327,16 +398,21 @@ static int db_gethook (lua_State *L) {
   char buff[5];
   int mask = lua_gethookmask(L1);
   lua_Hook hook = lua_gethook(L1);
-  if (hook != NULL && hook != hookf)  /* external hook? */
+  if (hook == NULL) {  /* no hook? */
+    luaL_pushfail(L);
+    return 1;
+  }
+  else if (hook != hookf)  /* external hook? */
     lua_pushliteral(L, "external hook");
-  else {
-    gethooktable(L);
+  else {  /* hook table must exist */
+    lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
+    checkstack(L, L1, 1);
     lua_pushthread(L1); lua_xmove(L1, L, 1);
-    lua_rawget(L, -2);   /* get hook */
+    lua_rawget(L, -2);   /* 1st result = hooktable[L1] */
     lua_remove(L, -2);  /* remove hook table */
   }
-  lua_pushstring(L, unmakemask(mask, buff));
-  lua_pushinteger(L, lua_gethookcount(L1));
+  lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */
+  lua_pushinteger(L, lua_gethookcount(L1));  /* 3rd result = count */
   return 3;
 }
 
@@ -344,13 +420,13 @@ static int db_gethook (lua_State *L) {
 static int db_debug (lua_State *L) {
   for (;;) {
     char buffer[250];
-    luai_writestringerror("%s", "lua_debug> ");
-    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
+    lua_writestringerror("%s", "lua_debug> ");
+    if (fgets(buffer, sizeof(buffer), stdin) == NULL ||
         strcmp(buffer, "cont\n") == 0)
       return 0;
     if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
         lua_pcall(L, 0, 0, 0))
-      luai_writestringerror("%s\n", lua_tostring(L, -1));
+      lua_writestringerror("%s\n", luaL_tolstring(L, -1, NULL));
     lua_settop(L, 0);  /* remove eventual returns */
   }
 }
@@ -363,13 +439,21 @@ static int db_traceback (lua_State *L) {
   if (msg == NULL && !lua_isnoneornil(L, arg + 1))  /* non-string 'msg'? */
     lua_pushvalue(L, arg + 1);  /* return it untouched */
   else {
-    int level = luaL_optint(L, arg + 2, (L == L1) ? 1 : 0);
+    int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
     luaL_traceback(L, L1, msg, level);
   }
   return 1;
 }
 
 
+static int db_setcstacklimit (lua_State *L) {
+  int limit = (int)luaL_checkinteger(L, 1);
+  int res = lua_setcstacklimit(L, limit);
+  lua_pushinteger(L, res);
+  return 1;
+}
+
+
 static const luaL_Reg dblib[] = {
   {"debug", db_debug},
   {"getuservalue", db_getuservalue},
@@ -387,6 +471,7 @@ static const luaL_Reg dblib[] = {
   {"setmetatable", db_setmetatable},
   {"setupvalue", db_setupvalue},
   {"traceback", db_traceback},
+  {"setcstacklimit", db_setcstacklimit},
   {NULL, NULL}
 };
 

3rd/lua/ldebug.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: ldebug.h $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
@@ -11,24 +11,53 @@
 #include "lstate.h"
 
 
-#define pcRel(pc, p)	(cast(int, (pc) - (p)->sp->code) - 1)
+#define pcRel(pc, p)	(cast_int((pc) - (p)->code) - 1)
+
+
+/* Active Lua function (given call info) */
+#define ci_func(ci)		(clLvalue(s2v((ci)->func.p)))
 
-#define getfuncline(f,pc)	(((f)->sp->lineinfo) ? (f)->sp->lineinfo[pc] : 0)
 
 #define resethookcount(L)	(L->hookcount = L->basehookcount)
 
-/* Active Lua function (given call info) */
-#define ci_func(ci)		(clLvalue((ci)->func))
+/*
+** mark for entries in 'lineinfo' array that has absolute information in
+** 'abslineinfo' array
+*/
+#define ABSLINEINFO	(-0x80)
 
 
+/*
+** MAXimum number of successive Instructions WiTHout ABSolute line
+** information. (A power of two allows fast divisions.)
+*/
+#if !defined(MAXIWTHABS)
+#define MAXIWTHABS	128
+#endif
+
+
+LUAI_FUNC int luaG_getfuncline (const Proto *f, int pc);
+LUAI_FUNC const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n,
+                                                    StkId *pos);
 LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
                                                 const char *opname);
-LUAI_FUNC l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2);
-LUAI_FUNC l_noret luaG_aritherror (lua_State *L, const TValue *p1,
+LUAI_FUNC l_noret luaG_callerror (lua_State *L, const TValue *o);
+LUAI_FUNC l_noret luaG_forerror (lua_State *L, const TValue *o,
+                                               const char *what);
+LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
+                                                  const TValue *p2);
+LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,
+                                                 const TValue *p2,
+                                                 const char *msg);
+LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,
                                                  const TValue *p2);
 LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
                                                  const TValue *p2);
 LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
+LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
+                                                  TString *src, int line);
 LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
+LUAI_FUNC int luaG_traceexec (lua_State *L, const Instruction *pc);
+
 
 #endif

3rd/lua/ldo.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: ldo.h $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -8,36 +8,78 @@
 #define ldo_h
 
 
+#include "llimits.h"
 #include "lobject.h"
 #include "lstate.h"
 #include "lzio.h"
 
 
-#define luaD_checkstack(L,n)	if (L->stack_last - L->top <= (n)) \
-				    luaD_growstack(L, n); else condmovestack(L);
+/*
+** Macro to check stack size and grow stack if needed.  Parameters
+** 'pre'/'pos' allow the macro to preserve a pointer into the
+** stack across reallocations, doing the work only when needed.
+** It also allows the running of one GC step when the stack is
+** reallocated.
+** 'condmovestack' is used in heavy tests to force a stack reallocation
+** at every check.
+*/
+#define luaD_checkstackaux(L,n,pre,pos)  \
+	if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \
+	  { pre; luaD_growstack(L, n, 1); pos; } \
+        else { condmovestack(L,pre,pos); }
+
+/* In general, 'pre'/'pos' are empty (nothing to save) */
+#define luaD_checkstack(L,n)	luaD_checkstackaux(L,n,(void)0,(void)0)
 
 
-#define incr_top(L) {L->top++; luaD_checkstack(L,0);}
 
-#define savestack(L,p)		((char *)(p) - (char *)L->stack)
-#define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
+#define savestack(L,pt)		(cast_charp(pt) - cast_charp(L->stack.p))
+#define restorestack(L,n)	cast(StkId, cast_charp(L->stack.p) + (n))
 
 
-/* type of protected functions, to be ran by `runprotected' */
+/* macro to check stack size, preserving 'p' */
+#define checkstackp(L,n,p)  \
+  luaD_checkstackaux(L, n, \
+    ptrdiff_t t__ = savestack(L, p),  /* save 'p' */ \
+    p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
+
+
+/* macro to check stack size and GC, preserving 'p' */
+#define checkstackGCp(L,n,p)  \
+  luaD_checkstackaux(L, n, \
+    ptrdiff_t t__ = savestack(L, p);  /* save 'p' */ \
+    luaC_checkGC(L),  /* stack grow uses memory */ \
+    p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
+
+
+/* macro to check stack size and GC */
+#define checkstackGC(L,fsize)  \
+	luaD_checkstackaux(L, (fsize), luaC_checkGC(L), (void)0)
+
+
+/* type of protected functions, to be ran by 'runprotected' */
 typedef void (*Pfunc) (lua_State *L, void *ud);
 
+LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
 LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
                                                   const char *mode);
-LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
-LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
-LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults,
-                                        int allowyield);
+LUAI_FUNC void luaD_hook (lua_State *L, int event, int line,
+                                        int fTransfer, int nTransfer);
+LUAI_FUNC void luaD_hookcall (lua_State *L, CallInfo *ci);
+LUAI_FUNC int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func,
+                                              int narg1, int delta);
+LUAI_FUNC CallInfo *luaD_precall (lua_State *L, StkId func, int nResults);
+LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
+LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
+LUAI_FUNC StkId luaD_tryfuncTM (lua_State *L, StkId func);
+LUAI_FUNC int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status);
 LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
                                         ptrdiff_t oldtop, ptrdiff_t ef);
-LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
-LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
-LUAI_FUNC void luaD_growstack (lua_State *L, int n);
+LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, int nres);
+LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror);
+LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror);
 LUAI_FUNC void luaD_shrinkstack (lua_State *L);
+LUAI_FUNC void luaD_inctop (lua_State *L);
 
 LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
 LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);

3rd/lua/ldump.c

@@ -1,174 +1,230 @@
 /*
-** $Id: ldump.c,v 2.17.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: ldump.c $
 ** save precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 
-#include <stddef.h>
-
 #define ldump_c
 #define LUA_CORE
 
+#include "lprefix.h"
+
+
+#include <limits.h>
+#include <stddef.h>
+
 #include "lua.h"
 
 #include "lobject.h"
 #include "lstate.h"
 #include "lundump.h"
 
+
 typedef struct {
- lua_State* L;
- lua_Writer writer;
- void* data;
- int strip;
- int status;
+  lua_State *L;
+  lua_Writer writer;
+  void *data;
+  int strip;
+  int status;
 } DumpState;
 
-#define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
-#define DumpVar(x,D)		DumpMem(&x,1,sizeof(x),D)
 
-static void DumpBlock(const void* b, size_t size, DumpState* D)
-{
- if (D->status==0)
- {
-  lua_unlock(D->L);
-  D->status=(*D->writer)(D->L,b,size,D->data);
-  lua_lock(D->L);
- }
-}
+/*
+** All high-level dumps go through dumpVector; you can change it to
+** change the endianness of the result
+*/
+#define dumpVector(D,v,n)	dumpBlock(D,v,(n)*sizeof((v)[0]))
 
-static void DumpChar(int y, DumpState* D)
-{
- char x=(char)y;
- DumpVar(x,D);
-}
+#define dumpLiteral(D, s)	dumpBlock(D,s,sizeof(s) - sizeof(char))
 
-static void DumpInt(int x, DumpState* D)
-{
- DumpVar(x,D);
-}
 
-static void DumpNumber(lua_Number x, DumpState* D)
-{
- DumpVar(x,D);
-}
-
-static void DumpVector(const void* b, int n, size_t size, DumpState* D)
-{
- DumpInt(n,D);
- DumpMem(b,n,size,D);
-}
-
-static void DumpString(const TString* s, DumpState* D)
-{
- if (s==NULL)
- {
-  size_t size=0;
-  DumpVar(size,D);
- }
- else
- {
-  size_t size=s->tsv.len+1;		/* include trailing '\0' */
-  DumpVar(size,D);
-  DumpBlock(getstr(s),size*sizeof(char),D);
- }
-}
-
-#define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
-
-static void DumpFunction(const Proto* f, DumpState* D);
-
-static void DumpConstants(const Proto* f, DumpState* D)
-{
- int i,n=f->sp->sizek;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  const TValue* o=&f->k[i];
-  DumpChar(ttypenv(o),D);
-  switch (ttypenv(o))
-  {
-   case LUA_TNIL:
-	break;
-   case LUA_TBOOLEAN:
-	DumpChar(bvalue(o),D);
-	break;
-   case LUA_TNUMBER:
-	DumpNumber(nvalue(o),D);
-	break;
-   case LUA_TSTRING:
-	DumpString(rawtsvalue(o),D);
-	break;
-    default: lua_assert(0);
+static void dumpBlock (DumpState *D, const void *b, size_t size) {
+  if (D->status == 0 && size > 0) {
+    lua_unlock(D->L);
+    D->status = (*D->writer)(D->L, b, size, D->data);
+    lua_lock(D->L);
   }
- }
- n=f->sp->sizep;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpFunction(f->p[i],D);
 }
 
-static void DumpUpvalues(const Proto* f, DumpState* D)
-{
- int i,n=f->sp->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  DumpChar(f->sp->upvalues[i].instack,D);
-  DumpChar(f->sp->upvalues[i].idx,D);
- }
+
+#define dumpVar(D,x)		dumpVector(D,&x,1)
+
+
+static void dumpByte (DumpState *D, int y) {
+  lu_byte x = (lu_byte)y;
+  dumpVar(D, x);
 }
 
-static void DumpDebug(const SharedProto* f, DumpState* D)
-{
- int i,n;
- DumpString((D->strip) ? NULL : f->source,D);
- n= (D->strip) ? 0 : f->sizelineinfo;
- DumpVector(f->lineinfo,n,sizeof(int),D);
- n= (D->strip) ? 0 : f->sizelocvars;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  DumpString(f->locvars[i].varname,D);
-  DumpInt(f->locvars[i].startpc,D);
-  DumpInt(f->locvars[i].endpc,D);
- }
- n= (D->strip) ? 0 : f->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpString(f->upvalues[i].name,D);
+
+/*
+** 'dumpSize' buffer size: each byte can store up to 7 bits. (The "+6"
+** rounds up the division.)
+*/
+#define DIBS    ((sizeof(size_t) * CHAR_BIT + 6) / 7)
+
+static void dumpSize (DumpState *D, size_t x) {
+  lu_byte buff[DIBS];
+  int n = 0;
+  do {
+    buff[DIBS - (++n)] = x & 0x7f;  /* fill buffer in reverse order */
+    x >>= 7;
+  } while (x != 0);
+  buff[DIBS - 1] |= 0x80;  /* mark last byte */
+  dumpVector(D, buff + DIBS - n, n);
 }
 
-static void DumpFunction(const Proto* f, DumpState* D)
-{
- const SharedProto *sp = f->sp;
- DumpInt(sp->linedefined,D);
- DumpInt(sp->lastlinedefined,D);
- DumpChar(sp->numparams,D);
- DumpChar(sp->is_vararg,D);
- DumpChar(sp->maxstacksize,D);
- DumpCode(sp,D);
- DumpConstants(f,D);
- DumpUpvalues(f,D);
- DumpDebug(sp,D);
+
+static void dumpInt (DumpState *D, int x) {
+  dumpSize(D, x);
 }
 
-static void DumpHeader(DumpState* D)
-{
- lu_byte h[LUAC_HEADERSIZE];
- luaU_header(h);
- DumpBlock(h,LUAC_HEADERSIZE,D);
+
+static void dumpNumber (DumpState *D, lua_Number x) {
+  dumpVar(D, x);
 }
 
+
+static void dumpInteger (DumpState *D, lua_Integer x) {
+  dumpVar(D, x);
+}
+
+
+static void dumpString (DumpState *D, const TString *s) {
+  if (s == NULL)
+    dumpSize(D, 0);
+  else {
+    size_t size = tsslen(s);
+    const char *str = getstr(s);
+    dumpSize(D, size + 1);
+    dumpVector(D, str, size);
+  }
+}
+
+
+static void dumpCode (DumpState *D, const Proto *f) {
+  dumpInt(D, f->sizecode);
+  dumpVector(D, f->code, f->sizecode);
+}
+
+
+static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
+
+static void dumpConstants (DumpState *D, const Proto *f) {
+  int i;
+  int n = f->sizek;
+  dumpInt(D, n);
+  for (i = 0; i < n; i++) {
+    const TValue *o = &f->k[i];
+    int tt = ttypetag(o);
+    dumpByte(D, tt);
+    switch (tt) {
+      case LUA_VNUMFLT:
+        dumpNumber(D, fltvalue(o));
+        break;
+      case LUA_VNUMINT:
+        dumpInteger(D, ivalue(o));
+        break;
+      case LUA_VSHRSTR:
+      case LUA_VLNGSTR:
+        dumpString(D, tsvalue(o));
+        break;
+      default:
+        lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE);
+    }
+  }
+}
+
+
+static void dumpProtos (DumpState *D, const Proto *f) {
+  int i;
+  int n = f->sizep;
+  dumpInt(D, n);
+  for (i = 0; i < n; i++)
+    dumpFunction(D, f->p[i], f->source);
+}
+
+
+static void dumpUpvalues (DumpState *D, const Proto *f) {
+  int i, n = f->sizeupvalues;
+  dumpInt(D, n);
+  for (i = 0; i < n; i++) {
+    dumpByte(D, f->upvalues[i].instack);
+    dumpByte(D, f->upvalues[i].idx);
+    dumpByte(D, f->upvalues[i].kind);
+  }
+}
+
+
+static void dumpDebug (DumpState *D, const Proto *f) {
+  int i, n;
+  n = (D->strip) ? 0 : f->sizelineinfo;
+  dumpInt(D, n);
+  dumpVector(D, f->lineinfo, n);
+  n = (D->strip) ? 0 : f->sizeabslineinfo;
+  dumpInt(D, n);
+  for (i = 0; i < n; i++) {
+    dumpInt(D, f->abslineinfo[i].pc);
+    dumpInt(D, f->abslineinfo[i].line);
+  }
+  n = (D->strip) ? 0 : f->sizelocvars;
+  dumpInt(D, n);
+  for (i = 0; i < n; i++) {
+    dumpString(D, f->locvars[i].varname);
+    dumpInt(D, f->locvars[i].startpc);
+    dumpInt(D, f->locvars[i].endpc);
+  }
+  n = (D->strip) ? 0 : f->sizeupvalues;
+  dumpInt(D, n);
+  for (i = 0; i < n; i++)
+    dumpString(D, f->upvalues[i].name);
+}
+
+
+static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
+  if (D->strip || f->source == psource)
+    dumpString(D, NULL);  /* no debug info or same source as its parent */
+  else
+    dumpString(D, f->source);
+  dumpInt(D, f->linedefined);
+  dumpInt(D, f->lastlinedefined);
+  dumpByte(D, f->numparams);
+  dumpByte(D, f->is_vararg);
+  dumpByte(D, f->maxstacksize);
+  dumpCode(D, f);
+  dumpConstants(D, f);
+  dumpUpvalues(D, f);
+  dumpProtos(D, f);
+  dumpDebug(D, f);
+}
+
+
+static void dumpHeader (DumpState *D) {
+  dumpLiteral(D, LUA_SIGNATURE);
+  dumpByte(D, LUAC_VERSION);
+  dumpByte(D, LUAC_FORMAT);
+  dumpLiteral(D, LUAC_DATA);
+  dumpByte(D, sizeof(Instruction));
+  dumpByte(D, sizeof(lua_Integer));
+  dumpByte(D, sizeof(lua_Number));
+  dumpInteger(D, LUAC_INT);
+  dumpNumber(D, LUAC_NUM);
+}
+
+
 /*
 ** dump Lua function as precompiled chunk
 */
-int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
-{
- DumpState D;
- D.L=L;
- D.writer=w;
- D.data=data;
- D.strip=strip;
- D.status=0;
- DumpHeader(&D);
- DumpFunction(f,&D);
- return D.status;
+int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
+              int strip) {
+  DumpState D;
+  D.L = L;
+  D.writer = w;
+  D.data = data;
+  D.strip = strip;
+  D.status = 0;
+  dumpHeader(&D);
+  dumpByte(&D, f->sizeupvalues);
+  dumpFunction(&D, f, NULL);
+  return D.status;
 }
+

3rd/lua/lfunc.c

@@ -1,170 +1,288 @@
 /*
-** $Id: lfunc.c,v 2.30.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lfunc.c $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
 
-
-#include <stddef.h>
-
 #define lfunc_c
 #define LUA_CORE
 
+#include "lprefix.h"
+
+
+#include <stddef.h>
+
 #include "lua.h"
 
+#include "ldebug.h"
+#include "ldo.h"
 #include "lfunc.h"
 #include "lgc.h"
 #include "lmem.h"
 #include "lobject.h"
 #include "lstate.h"
+#include "lstring.h"
 
 
 
-Closure *luaF_newCclosure (lua_State *L, int n) {
-  Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n), NULL, 0)->cl;
-  c->c.nupvalues = cast_byte(n);
+CClosure *luaF_newCclosure (lua_State *L, int nupvals) {
+  GCObject *o = luaC_newobj(L, LUA_VCCL, sizeCclosure(nupvals));
+  CClosure *c = gco2ccl(o);
+  c->nupvalues = cast_byte(nupvals);
   return c;
 }
 
 
-Closure *luaF_newLclosure (lua_State *L, int n) {
-  Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl;
-  c->l.p = NULL;
-  c->l.nupvalues = cast_byte(n);
-  while (n--) c->l.upvals[n] = NULL;
+LClosure *luaF_newLclosure (lua_State *L, int nupvals) {
+  GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals));
+  LClosure *c = gco2lcl(o);
+  c->p = NULL;
+  c->nupvalues = cast_byte(nupvals);
+  while (nupvals--) c->upvals[nupvals] = NULL;
   return c;
 }
 
 
-UpVal *luaF_newupval (lua_State *L) {
-  UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;
-  uv->v = &uv->u.value;
-  setnilvalue(uv->v);
+/*
+** fill a closure with new closed upvalues
+*/
+void luaF_initupvals (lua_State *L, LClosure *cl) {
+  int i;
+  for (i = 0; i < cl->nupvalues; i++) {
+    GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
+    UpVal *uv = gco2upv(o);
+    uv->v.p = &uv->u.value;  /* make it closed */
+    setnilvalue(uv->v.p);
+    cl->upvals[i] = uv;
+    luaC_objbarrier(L, cl, uv);
+  }
+}
+
+
+/*
+** Create a new upvalue at the given level, and link it to the list of
+** open upvalues of 'L' after entry 'prev'.
+**/
+static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) {
+  GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
+  UpVal *uv = gco2upv(o);
+  UpVal *next = *prev;
+  uv->v.p = s2v(level);  /* current value lives in the stack */
+  uv->u.open.next = next;  /* link it to list of open upvalues */
+  uv->u.open.previous = prev;
+  if (next)
+    next->u.open.previous = &uv->u.open.next;
+  *prev = uv;
+  if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
+    L->twups = G(L)->twups;  /* link it to the list */
+    G(L)->twups = L;
+  }
   return uv;
 }
 
 
+/*
+** Find and reuse, or create if it does not exist, an upvalue
+** at the given level.
+*/
 UpVal *luaF_findupval (lua_State *L, StkId level) {
-  global_State *g = G(L);
-  GCObject **pp = &L->openupval;
+  UpVal **pp = &L->openupval;
   UpVal *p;
-  UpVal *uv;
-  while (*pp != NULL && (p = gco2uv(*pp))->v >= level) {
-    GCObject *o = obj2gco(p);
-    lua_assert(p->v != &p->u.value);
-    lua_assert(!isold(o) || isold(obj2gco(L)));
-    if (p->v == level) {  /* found a corresponding upvalue? */
-      if (isdead(g, o))  /* is it dead? */
-        changewhite(o);  /* resurrect it */
-      return p;
-    }
-    pp = &p->next;
+  lua_assert(isintwups(L) || L->openupval == NULL);
+  while ((p = *pp) != NULL && uplevel(p) >= level) {  /* search for it */
+    lua_assert(!isdead(G(L), p));
+    if (uplevel(p) == level)  /* corresponding upvalue? */
+      return p;  /* return it */
+    pp = &p->u.open.next;
   }
-  /* not found: create a new one */
-  uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv;
-  uv->v = level;  /* current value lives in the stack */
-  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
-  uv->u.l.next = g->uvhead.u.l.next;
-  uv->u.l.next->u.l.prev = uv;
-  g->uvhead.u.l.next = uv;
-  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-  return uv;
+  /* not found: create a new upvalue after 'pp' */
+  return newupval(L, level, pp);
 }
 
 
-static void unlinkupval (UpVal *uv) {
-  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
-  uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
-  uv->u.l.prev->u.l.next = uv->u.l.next;
+/*
+** Call closing method for object 'obj' with error message 'err'. The
+** boolean 'yy' controls whether the call is yieldable.
+** (This function assumes EXTRA_STACK.)
+*/
+static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) {
+  StkId top = L->top.p;
+  const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE);
+  setobj2s(L, top, tm);  /* will call metamethod... */
+  setobj2s(L, top + 1, obj);  /* with 'self' as the 1st argument */
+  setobj2s(L, top + 2, err);  /* and error msg. as 2nd argument */
+  L->top.p = top + 3;  /* add function and arguments */
+  if (yy)
+    luaD_call(L, top, 0);
+  else
+    luaD_callnoyield(L, top, 0);
 }
 
 
-void luaF_freeupval (lua_State *L, UpVal *uv) {
-  if (uv->v != &uv->u.value)  /* is it open? */
-    unlinkupval(uv);  /* remove from open list */
-  luaM_free(L, uv);  /* free upvalue */
+/*
+** Check whether object at given level has a close metamethod and raise
+** an error if not.
+*/
+static void checkclosemth (lua_State *L, StkId level) {
+  const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE);
+  if (ttisnil(tm)) {  /* no metamethod? */
+    int idx = cast_int(level - L->ci->func.p);  /* variable index */
+    const char *vname = luaG_findlocal(L, L->ci, idx, NULL);
+    if (vname == NULL) vname = "?";
+    luaG_runerror(L, "variable '%s' got a non-closable value", vname);
+  }
 }
 
 
-void luaF_close (lua_State *L, StkId level) {
+/*
+** Prepare and call a closing method.
+** If status is CLOSEKTOP, the call to the closing method will be pushed
+** at the top of the stack. Otherwise, values can be pushed right after
+** the 'level' of the upvalue being closed, as everything after that
+** won't be used again.
+*/
+static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) {
+  TValue *uv = s2v(level);  /* value being closed */
+  TValue *errobj;
+  if (status == CLOSEKTOP)
+    errobj = &G(L)->nilvalue;  /* error object is nil */
+  else {  /* 'luaD_seterrorobj' will set top to level + 2 */
+    errobj = s2v(level + 1);  /* error object goes after 'uv' */
+    luaD_seterrorobj(L, status, level + 1);  /* set error object */
+  }
+  callclosemethod(L, uv, errobj, yy);
+}
+
+
+/*
+** Maximum value for deltas in 'tbclist', dependent on the type
+** of delta. (This macro assumes that an 'L' is in scope where it
+** is used.)
+*/
+#define MAXDELTA  \
+	((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1)
+
+
+/*
+** Insert a variable in the list of to-be-closed variables.
+*/
+void luaF_newtbcupval (lua_State *L, StkId level) {
+  lua_assert(level > L->tbclist.p);
+  if (l_isfalse(s2v(level)))
+    return;  /* false doesn't need to be closed */
+  checkclosemth(L, level);  /* value must have a close method */
+  while (cast_uint(level - L->tbclist.p) > MAXDELTA) {
+    L->tbclist.p += MAXDELTA;  /* create a dummy node at maximum delta */
+    L->tbclist.p->tbclist.delta = 0;
+  }
+  level->tbclist.delta = cast(unsigned short, level - L->tbclist.p);
+  L->tbclist.p = level;
+}
+
+
+void luaF_unlinkupval (UpVal *uv) {
+  lua_assert(upisopen(uv));
+  *uv->u.open.previous = uv->u.open.next;
+  if (uv->u.open.next)
+    uv->u.open.next->u.open.previous = uv->u.open.previous;
+}
+
+
+/*
+** Close all upvalues up to the given stack level.
+*/
+void luaF_closeupval (lua_State *L, StkId level) {
   UpVal *uv;
-  global_State *g = G(L);
-  while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) {
-    GCObject *o = obj2gco(uv);
-    lua_assert(!isblack(o) && uv->v != &uv->u.value);
-    L->openupval = uv->next;  /* remove from `open' list */
-    if (isdead(g, o))
-      luaF_freeupval(L, uv);  /* free upvalue */
-    else {
-      unlinkupval(uv);  /* remove upvalue from 'uvhead' list */
-      setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
-      uv->v = &uv->u.value;  /* now current value lives here */
-      gch(o)->next = g->allgc;  /* link upvalue into 'allgc' list */
-      g->allgc = o;
-      luaC_checkupvalcolor(g, uv);
+  StkId upl;  /* stack index pointed by 'uv' */
+  while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) {
+    TValue *slot = &uv->u.value;  /* new position for value */
+    lua_assert(uplevel(uv) < L->top.p);
+    luaF_unlinkupval(uv);  /* remove upvalue from 'openupval' list */
+    setobj(L, slot, uv->v.p);  /* move value to upvalue slot */
+    uv->v.p = slot;  /* now current value lives here */
+    if (!iswhite(uv)) {  /* neither white nor dead? */
+      nw2black(uv);  /* closed upvalues cannot be gray */
+      luaC_barrier(L, uv, slot);
     }
   }
 }
 
 
-Proto *luaF_newproto (lua_State *L, SharedProto *sp) {
-  Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto), NULL, 0)->p;
+/*
+** Remove first element from the tbclist plus its dummy nodes.
+*/
+static void poptbclist (lua_State *L) {
+  StkId tbc = L->tbclist.p;
+  lua_assert(tbc->tbclist.delta > 0);  /* first element cannot be dummy */
+  tbc -= tbc->tbclist.delta;
+  while (tbc > L->stack.p && tbc->tbclist.delta == 0)
+    tbc -= MAXDELTA;  /* remove dummy nodes */
+  L->tbclist.p = tbc;
+}
+
+
+/*
+** Close all upvalues and to-be-closed variables up to the given stack
+** level. Return restored 'level'.
+*/
+StkId luaF_close (lua_State *L, StkId level, int status, int yy) {
+  ptrdiff_t levelrel = savestack(L, level);
+  luaF_closeupval(L, level);  /* first, close the upvalues */
+  while (L->tbclist.p >= level) {  /* traverse tbc's down to that level */
+    StkId tbc = L->tbclist.p;  /* get variable index */
+    poptbclist(L);  /* remove it from list */
+    prepcallclosemth(L, tbc, status, yy);  /* close variable */
+    level = restorestack(L, levelrel);
+  }
+  return level;
+}
+
+
+Proto *luaF_newproto (lua_State *L) {
+  GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto));
+  Proto *f = gco2p(o);
   f->k = NULL;
-  f->sp = NULL;
+  f->sizek = 0;
   f->p = NULL;
-  f->cache = NULL;
-
-  if (sp == NULL) {
-    sp = luaM_new(L, SharedProto);
-    sp->l_G = G(L);
-    sp->sizek = 0;
-    sp->sizep = 0;
-    sp->code = NULL;
-    sp->sizecode = 0;
-    sp->lineinfo = NULL;
-    sp->sizelineinfo = 0;
-    sp->upvalues = NULL;
-    sp->sizeupvalues = 0;
-    sp->numparams = 0;
-    sp->is_vararg = 0;
-    sp->maxstacksize = 0;
-    sp->locvars = NULL;
-    sp->sizelocvars = 0;
-    sp->linedefined = 0;
-    sp->lastlinedefined = 0;
-    sp->source = NULL;
-  }
-  f->sp = sp;
-
+  f->sizep = 0;
+  f->code = NULL;
+  f->sizecode = 0;
+  f->lineinfo = NULL;
+  f->sizelineinfo = 0;
+  f->abslineinfo = NULL;
+  f->sizeabslineinfo = 0;
+  f->upvalues = NULL;
+  f->sizeupvalues = 0;
+  f->numparams = 0;
+  f->is_vararg = 0;
+  f->maxstacksize = 0;
+  f->locvars = NULL;
+  f->sizelocvars = 0;
+  f->linedefined = 0;
+  f->lastlinedefined = 0;
+  f->source = NULL;
   return f;
 }
 
-static void
-luaF_freesharedproto (lua_State *L, SharedProto *f) {
-  if (f == NULL || G(L) != f->l_G)
-    return;
+
+void luaF_freeproto (lua_State *L, Proto *f) {
   luaM_freearray(L, f->code, f->sizecode);
+  luaM_freearray(L, f->p, f->sizep);
+  luaM_freearray(L, f->k, f->sizek);
   luaM_freearray(L, f->lineinfo, f->sizelineinfo);
+  luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo);
   luaM_freearray(L, f->locvars, f->sizelocvars);
   luaM_freearray(L, f->upvalues, f->sizeupvalues);
   luaM_free(L, f);
 }
 
-void luaF_freeproto (lua_State *L, Proto *f) {
-  luaM_freearray(L, f->k, f->sp->sizek);
-  luaM_freearray(L, f->p, f->sp->sizep);
-  luaF_freesharedproto(L, f->sp);
-  luaM_free(L, f);
-}
-
 
 /*
-** Look for n-th local variable at line `line' in function `func'.
+** Look for n-th local variable at line 'line' in function 'func'.
 ** Returns NULL if not found.
 */
-const char *luaF_getlocalname (const Proto *fp, int local_number, int pc) {
+const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
   int i;
-  const SharedProto *f = fp->sp;
   for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
     if (pc < f->locvars[i].endpc) {  /* is variable active? */
       local_number--;
@@ -175,3 +293,20 @@ const char *luaF_getlocalname (const Proto *fp, int local_number, int pc) {
   return NULL;  /* not found */
 }
 
+void luaF_shareproto (Proto *f) {
+  int i;
+  if (f == NULL || isshared(f))
+    return;
+  makeshared(f);
+  luaS_share(f->source);
+  for (i = 0; i < f->sizek; i++) {
+    if (ttype(&f->k[i]) == LUA_TSTRING)
+      luaS_share(tsvalue(&f->k[i]));
+  }
+  for (i = 0; i < f->sizeupvalues; i++)
+    luaS_share(f->upvalues[i].name);
+  for (i = 0; i < f->sizelocvars; i++)
+    luaS_share(f->locvars[i].varname);
+  for (i = 0; i < f->sizep; i++)
+    luaF_shareproto(f->p[i]);
+}

3rd/lua/lfunc.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lfunc.h $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -11,23 +11,54 @@
 #include "lobject.h"
 
 
-#define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
-                         cast(int, sizeof(TValue)*((n)-1)))
+#define sizeCclosure(n)	(cast_int(offsetof(CClosure, upvalue)) + \
+                         cast_int(sizeof(TValue)) * (n))
 
-#define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
-                         cast(int, sizeof(TValue *)*((n)-1)))
+#define sizeLclosure(n)	(cast_int(offsetof(LClosure, upvals)) + \
+                         cast_int(sizeof(TValue *)) * (n))
 
 
-LUAI_FUNC Proto *luaF_newproto (lua_State *L, SharedProto *sp);
-LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems);
-LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems);
-LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
+/* test whether thread is in 'twups' list */
+#define isintwups(L)	(L->twups != L)
+
+
+/*
+** maximum number of upvalues in a closure (both C and Lua). (Value
+** must fit in a VM register.)
+*/
+#define MAXUPVAL	255
+
+
+#define upisopen(up)	((up)->v.p != &(up)->u.value)
+
+
+#define uplevel(up)	check_exp(upisopen(up), cast(StkId, (up)->v.p))
+
+
+/*
+** maximum number of misses before giving up the cache of closures
+** in prototypes
+*/
+#define MAXMISS		10
+
+
+
+/* special status to close upvalues preserving the top of the stack */
+#define CLOSEKTOP	(-1)
+
+
+LUAI_FUNC Proto *luaF_newproto (lua_State *L);
+LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nupvals);
+LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nupvals);
+LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
 LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
-LUAI_FUNC void luaF_close (lua_State *L, StkId level);
+LUAI_FUNC void luaF_newtbcupval (lua_State *L, StkId level);
+LUAI_FUNC void luaF_closeupval (lua_State *L, StkId level);
+LUAI_FUNC StkId luaF_close (lua_State *L, StkId level, int status, int yy);
+LUAI_FUNC void luaF_unlinkupval (UpVal *uv);
 LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
-LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
 LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
                                          int pc);
-
+LUAI_FUNC void luaF_shareproto (Proto *func);
 
 #endif

3rd/lua/lgc.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lgc.h $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -12,68 +12,52 @@
 #include "lstate.h"
 
 /*
-** Collectable objects may have one of three colors: white, which
-** means the object is not marked; gray, which means the
-** object is marked, but its references may be not marked; and
-** black, which means that the object and all its references are marked.
-** The main invariant of the garbage collector, while marking objects,
-** is that a black object can never point to a white one. Moreover,
-** any gray object must be in a "gray list" (gray, grayagain, weak,
-** allweak, ephemeron) so that it can be visited again before finishing
-** the collection cycle. These lists have no meaning when the invariant
-** is not being enforced (e.g., sweep phase).
+** Collectable objects may have one of three colors: white, which means
+** the object is not marked; gray, which means the object is marked, but
+** its references may be not marked; and black, which means that the
+** object and all its references are marked.  The main invariant of the
+** garbage collector, while marking objects, is that a black object can
+** never point to a white one. Moreover, any gray object must be in a
+** "gray list" (gray, grayagain, weak, allweak, ephemeron) so that it
+** can be visited again before finishing the collection cycle. (Open
+** upvalues are an exception to this rule.)  These lists have no meaning
+** when the invariant is not being enforced (e.g., sweep phase).
 */
 
 
-
-/* how much to allocate before next GC step */
-#if !defined(GCSTEPSIZE)
-/* ~100 small strings */
-#define GCSTEPSIZE	(cast_int(100 * sizeof(TString)))
-#endif
-
-
 /*
 ** Possible states of the Garbage Collector
 */
 #define GCSpropagate	0
-#define GCSatomic	1
-#define GCSsweepstring	2
-#define GCSsweepudata	3
-#define GCSsweep	4
-#define GCSpause	5
+#define GCSenteratomic	1
+#define GCSatomic	2
+#define GCSswpallgc	3
+#define GCSswpfinobj	4
+#define GCSswptobefnz	5
+#define GCSswpend	6
+#define GCScallfin	7
+#define GCSpause	8
 
 
 #define issweepphase(g)  \
-	(GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep)
+	(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
 
-#define isgenerational(g)	((g)->gckind == KGC_GEN)
 
 /*
-** macros to tell when main invariant (white objects cannot point to black
-** ones) must be kept. During a non-generational collection, the sweep
+** macro to tell when main invariant (white objects cannot point to black
+** ones) must be kept. During a collection, the sweep
 ** phase may break the invariant, as objects turned white may point to
 ** still-black objects. The invariant is restored when sweep ends and
-** all objects are white again. During a generational collection, the
-** invariant must be kept all times.
+** all objects are white again.
 */
 
-#define keepinvariant(g)	(isgenerational(g) || g->gcstate <= GCSatomic)
-
-
-/*
-** Outside the collector, the state in generational mode is kept in
-** 'propagate', so 'keepinvariant' is always true.
-*/
-#define keepinvariantout(g)  \
-  check_exp(g->gcstate == GCSpropagate || !isgenerational(g),  \
-            g->gcstate <= GCSatomic)
+#define keepinvariant(g)	((g)->gcstate <= GCSatomic)
 
 
 /*
 ** some useful bit tricks
 */
-#define resetbits(x,m)		((x) &= cast(lu_byte, ~(m)))
+#define resetbits(x,m)		((x) &= cast_byte(~(m)))
 #define setbits(x,m)		((x) |= (m))
 #define testbits(x,m)		((x) & (m))
 #define bitmask(b)		(1<<(b))
@@ -83,75 +67,141 @@
 #define testbit(x,b)		testbits(x, bitmask(b))
 
 
-/* Layout for bit use in `marked' field: */
-#define WHITE0BIT	0  /* object is white (type 0) */
-#define WHITE1BIT	1  /* object is white (type 1) */
-#define BLACKBIT	2  /* object is black */
-#define FINALIZEDBIT	3  /* object has been separated for finalization */
-#define SEPARATED	4  /* object is in 'finobj' list or in 'tobefnz' */
-#define FIXEDBIT	5  /* object is fixed (should not be collected) */
-#define OLDBIT		6  /* object is old (only in generational mode) */
-/* bit 7 is currently used by tests (luaL_checkmemory) */
+/*
+** Layout for bit use in 'marked' field. First three bits are
+** used for object "age" in generational mode. Last bit is used
+** by tests.
+*/
+#define WHITE0BIT	3  /* object is white (type 0) */
+#define WHITE1BIT	4  /* object is white (type 1) */
+#define BLACKBIT	5  /* object is black */
+#define FINALIZEDBIT	6  /* object has been marked for finalization */
+
+#define TESTBIT		7
+
+
 
 #define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
 
 
-#define iswhite(x)      testbits((x)->gch.marked, WHITEBITS)
-#define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
+#define iswhite(x)      testbits((x)->marked, WHITEBITS)
+#define isblack(x)      testbit((x)->marked, BLACKBIT)
 #define isgray(x)  /* neither white nor black */  \
-	(!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT)))
+	(!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))
 
-#define isold(x)	testbit((x)->gch.marked, OLDBIT)
+#define tofinalize(x)	testbit((x)->marked, FINALIZEDBIT)
 
-/* MOVE OLD rule: whenever an object is moved to the beginning of
-   a GC list, its old bit must be cleared */
-#define resetoldbit(o)	resetbit((o)->gch.marked, OLDBIT)
+#define otherwhite(g)	((g)->currentwhite ^ WHITEBITS)
+#define isdeadm(ow,m)	((m) & (ow))
+#define isdead(g,v)	isdeadm(otherwhite(g), (v)->marked)
 
-#define otherwhite(g)	(g->currentwhite ^ WHITEBITS)
-#define isdeadm(ow,m)	(!(((m) ^ WHITEBITS) & (ow)))
-#define isdead(g,v)	isdeadm(otherwhite(g), (v)->gch.marked)
+#define changewhite(x)	((x)->marked ^= WHITEBITS)
+#define nw2black(x)  \
+	check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT))
 
-#define changewhite(x)	((x)->gch.marked ^= WHITEBITS)
-#define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)
-
-#define valiswhite(x)	(iscollectable(x) && iswhite(gcvalue(x)))
-
-#define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
+#define luaC_white(g)	cast_byte((g)->currentwhite & WHITEBITS)
 
 
-#define luaC_condGC(L,c) \
-	{if (G(L)->GCdebt > 0) {c;}; condchangemem(L);}
-#define luaC_checkGC(L)		luaC_condGC(L, luaC_step(L);)
+/* object age in generational mode */
+#define G_NEW		0	/* created in current cycle */
+#define G_SURVIVAL	1	/* created in previous cycle */
+#define G_OLD0		2	/* marked old by frw. barrier in this cycle */
+#define G_OLD1		3	/* first full cycle as old */
+#define G_OLD		4	/* really old object (not to be visited) */
+#define G_TOUCHED1	5	/* old object touched this cycle */
+#define G_TOUCHED2	6	/* old object touched in previous cycle */
+#define G_SHARED	7	/* object is shared */
+
+#define AGEBITS		7  /* all age bits (111) */
+
+#define getage(o)	((o)->marked & AGEBITS)
+#define setage(o,a)  ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a))
+#define isold(o)	(getage(o) > G_SURVIVAL)
+
+#define isshared(x)     (getage(x) == G_SHARED)
+#define makeshared(x)   setage(x, G_SHARED)
+#define ispurewhite(x)  (iswhite(x) && !isshared(x))
+
+#define changeage(o,f,t)  \
+	check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t)))
 
 
-#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
-	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }
+/* Default Values for GC parameters */
+#define LUAI_GENMAJORMUL         100
+#define LUAI_GENMINORMUL         20
 
-#define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
-	luaC_barrierback_(L,p); }
+/* wait memory to double before starting new cycle */
+#define LUAI_GCPAUSE    200
 
-#define luaC_objbarrier(L,p,o)  \
-	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
-		luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
+/*
+** some gc parameters are stored divided by 4 to allow a maximum value
+** up to 1023 in a 'lu_byte'.
+*/
+#define getgcparam(p)	((p) * 4)
+#define setgcparam(p,v)	((p) = (v) / 4)
 
-#define luaC_objbarrierback(L,p,o)  \
-   { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); }
+#define LUAI_GCMUL      100
 
-#define luaC_barrierproto(L,p,c) \
-   { if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); }
+/* how much to allocate before next GC step (log2) */
+#define LUAI_GCSTEPSIZE 13      /* 8 KB */
 
+
+/*
+** Check whether the declared GC mode is generational. While in
+** generational mode, the collector can go temporarily to incremental
+** mode to improve performance. This is signaled by 'g->lastatomic != 0'.
+*/
+#define isdecGCmodegen(g)	(g->gckind == KGC_GEN || g->lastatomic != 0)
+
+
+/*
+** Control when GC is running:
+*/
+#define GCSTPUSR	1  /* bit true when GC stopped by user */
+#define GCSTPGC		2  /* bit true when GC stopped by itself */
+#define GCSTPCLS	4  /* bit true when closing Lua state */
+#define gcrunning(g)	((g)->gcstp == 0)
+
+
+/*
+** Does one step of collection when debt becomes positive. 'pre'/'pos'
+** allows some adjustments to be done only when needed. macro
+** 'condchangemem' is used only for heavy tests (forcing a full
+** GC cycle on every opportunity)
+*/
+#define luaC_condGC(L,pre,pos) \
+	{ if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
+	  condchangemem(L,pre,pos); }
+
+/* more often than not, 'pre'/'pos' are empty */
+#define luaC_checkGC(L)		luaC_condGC(L,(void)0,(void)0)
+
+
+#define luaC_objbarrier(L,p,o) (  \
+	(isblack(p) && ispurewhite(o)) ? \
+	luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
+
+#define luaC_barrier(L,p,v) (  \
+	iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0))
+
+#define luaC_objbarrierback(L,p,o) (  \
+	(isblack(p) && ispurewhite(o)) ? luaC_barrierback_(L,p) : cast_void(0))
+
+#define luaC_barrierback(L,p,v) (  \
+	iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0))
+
+LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
 LUAI_FUNC void luaC_freeallobjects (lua_State *L);
 LUAI_FUNC void luaC_step (lua_State *L);
-LUAI_FUNC void luaC_forcestep (lua_State *L);
 LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
 LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
-LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz,
-                                 GCObject **list, int offset);
+LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
+LUAI_FUNC GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz,
+                                                 size_t offset);
 LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
 LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
-LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c);
 LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
-LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv);
-LUAI_FUNC void luaC_changemode (lua_State *L, int mode);
+LUAI_FUNC void luaC_changemode (lua_State *L, int newmode);
+
 
 #endif

3rd/lua/linit.c

@@ -1,20 +1,33 @@
 /*
-** $Id: linit.c,v 1.32.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: linit.c $
 ** Initialization of libraries for lua.c and other clients
 ** See Copyright Notice in lua.h
 */
 
 
+#define linit_c
+#define LUA_LIB
+
 /*
 ** If you embed Lua in your program and need to open the standard
 ** libraries, call luaL_openlibs in your program. If you need a
 ** different set of libraries, copy this file to your project and edit
 ** it to suit your needs.
+**
+** You can also *preload* libraries, so that a later 'require' can
+** open the library, which is already linked to the application.
+** For that, do the following code:
+**
+**  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
+**  lua_pushcfunction(L, luaopen_modname);
+**  lua_setfield(L, -2, modname);
+**  lua_pop(L, 1);  // remove PRELOAD table
 */
 
+#include "lprefix.h"
 
-#define linit_c
-#define LUA_LIB
+
+#include <stddef.h>
 
 #include "lua.h"
 
@@ -27,41 +40,26 @@
 ** program
 */
 static const luaL_Reg loadedlibs[] = {
-  {"_G", luaopen_base},
+  {LUA_GNAME, luaopen_base},
   {LUA_LOADLIBNAME, luaopen_package},
   {LUA_COLIBNAME, luaopen_coroutine},
   {LUA_TABLIBNAME, luaopen_table},
   {LUA_IOLIBNAME, luaopen_io},
   {LUA_OSLIBNAME, luaopen_os},
   {LUA_STRLIBNAME, luaopen_string},
-  {LUA_BITLIBNAME, luaopen_bit32},
   {LUA_MATHLIBNAME, luaopen_math},
+  {LUA_UTF8LIBNAME, luaopen_utf8},
   {LUA_DBLIBNAME, luaopen_debug},
   {NULL, NULL}
 };
 
 
-/*
-** these libs are preloaded and must be required before used
-*/
-static const luaL_Reg preloadedlibs[] = {
-  {NULL, NULL}
-};
-
-
 LUALIB_API void luaL_openlibs (lua_State *L) {
   const luaL_Reg *lib;
-  /* call open functions from 'loadedlibs' and set results to global table */
+  /* "require" functions from 'loadedlibs' and set results to global table */
   for (lib = loadedlibs; lib->func; lib++) {
     luaL_requiref(L, lib->name, lib->func, 1);
     lua_pop(L, 1);  /* remove lib */
   }
-  /* add open functions from 'preloadedlibs' into 'package.preload' table */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
-  for (lib = preloadedlibs; lib->func; lib++) {
-    lua_pushcfunction(L, lib->func);
-    lua_setfield(L, -2, lib->name);
-  }
-  lua_pop(L, 1);  /* remove _PRELOAD table */
 }
 

3rd/lua/liolib.c

@@ -1,120 +1,153 @@
 /*
-** $Id: liolib.c,v 2.112.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: liolib.c $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
 
+#define liolib_c
+#define LUA_LIB
 
-/*
-** This definition must come before the inclusion of 'stdio.h'; it
-** should not affect non-POSIX systems
-*/
-#if !defined(_FILE_OFFSET_BITS)
-#define	_LARGEFILE_SOURCE	1
-#define _FILE_OFFSET_BITS	64
-#endif
+#include "lprefix.h"
 
 
+#include <ctype.h>
 #include <errno.h>
+#include <locale.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define liolib_c
-#define LUA_LIB
-
 #include "lua.h"
 
 #include "lauxlib.h"
 #include "lualib.h"
 
 
-#if !defined(lua_checkmode)
+
 
 /*
-** Check whether 'mode' matches '[rwa]%+?b?'.
 ** Change this macro to accept other modes for 'fopen' besides
 ** the standard ones.
 */
-#define lua_checkmode(mode) \
-	(*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&	\
-	(*mode != '+' || ++mode) &&  /* skip if char is '+' */	\
-	(*mode != 'b' || ++mode) &&  /* skip if char is 'b' */	\
-	(*mode == '\0'))
+#if !defined(l_checkmode)
+
+/* accepted extensions to 'mode' in 'fopen' */
+#if !defined(L_MODEEXT)
+#define L_MODEEXT	"b"
+#endif
+
+/* Check whether 'mode' matches '[rwa]%+?[L_MODEEXT]*' */
+static int l_checkmode (const char *mode) {
+  return (*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&
+         (*mode != '+' || ((void)(++mode), 1)) &&  /* skip if char is '+' */
+         (strspn(mode, L_MODEEXT) == strlen(mode)));  /* check extensions */
+}
 
 #endif
 
 /*
 ** {======================================================
-** lua_popen spawns a new process connected to the current
+** l_popen spawns a new process connected to the current
 ** one through the file streams.
 ** =======================================================
 */
 
-#if !defined(lua_popen)	/* { */
+#if !defined(l_popen)		/* { */
 
-#if defined(LUA_USE_POPEN)	/* { */
+#if defined(LUA_USE_POSIX)	/* { */
 
-#define lua_popen(L,c,m)	((void)L, fflush(NULL), popen(c,m))
-#define lua_pclose(L,file)	((void)L, pclose(file))
+#define l_popen(L,c,m)		(fflush(NULL), popen(c,m))
+#define l_pclose(L,file)	(pclose(file))
 
-#elif defined(LUA_WIN)		/* }{ */
+#elif defined(LUA_USE_WINDOWS)	/* }{ */
 
-#define lua_popen(L,c,m)		((void)L, _popen(c,m))
-#define lua_pclose(L,file)		((void)L, _pclose(file))
+#define l_popen(L,c,m)		(_popen(c,m))
+#define l_pclose(L,file)	(_pclose(file))
 
+#if !defined(l_checkmodep)
+/* Windows accepts "[rw][bt]?" as valid modes */
+#define l_checkmodep(m)	((m[0] == 'r' || m[0] == 'w') && \
+  (m[1] == '\0' || ((m[1] == 'b' || m[1] == 't') && m[2] == '\0')))
+#endif
 
 #else				/* }{ */
 
-#define lua_popen(L,c,m)		((void)((void)c, m),  \
-		luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
-#define lua_pclose(L,file)		((void)((void)L, file), -1)
-
+/* ISO C definitions */
+#define l_popen(L,c,m)  \
+	  ((void)c, (void)m, \
+	  luaL_error(L, "'popen' not supported"), \
+	  (FILE*)0)
+#define l_pclose(L,file)		((void)L, (void)file, -1)
 
 #endif				/* } */
 
-#endif			/* } */
+#endif				/* } */
+
+
+#if !defined(l_checkmodep)
+/* By default, Lua accepts only "r" or "w" as valid modes */
+#define l_checkmodep(m)        ((m[0] == 'r' || m[0] == 'w') && m[1] == '\0')
+#endif
 
 /* }====================================================== */
 
 
+#if !defined(l_getc)		/* { */
+
+#if defined(LUA_USE_POSIX)
+#define l_getc(f)		getc_unlocked(f)
+#define l_lockfile(f)		flockfile(f)
+#define l_unlockfile(f)		funlockfile(f)
+#else
+#define l_getc(f)		getc(f)
+#define l_lockfile(f)		((void)0)
+#define l_unlockfile(f)		((void)0)
+#endif
+
+#endif				/* } */
+
+
 /*
 ** {======================================================
-** lua_fseek: configuration for longer offsets
+** l_fseek: configuration for longer offsets
 ** =======================================================
 */
 
-#if !defined(lua_fseek)	&& !defined(LUA_ANSI)	/* { */
+#if !defined(l_fseek)		/* { */
 
 #if defined(LUA_USE_POSIX)	/* { */
 
+#include <sys/types.h>
+
 #define l_fseek(f,o,w)		fseeko(f,o,w)
 #define l_ftell(f)		ftello(f)
 #define l_seeknum		off_t
 
-#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \
+#elif defined(LUA_USE_WINDOWS) && !defined(_CRTIMP_TYPEINFO) \
    && defined(_MSC_VER) && (_MSC_VER >= 1400)	/* }{ */
-/* Windows (but not DDK) and Visual C++ 2005 or higher */
 
+/* Windows (but not DDK) and Visual C++ 2005 or higher */
 #define l_fseek(f,o,w)		_fseeki64(f,o,w)
 #define l_ftell(f)		_ftelli64(f)
 #define l_seeknum		__int64
 
-#endif	/* } */
+#else				/* }{ */
 
-#endif			/* } */
-
-
-#if !defined(l_fseek)		/* default definitions */
+/* ISO C definitions */
 #define l_fseek(f,o,w)		fseek(f,o,w)
 #define l_ftell(f)		ftell(f)
 #define l_seeknum		long
-#endif
+
+#endif				/* } */
+
+#endif				/* } */
 
 /* }====================================================== */
 
 
+
 #define IO_PREFIX	"_IO_"
+#define IOPREF_LEN	(sizeof(IO_PREFIX)/sizeof(char) - 1)
 #define IO_INPUT	(IO_PREFIX "input")
 #define IO_OUTPUT	(IO_PREFIX "output")
 
@@ -132,7 +165,7 @@ static int io_type (lua_State *L) {
   luaL_checkany(L, 1);
   p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE);
   if (p == NULL)
-    lua_pushnil(L);  /* not a file */
+    luaL_pushfail(L);  /* not a file */
   else if (isclosed(p))
     lua_pushliteral(L, "closed file");
   else
@@ -153,7 +186,7 @@ static int f_tostring (lua_State *L) {
 
 static FILE *tofile (lua_State *L) {
   LStream *p = tolstream(L);
-  if (isclosed(p))
+  if (l_unlikely(isclosed(p)))
     luaL_error(L, "attempt to use a closed file");
   lua_assert(p->f);
   return p->f;
@@ -161,34 +194,44 @@ static FILE *tofile (lua_State *L) {
 
 
 /*
-** When creating file handles, always creates a `closed' file handle
+** When creating file handles, always creates a 'closed' file handle
 ** before opening the actual file; so, if there is a memory error, the
-** file is not left opened.
+** handle is in a consistent state.
 */
 static LStream *newprefile (lua_State *L) {
-  LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream));
+  LStream *p = (LStream *)lua_newuserdatauv(L, sizeof(LStream), 0);
   p->closef = NULL;  /* mark file handle as 'closed' */
   luaL_setmetatable(L, LUA_FILEHANDLE);
   return p;
 }
 
 
+/*
+** Calls the 'close' function from a file handle. The 'volatile' avoids
+** a bug in some versions of the Clang compiler (e.g., clang 3.0 for
+** 32 bits).
+*/
 static int aux_close (lua_State *L) {
   LStream *p = tolstream(L);
-  lua_CFunction cf = p->closef;
+  volatile lua_CFunction cf = p->closef;
   p->closef = NULL;  /* mark stream as closed */
   return (*cf)(L);  /* close it */
 }
 
 
-static int io_close (lua_State *L) {
-  if (lua_isnone(L, 1))  /* no argument? */
-    lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use standard output */
+static int f_close (lua_State *L) {
   tofile(L);  /* make sure argument is an open stream */
   return aux_close(L);
 }
 
 
+static int io_close (lua_State *L) {
+  if (lua_isnone(L, 1))  /* no argument? */
+    lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use default output */
+  return f_close(L);
+}
+
+
 static int f_gc (lua_State *L) {
   LStream *p = tolstream(L);
   if (!isclosed(p) && p->f != NULL)
@@ -218,8 +261,8 @@ static LStream *newfile (lua_State *L) {
 static void opencheck (lua_State *L, const char *fname, const char *mode) {
   LStream *p = newfile(L);
   p->f = fopen(fname, mode);
-  if (p->f == NULL)
-    luaL_error(L, "cannot open file " LUA_QS " (%s)", fname, strerror(errno));
+  if (l_unlikely(p->f == NULL))
+    luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno));
 }
 
 
@@ -228,7 +271,7 @@ static int io_open (lua_State *L) {
   const char *mode = luaL_optstring(L, 2, "r");
   LStream *p = newfile(L);
   const char *md = mode;  /* to traverse/check mode */
-  luaL_argcheck(L, lua_checkmode(md), 2, "invalid mode");
+  luaL_argcheck(L, l_checkmode(md), 2, "invalid mode");
   p->f = fopen(filename, mode);
   return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
 }
@@ -239,7 +282,8 @@ static int io_open (lua_State *L) {
 */
 static int io_pclose (lua_State *L) {
   LStream *p = tolstream(L);
-  return luaL_execresult(L, lua_pclose(L, p->f));
+  errno = 0;
+  return luaL_execresult(L, l_pclose(L, p->f));
 }
 
 
@@ -247,7 +291,8 @@ static int io_popen (lua_State *L) {
   const char *filename = luaL_checkstring(L, 1);
   const char *mode = luaL_optstring(L, 2, "r");
   LStream *p = newprefile(L);
-  p->f = lua_popen(L, filename, mode);
+  luaL_argcheck(L, l_checkmodep(mode), 2, "invalid mode");
+  p->f = l_popen(L, filename, mode);
   p->closef = &io_pclose;
   return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
 }
@@ -264,8 +309,8 @@ static FILE *getiofile (lua_State *L, const char *findex) {
   LStream *p;
   lua_getfield(L, LUA_REGISTRYINDEX, findex);
   p = (LStream *)lua_touserdata(L, -1);
-  if (isclosed(p))
-    luaL_error(L, "standard %s file is closed", findex + strlen(IO_PREFIX));
+  if (l_unlikely(isclosed(p)))
+    luaL_error(L, "default %s file is closed", findex + IOPREF_LEN);
   return p->f;
 }
 
@@ -300,15 +345,28 @@ static int io_output (lua_State *L) {
 static int io_readline (lua_State *L);
 
 
+/*
+** maximum number of arguments to 'f:lines'/'io.lines' (it + 3 must fit
+** in the limit for upvalues of a closure)
+*/
+#define MAXARGLINE	250
+
+/*
+** Auxiliary function to create the iteration function for 'lines'.
+** The iteration function is a closure over 'io_readline', with
+** the following upvalues:
+** 1) The file being read (first value in the stack)
+** 2) the number of arguments to read
+** 3) a boolean, true iff file has to be closed when finished ('toclose')
+** *) a variable number of format arguments (rest of the stack)
+*/
 static void aux_lines (lua_State *L, int toclose) {
-  int i;
   int n = lua_gettop(L) - 1;  /* number of arguments to read */
-  /* ensure that arguments will fit here and into 'io_readline' stack */
-  luaL_argcheck(L, n <= LUA_MINSTACK - 3, LUA_MINSTACK - 3, "too many options");
-  lua_pushvalue(L, 1);  /* file handle */
+  luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments");
+  lua_pushvalue(L, 1);  /* file */
   lua_pushinteger(L, n);  /* number of arguments to read */
   lua_pushboolean(L, toclose);  /* close/not close file when finished */
-  for (i = 1; i <= n; i++) lua_pushvalue(L, i + 1);  /* copy arguments */
+  lua_rotate(L, 2, 3);  /* move the three values to their positions */
   lua_pushcclosure(L, io_readline, 3 + n);
 }
 
@@ -320,6 +378,11 @@ static int f_lines (lua_State *L) {
 }
 
 
+/*
+** Return an iteration function for 'io.lines'. If file has to be
+** closed, also returns the file itself as a second result (to be
+** closed as the state at the exit of a generic for).
+*/
 static int io_lines (lua_State *L) {
   int toclose;
   if (lua_isnone(L, 1)) lua_pushnil(L);  /* at least one argument */
@@ -335,8 +398,15 @@ static int io_lines (lua_State *L) {
     lua_replace(L, 1);  /* put file at index 1 */
     toclose = 1;  /* close it after iteration */
   }
-  aux_lines(L, toclose);
-  return 1;
+  aux_lines(L, toclose);  /* push iteration function */
+  if (toclose) {
+    lua_pushnil(L);  /* state */
+    lua_pushnil(L);  /* control */
+    lua_pushvalue(L, 1);  /* file is the to-be-closed variable (4th result) */
+    return 4;
+  }
+  else
+    return 1;
 }
 
 
@@ -347,13 +417,91 @@ static int io_lines (lua_State *L) {
 */
 
 
-static int read_number (lua_State *L, FILE *f) {
-  lua_Number d;
-  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
-    lua_pushnumber(L, d);
-    return 1;
+/* maximum length of a numeral */
+#if !defined (L_MAXLENNUM)
+#define L_MAXLENNUM     200
+#endif
+
+
+/* auxiliary structure used by 'read_number' */
+typedef struct {
+  FILE *f;  /* file being read */
+  int c;  /* current character (look ahead) */
+  int n;  /* number of elements in buffer 'buff' */
+  char buff[L_MAXLENNUM + 1];  /* +1 for ending '\0' */
+} RN;
+
+
+/*
+** Add current char to buffer (if not out of space) and read next one
+*/
+static int nextc (RN *rn) {
+  if (l_unlikely(rn->n >= L_MAXLENNUM)) {  /* buffer overflow? */
+    rn->buff[0] = '\0';  /* invalidate result */
+    return 0;  /* fail */
   }
   else {
+    rn->buff[rn->n++] = rn->c;  /* save current char */
+    rn->c = l_getc(rn->f);  /* read next one */
+    return 1;
+  }
+}
+
+
+/*
+** Accept current char if it is in 'set' (of size 2)
+*/
+static int test2 (RN *rn, const char *set) {
+  if (rn->c == set[0] || rn->c == set[1])
+    return nextc(rn);
+  else return 0;
+}
+
+
+/*
+** Read a sequence of (hex)digits
+*/
+static int readdigits (RN *rn, int hex) {
+  int count = 0;
+  while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))
+    count++;
+  return count;
+}
+
+
+/*
+** Read a number: first reads a valid prefix of a numeral into a buffer.
+** Then it calls 'lua_stringtonumber' to check whether the format is
+** correct and to convert it to a Lua number.
+*/
+static int read_number (lua_State *L, FILE *f) {
+  RN rn;
+  int count = 0;
+  int hex = 0;
+  char decp[2];
+  rn.f = f; rn.n = 0;
+  decp[0] = lua_getlocaledecpoint();  /* get decimal point from locale */
+  decp[1] = '.';  /* always accept a dot */
+  l_lockfile(rn.f);
+  do { rn.c = l_getc(rn.f); } while (isspace(rn.c));  /* skip spaces */
+  test2(&rn, "-+");  /* optional sign */
+  if (test2(&rn, "00")) {
+    if (test2(&rn, "xX")) hex = 1;  /* numeral is hexadecimal */
+    else count = 1;  /* count initial '0' as a valid digit */
+  }
+  count += readdigits(&rn, hex);  /* integral part */
+  if (test2(&rn, decp))  /* decimal point? */
+    count += readdigits(&rn, hex);  /* fractional part */
+  if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) {  /* exponent mark? */
+    test2(&rn, "-+");  /* exponent sign */
+    readdigits(&rn, 0);  /* exponent digits */
+  }
+  ungetc(rn.c, rn.f);  /* unread look-ahead char */
+  l_unlockfile(rn.f);
+  rn.buff[rn.n] = '\0';  /* finish string */
+  if (l_likely(lua_stringtonumber(L, rn.buff)))
+    return 1;  /* ok, it is a valid number */
+  else {  /* invalid format */
    lua_pushnil(L);  /* "result" to be removed */
    return 0;  /* read fails */
   }
@@ -362,48 +510,42 @@ static int read_number (lua_State *L, FILE *f) {
 
 static int test_eof (lua_State *L, FILE *f) {
   int c = getc(f);
-  ungetc(c, f);
-  lua_pushlstring(L, NULL, 0);
+  ungetc(c, f);  /* no-op when c == EOF */
+  lua_pushliteral(L, "");
   return (c != EOF);
 }
 
 
 static int read_line (lua_State *L, FILE *f, int chop) {
   luaL_Buffer b;
+  int c;
   luaL_buffinit(L, &b);
-  for (;;) {
-    size_t l;
-    char *p = luaL_prepbuffer(&b);
-    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
-      luaL_pushresult(&b);  /* close buffer */
-      return (lua_rawlen(L, -1) > 0);  /* check whether read something */
-    }
-    l = strlen(p);
-    if (l == 0 || p[l-1] != '\n')
-      luaL_addsize(&b, l);
-    else {
-      luaL_addsize(&b, l - chop);  /* chop 'eol' if needed */
-      luaL_pushresult(&b);  /* close buffer */
-      return 1;  /* read at least an `eol' */
-    }
-  }
+  do {  /* may need to read several chunks to get whole line */
+    char *buff = luaL_prepbuffer(&b);  /* preallocate buffer space */
+    int i = 0;
+    l_lockfile(f);  /* no memory errors can happen inside the lock */
+    while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n')
+      buff[i++] = c;  /* read up to end of line or buffer limit */
+    l_unlockfile(f);
+    luaL_addsize(&b, i);
+  } while (c != EOF && c != '\n');  /* repeat until end of line */
+  if (!chop && c == '\n')  /* want a newline and have one? */
+    luaL_addchar(&b, c);  /* add ending newline to result */
+  luaL_pushresult(&b);  /* close buffer */
+  /* return ok if read something (either a newline or something else) */
+  return (c == '\n' || lua_rawlen(L, -1) > 0);
 }
 
 
-#define MAX_SIZE_T	(~(size_t)0)
-
 static void read_all (lua_State *L, FILE *f) {
-  size_t rlen = LUAL_BUFFERSIZE;  /* how much to read in each cycle */
+  size_t nr;
   luaL_Buffer b;
   luaL_buffinit(L, &b);
-  for (;;) {
-    char *p = luaL_prepbuffsize(&b, rlen);
-    size_t nr = fread(p, sizeof(char), rlen, f);
+  do {  /* read file in chunks of LUAL_BUFFERSIZE bytes */
+    char *p = luaL_prepbuffer(&b);
+    nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
     luaL_addsize(&b, nr);
-    if (nr < rlen) break;  /* eof? */
-    else if (rlen <= (MAX_SIZE_T / 4))  /* avoid buffers too large */
-      rlen *= 2;  /* double buffer size at each iteration */
-  }
+  } while (nr == LUAL_BUFFERSIZE);
   luaL_pushresult(&b);  /* close buffer */
 }
 
@@ -423,25 +565,25 @@ static int read_chars (lua_State *L, FILE *f, size_t n) {
 
 static int g_read (lua_State *L, FILE *f, int first) {
   int nargs = lua_gettop(L) - 1;
-  int success;
-  int n;
+  int n, success;
   clearerr(f);
   if (nargs == 0) {  /* no arguments? */
     success = read_line(L, f, 1);
-    n = first+1;  /* to return 1 result */
+    n = first + 1;  /* to return 1 result */
   }
-  else {  /* ensure stack space for all results and for auxlib's buffer */
+  else {
+    /* ensure stack space for all results and for auxlib's buffer */
     luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
     success = 1;
     for (n = first; nargs-- && success; n++) {
       if (lua_type(L, n) == LUA_TNUMBER) {
-        size_t l = (size_t)lua_tointeger(L, n);
+        size_t l = (size_t)luaL_checkinteger(L, n);
         success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
       }
       else {
-        const char *p = lua_tostring(L, n);
-        luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
-        switch (p[1]) {
+        const char *p = luaL_checkstring(L, n);
+        if (*p == '*') p++;  /* skip optional '*' (for compatibility) */
+        switch (*p) {
           case 'n':  /* number */
             success = read_number(L, f);
             break;
@@ -465,7 +607,7 @@ static int g_read (lua_State *L, FILE *f, int first) {
     return luaL_fileresult(L, 0, NULL);
   if (!success) {
     lua_pop(L, 1);  /* remove last result */
-    lua_pushnil(L);  /* push nil instead */
+    luaL_pushfail(L);  /* push nil instead */
   }
   return n - first;
 }
@@ -481,6 +623,9 @@ static int f_read (lua_State *L) {
 }
 
 
+/*
+** Iteration function for 'lines'.
+*/
 static int io_readline (lua_State *L) {
   LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1));
   int i;
@@ -488,20 +633,21 @@ static int io_readline (lua_State *L) {
   if (isclosed(p))  /* file is already closed? */
     return luaL_error(L, "file is already closed");
   lua_settop(L , 1);
+  luaL_checkstack(L, n, "too many arguments");
   for (i = 1; i <= n; i++)  /* push arguments to 'g_read' */
     lua_pushvalue(L, lua_upvalueindex(3 + i));
   n = g_read(L, p->f, 2);  /* 'n' is number of results */
   lua_assert(n > 0);  /* should return at least a nil */
-  if (!lua_isnil(L, -n))  /* read at least one value? */
+  if (lua_toboolean(L, -n))  /* read at least one value? */
     return n;  /* return them */
-  else {  /* first result is nil: EOF or error */
+  else {  /* first result is false: EOF or error */
     if (n > 1) {  /* is there error information? */
       /* 2nd result is error message */
       return luaL_error(L, "%s", lua_tostring(L, -n + 1));
     }
     if (lua_toboolean(L, lua_upvalueindex(3))) {  /* generator created file? */
-      lua_settop(L, 0);
-      lua_pushvalue(L, lua_upvalueindex(1));
+      lua_settop(L, 0);  /* clear stack */
+      lua_pushvalue(L, lua_upvalueindex(1));  /* push file at index 1 */
       aux_close(L);  /* close it */
     }
     return 0;
@@ -517,8 +663,12 @@ static int g_write (lua_State *L, FILE *f, int arg) {
   for (; nargs--; arg++) {
     if (lua_type(L, arg) == LUA_TNUMBER) {
       /* optimization: could be done exactly as for strings */
-      status = status &&
-          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
+      int len = lua_isinteger(L, arg)
+                ? fprintf(f, LUA_INTEGER_FMT,
+                             (LUAI_UACINT)lua_tointeger(L, arg))
+                : fprintf(f, LUA_NUMBER_FMT,
+                             (LUAI_UACNUMBER)lua_tonumber(L, arg));
+      status = status && (len > 0);
     }
     else {
       size_t l;
@@ -526,7 +676,8 @@ static int g_write (lua_State *L, FILE *f, int arg) {
       status = status && (fwrite(s, sizeof(char), l, f) == l);
     }
   }
-  if (status) return 1;  /* file handle already on stack top */
+  if (l_likely(status))
+    return 1;  /* file handle already on stack top */
   else return luaL_fileresult(L, status, NULL);
 }
 
@@ -548,15 +699,15 @@ static int f_seek (lua_State *L) {
   static const char *const modenames[] = {"set", "cur", "end", NULL};
   FILE *f = tofile(L);
   int op = luaL_checkoption(L, 2, "cur", modenames);
-  lua_Number p3 = luaL_optnumber(L, 3, 0);
+  lua_Integer p3 = luaL_optinteger(L, 3, 0);
   l_seeknum offset = (l_seeknum)p3;
-  luaL_argcheck(L, (lua_Number)offset == p3, 3,
+  luaL_argcheck(L, (lua_Integer)offset == p3, 3,
                   "not an integer in proper range");
   op = l_fseek(f, offset, mode[op]);
-  if (op)
+  if (l_unlikely(op))
     return luaL_fileresult(L, 0, NULL);  /* error */
   else {
-    lua_pushnumber(L, (lua_Number)l_ftell(f));
+    lua_pushinteger(L, (lua_Integer)l_ftell(f));
     return 1;
   }
 }
@@ -568,7 +719,7 @@ static int f_setvbuf (lua_State *L) {
   FILE *f = tofile(L);
   int op = luaL_checkoption(L, 2, NULL, modenames);
   lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
-  int res = setvbuf(f, NULL, mode[op], sz);
+  int res = setvbuf(f, NULL, mode[op], (size_t)sz);
   return luaL_fileresult(L, res == 0, NULL);
 }
 
@@ -606,26 +757,37 @@ static const luaL_Reg iolib[] = {
 /*
 ** methods for file handles
 */
-static const luaL_Reg flib[] = {
-  {"close", io_close},
-  {"flush", f_flush},
-  {"lines", f_lines},
+static const luaL_Reg meth[] = {
   {"read", f_read},
-  {"seek", f_seek},
-  {"setvbuf", f_setvbuf},
   {"write", f_write},
+  {"lines", f_lines},
+  {"flush", f_flush},
+  {"seek", f_seek},
+  {"close", f_close},
+  {"setvbuf", f_setvbuf},
+  {NULL, NULL}
+};
+
+
+/*
+** metamethods for file handles
+*/
+static const luaL_Reg metameth[] = {
+  {"__index", NULL},  /* place holder */
   {"__gc", f_gc},
+  {"__close", f_gc},
   {"__tostring", f_tostring},
   {NULL, NULL}
 };
 
 
 static void createmeta (lua_State *L) {
-  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
-  lua_pushvalue(L, -1);  /* push metatable */
-  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
-  luaL_setfuncs(L, flib, 0);  /* add file methods to new metatable */
-  lua_pop(L, 1);  /* pop new metatable */
+  luaL_newmetatable(L, LUA_FILEHANDLE);  /* metatable for file handles */
+  luaL_setfuncs(L, metameth, 0);  /* add metamethods to new metatable */
+  luaL_newlibtable(L, meth);  /* create method table */
+  luaL_setfuncs(L, meth, 0);  /* add file methods to method table */
+  lua_setfield(L, -2, "__index");  /* metatable.__index = method table */
+  lua_pop(L, 1);  /* pop metatable */
 }
 
 
@@ -635,7 +797,7 @@ static void createmeta (lua_State *L) {
 static int io_noclose (lua_State *L) {
   LStream *p = tolstream(L);
   p->closef = &io_noclose;  /* keep file opened */
-  lua_pushnil(L);
+  luaL_pushfail(L);
   lua_pushliteral(L, "cannot close standard file");
   return 2;
 }

3rd/lua/ljumptab.h

@@ -0,0 +1,112 @@
+/*
+** $Id: ljumptab.h $
+** Jump Table for the Lua interpreter
+** See Copyright Notice in lua.h
+*/
+
+
+#undef vmdispatch
+#undef vmcase
+#undef vmbreak
+
+#define vmdispatch(x)     goto *disptab[x];
+
+#define vmcase(l)     L_##l:
+
+#define vmbreak		vmfetch(); vmdispatch(GET_OPCODE(i));
+
+
+static const void *const disptab[NUM_OPCODES] = {
+
+#if 0
+** you can update the following list with this command:
+**
+**  sed -n '/^OP_/\!d; s/OP_/\&\&L_OP_/ ; s/,.*/,/ ; s/\/.*// ; p'  lopcodes.h
+**
+#endif
+
+&&L_OP_MOVE,
+&&L_OP_LOADI,
+&&L_OP_LOADF,
+&&L_OP_LOADK,
+&&L_OP_LOADKX,
+&&L_OP_LOADFALSE,
+&&L_OP_LFALSESKIP,
+&&L_OP_LOADTRUE,
+&&L_OP_LOADNIL,
+&&L_OP_GETUPVAL,
+&&L_OP_SETUPVAL,
+&&L_OP_GETTABUP,
+&&L_OP_GETTABLE,
+&&L_OP_GETI,
+&&L_OP_GETFIELD,
+&&L_OP_SETTABUP,
+&&L_OP_SETTABLE,
+&&L_OP_SETI,
+&&L_OP_SETFIELD,
+&&L_OP_NEWTABLE,
+&&L_OP_SELF,
+&&L_OP_ADDI,
+&&L_OP_ADDK,
+&&L_OP_SUBK,
+&&L_OP_MULK,
+&&L_OP_MODK,
+&&L_OP_POWK,
+&&L_OP_DIVK,
+&&L_OP_IDIVK,
+&&L_OP_BANDK,
+&&L_OP_BORK,
+&&L_OP_BXORK,
+&&L_OP_SHRI,
+&&L_OP_SHLI,
+&&L_OP_ADD,
+&&L_OP_SUB,
+&&L_OP_MUL,
+&&L_OP_MOD,
+&&L_OP_POW,
+&&L_OP_DIV,
+&&L_OP_IDIV,
+&&L_OP_BAND,
+&&L_OP_BOR,
+&&L_OP_BXOR,
+&&L_OP_SHL,
+&&L_OP_SHR,
+&&L_OP_MMBIN,
+&&L_OP_MMBINI,
+&&L_OP_MMBINK,
+&&L_OP_UNM,
+&&L_OP_BNOT,
+&&L_OP_NOT,
+&&L_OP_LEN,
+&&L_OP_CONCAT,
+&&L_OP_CLOSE,
+&&L_OP_TBC,
+&&L_OP_JMP,
+&&L_OP_EQ,
+&&L_OP_LT,
+&&L_OP_LE,
+&&L_OP_EQK,
+&&L_OP_EQI,
+&&L_OP_LTI,
+&&L_OP_LEI,
+&&L_OP_GTI,
+&&L_OP_GEI,
+&&L_OP_TEST,
+&&L_OP_TESTSET,
+&&L_OP_CALL,
+&&L_OP_TAILCALL,
+&&L_OP_RETURN,
+&&L_OP_RETURN0,
+&&L_OP_RETURN1,
+&&L_OP_FORLOOP,
+&&L_OP_FORPREP,
+&&L_OP_TFORPREP,
+&&L_OP_TFORCALL,
+&&L_OP_TFORLOOP,
+&&L_OP_SETLIST,
+&&L_OP_CLOSURE,
+&&L_OP_VARARG,
+&&L_OP_VARARGPREP,
+&&L_OP_EXTRAARG
+
+};

3rd/lua/llex.c

@@ -1,20 +1,24 @@
 /*
-** $Id: llex.c,v 2.63.1.2 2013/08/30 15:49:41 roberto Exp $
+** $Id: llex.c $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
 
+#define llex_c
+#define LUA_CORE
+
+#include "lprefix.h"
+
 
 #include <locale.h>
 #include <string.h>
 
-#define llex_c
-#define LUA_CORE
-
 #include "lua.h"
 
 #include "lctype.h"
+#include "ldebug.h"
 #include "ldo.h"
+#include "lgc.h"
 #include "llex.h"
 #include "lobject.h"
 #include "lparser.h"
@@ -25,7 +29,7 @@
 
 
 
-#define next(ls) (ls->current = zgetc(ls->z))
+#define next(ls)	(ls->current = zgetc(ls->z))
 
 
 
@@ -38,8 +42,9 @@ static const char *const luaX_tokens [] = {
     "end", "false", "for", "function", "goto", "if",
     "in", "local", "nil", "not", "or", "repeat",
     "return", "then", "true", "until", "while",
-    "..", "...", "==", ">=", "<=", "~=", "::", "<eof>",
-    "<number>", "<name>", "<string>"
+    "//", "..", "...", "==", ">=", "<=", "~=",
+    "<<", ">>", "::", "<eof>",
+    "<number>", "<integer>", "<name>", "<string>"
 };
 
 
@@ -53,35 +58,38 @@ static void save (LexState *ls, int c) {
   Mbuffer *b = ls->buff;
   if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
     size_t newsize;
-    if (luaZ_sizebuffer(b) >= MAX_SIZET/2)
+    if (luaZ_sizebuffer(b) >= MAX_SIZE/2)
       lexerror(ls, "lexical element too long", 0);
     newsize = luaZ_sizebuffer(b) * 2;
     luaZ_resizebuffer(ls->L, b, newsize);
   }
-  b->buffer[luaZ_bufflen(b)++] = cast(char, c);
+  b->buffer[luaZ_bufflen(b)++] = cast_char(c);
 }
 
 
 void luaX_init (lua_State *L) {
   int i;
+  TString *e = luaS_newliteral(L, LUA_ENV);  /* create env name */
+  luaC_fix(L, obj2gco(e));  /* never collect this name */
   for (i=0; i<NUM_RESERVED; i++) {
     TString *ts = luaS_new(L, luaX_tokens[i]);
-    luaS_fix(ts);  /* reserved words are never collected */
-    ts->tsv.extra = cast_byte(i+1);  /* reserved word */
+    luaC_fix(L, obj2gco(ts));  /* reserved words are never collected */
+    ts->extra = cast_byte(i+1);  /* reserved word */
   }
 }
 
 
 const char *luaX_token2str (LexState *ls, int token) {
   if (token < FIRST_RESERVED) {  /* single-byte symbols? */
-    lua_assert(token == cast(unsigned char, token));
-    return (lisprint(token)) ? luaO_pushfstring(ls->L, LUA_QL("%c"), token) :
-                              luaO_pushfstring(ls->L, "char(%d)", token);
+    if (lisprint(token))
+      return luaO_pushfstring(ls->L, "'%c'", token);
+    else  /* control character */
+      return luaO_pushfstring(ls->L, "'<\\%d>'", token);
   }
   else {
     const char *s = luaX_tokens[token - FIRST_RESERVED];
     if (token < TK_EOS)  /* fixed format (symbols and reserved words)? */
-      return luaO_pushfstring(ls->L, LUA_QS, s);
+      return luaO_pushfstring(ls->L, "'%s'", s);
     else  /* names, strings, and numerals */
       return s;
   }
@@ -90,11 +98,10 @@ const char *luaX_token2str (LexState *ls, int token) {
 
 static const char *txtToken (LexState *ls, int token) {
   switch (token) {
-    case TK_NAME:
-    case TK_STRING:
-    case TK_NUMBER:
+    case TK_NAME: case TK_STRING:
+    case TK_FLT: case TK_INT:
       save(ls, '\0');
-      return luaO_pushfstring(ls->L, LUA_QS, luaZ_buffer(ls->buff));
+      return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff));
     default:
       return luaX_token2str(ls, token);
   }
@@ -102,9 +109,7 @@ static const char *txtToken (LexState *ls, int token) {
 
 
 static l_noret lexerror (LexState *ls, const char *msg, int token) {
-  char buff[LUA_IDSIZE];
-  luaO_chunkid(buff, getstr(ls->source), LUA_IDSIZE);
-  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
+  msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber);
   if (token)
     luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
   luaD_throw(ls->L, LUA_ERRSYNTAX);
@@ -117,26 +122,29 @@ l_noret luaX_syntaxerror (LexState *ls, const char *msg) {
 
 
 /*
-** creates a new string and anchors it in function's table so that
-** it will not be collected until the end of the function's compilation
-** (by that time it should be anchored in function's prototype)
+** Creates a new string and anchors it in scanner's table so that it
+** will not be collected until the end of the compilation; by that time
+** it should be anchored somewhere. It also internalizes long strings,
+** ensuring there is only one copy of each unique string.  The table
+** here is used as a set: the string enters as the key, while its value
+** is irrelevant. We use the string itself as the value only because it
+** is a TValue readily available. Later, the code generation can change
+** this value.
 */
 TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
   lua_State *L = ls->L;
-  TValue *o;  /* entry for `str' */
   TString *ts = luaS_newlstr(L, str, l);  /* create new string */
-  setsvalue2s(L, L->top++, ts);  /* temporarily anchor it in stack */
-  o = luaH_set(L, ls->fs->h, L->top - 1);
-  if (ttisnil(o)) {  /* not in use yet? (see 'addK') */
-    /* boolean value does not need GC barrier;
-       table has no metatable, so it does not need to invalidate cache */
-    setbvalue(o, 1);  /* t[string] = true */
+  const TValue *o = luaH_getstr(ls->h, ts);
+  if (!ttisnil(o))  /* string already present? */
+    ts = keystrval(nodefromval(o));  /* get saved copy */
+  else {  /* not in use yet */
+    TValue *stv = s2v(L->top.p++);  /* reserve stack space for string */
+    setsvalue(L, stv, ts);  /* temporarily anchor the string */
+    luaH_finishset(L, ls->h, stv, o, stv);  /* t[string] = string */
+    /* table is not a metatable, so it does not need to invalidate cache */
     luaC_checkGC(L);
+    L->top.p--;  /* remove string from stack */
   }
-  else {  /* string already present */
-    ts = rawtsvalue(keyfromval(o));  /* re-use value previously stored */
-  }
-  L->top--;  /* remove string from stack */
   return ts;
 }
 
@@ -148,17 +156,17 @@ TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
 static void inclinenumber (LexState *ls) {
   int old = ls->current;
   lua_assert(currIsNewline(ls));
-  next(ls);  /* skip `\n' or `\r' */
+  next(ls);  /* skip '\n' or '\r' */
   if (currIsNewline(ls) && ls->current != old)
-    next(ls);  /* skip `\n\r' or `\r\n' */
+    next(ls);  /* skip '\n\r' or '\r\n' */
   if (++ls->linenumber >= MAX_INT)
-    luaX_syntaxerror(ls, "chunk has too many lines");
+    lexerror(ls, "chunk has too many lines", 0);
 }
 
 
 void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
                     int firstchar) {
-  ls->decpoint = '.';
+  ls->t.token = 0;
   ls->L = L;
   ls->current = firstchar;
   ls->lookahead.token = TK_EOS;  /* no look-ahead token */
@@ -167,8 +175,7 @@ void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
   ls->linenumber = 1;
   ls->lastline = 1;
   ls->source = source;
-  ls->envn = luaS_new(L, LUA_ENV);  /* create env name */
-  luaS_fix(ls->envn);  /* never collect this name */
+  ls->envn = luaS_newliteral(L, LUA_ENV);  /* get env name */
   luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
 }
 
@@ -181,81 +188,82 @@ void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
 */
 
 
-
-static int check_next (LexState *ls, const char *set) {
-  if (ls->current == '\0' || !strchr(set, ls->current))
-    return 0;
-  save_and_next(ls);
-  return 1;
-}
-
-
-/*
-** change all characters 'from' in buffer to 'to'
-*/
-static void buffreplace (LexState *ls, char from, char to) {
-  size_t n = luaZ_bufflen(ls->buff);
-  char *p = luaZ_buffer(ls->buff);
-  while (n--)
-    if (p[n] == from) p[n] = to;
-}
-
-
-#if !defined(getlocaledecpoint)
-#define getlocaledecpoint()	(localeconv()->decimal_point[0])
-#endif
-
-
-#define buff2d(b,e)	luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e)
-
-/*
-** in case of format error, try to change decimal point separator to
-** the one defined in the current locale and check again
-*/
-static void trydecpoint (LexState *ls, SemInfo *seminfo) {
-  char old = ls->decpoint;
-  ls->decpoint = getlocaledecpoint();
-  buffreplace(ls, old, ls->decpoint);  /* try new decimal separator */
-  if (!buff2d(ls->buff, &seminfo->r)) {
-    /* format error with correct decimal point: no more options */
-    buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */
-    lexerror(ls, "malformed number", TK_NUMBER);
+static int check_next1 (LexState *ls, int c) {
+  if (ls->current == c) {
+    next(ls);
+    return 1;
   }
+  else return 0;
+}
+
+
+/*
+** Check whether current char is in set 'set' (with two chars) and
+** saves it
+*/
+static int check_next2 (LexState *ls, const char *set) {
+  lua_assert(set[2] == '\0');
+  if (ls->current == set[0] || ls->current == set[1]) {
+    save_and_next(ls);
+    return 1;
+  }
+  else return 0;
 }
 
 
 /* LUA_NUMBER */
 /*
-** this function is quite liberal in what it accepts, as 'luaO_str2d'
-** will reject ill-formed numerals.
+** This function is quite liberal in what it accepts, as 'luaO_str2num'
+** will reject ill-formed numerals. Roughly, it accepts the following
+** pattern:
+**
+**   %d(%x|%.|([Ee][+-]?))* | 0[Xx](%x|%.|([Pp][+-]?))*
+**
+** The only tricky part is to accept [+-] only after a valid exponent
+** mark, to avoid reading '3-4' or '0xe+1' as a single number.
+**
+** The caller might have already read an initial dot.
 */
-static void read_numeral (LexState *ls, SemInfo *seminfo) {
+static int read_numeral (LexState *ls, SemInfo *seminfo) {
+  TValue obj;
   const char *expo = "Ee";
   int first = ls->current;
   lua_assert(lisdigit(ls->current));
   save_and_next(ls);
-  if (first == '0' && check_next(ls, "Xx"))  /* hexadecimal? */
+  if (first == '0' && check_next2(ls, "xX"))  /* hexadecimal? */
     expo = "Pp";
   for (;;) {
-    if (check_next(ls, expo))  /* exponent part? */
-      check_next(ls, "+-");  /* optional exponent sign */
-    if (lisxdigit(ls->current) || ls->current == '.')
+    if (check_next2(ls, expo))  /* exponent mark? */
+      check_next2(ls, "-+");  /* optional exponent sign */
+    else if (lisxdigit(ls->current) || ls->current == '.')  /* '%x|%.' */
       save_and_next(ls);
-    else  break;
+    else break;
   }
+  if (lislalpha(ls->current))  /* is numeral touching a letter? */
+    save_and_next(ls);  /* force an error */
   save(ls, '\0');
-  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
-  if (!buff2d(ls->buff, &seminfo->r))  /* format error? */
-    trydecpoint(ls, seminfo); /* try to update decimal point separator */
+  if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0)  /* format error? */
+    lexerror(ls, "malformed number", TK_FLT);
+  if (ttisinteger(&obj)) {
+    seminfo->i = ivalue(&obj);
+    return TK_INT;
+  }
+  else {
+    lua_assert(ttisfloat(&obj));
+    seminfo->r = fltvalue(&obj);
+    return TK_FLT;
+  }
 }
 
 
 /*
-** skip a sequence '[=*[' or ']=*]' and return its number of '='s or
-** -1 if sequence is malformed
+** read a sequence '[=*[' or ']=*]', leaving the last bracket. If
+** sequence is well formed, return its number of '='s + 2; otherwise,
+** return 1 if it is a single bracket (no '='s and no 2nd bracket);
+** otherwise (an unfinished '[==...') return 0.
 */
-static int skip_sep (LexState *ls) {
-  int count = 0;
+static size_t skip_sep (LexState *ls) {
+  size_t count = 0;
   int s = ls->current;
   lua_assert(s == '[' || s == ']');
   save_and_next(ls);
@@ -263,23 +271,29 @@ static int skip_sep (LexState *ls) {
     save_and_next(ls);
     count++;
   }
-  return (ls->current == s) ? count : (-count) - 1;
+  return (ls->current == s) ? count + 2
+         : (count == 0) ? 1
+         : 0;
 }
 
 
-static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
-  save_and_next(ls);  /* skip 2nd `[' */
+static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {
+  int line = ls->linenumber;  /* initial line (for error message) */
+  save_and_next(ls);  /* skip 2nd '[' */
   if (currIsNewline(ls))  /* string starts with a newline? */
     inclinenumber(ls);  /* skip it */
   for (;;) {
     switch (ls->current) {
-      case EOZ:
-        lexerror(ls, (seminfo) ? "unfinished long string" :
-                                 "unfinished long comment", TK_EOS);
+      case EOZ: {  /* error */
+        const char *what = (seminfo ? "string" : "comment");
+        const char *msg = luaO_pushfstring(ls->L,
+                     "unfinished long %s (starting at line %d)", what, line);
+        lexerror(ls, msg, TK_EOS);
         break;  /* to avoid warnings */
+      }
       case ']': {
         if (skip_sep(ls) == sep) {
-          save_and_next(ls);  /* skip 2nd `]' */
+          save_and_next(ls);  /* skip 2nd ']' */
           goto endloop;
         }
         break;
@@ -297,45 +311,70 @@ static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
     }
   } endloop:
   if (seminfo)
-    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
-                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
+    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep,
+                                     luaZ_bufflen(ls->buff) - 2 * sep);
 }
 
 
-static void escerror (LexState *ls, int *c, int n, const char *msg) {
-  int i;
-  luaZ_resetbuffer(ls->buff);  /* prepare error message */
-  save(ls, '\\');
-  for (i = 0; i < n && c[i] != EOZ; i++)
-    save(ls, c[i]);
-  lexerror(ls, msg, TK_STRING);
+static void esccheck (LexState *ls, int c, const char *msg) {
+  if (!c) {
+    if (ls->current != EOZ)
+      save_and_next(ls);  /* add current to buffer for error message */
+    lexerror(ls, msg, TK_STRING);
+  }
+}
+
+
+static int gethexa (LexState *ls) {
+  save_and_next(ls);
+  esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected");
+  return luaO_hexavalue(ls->current);
 }
 
 
 static int readhexaesc (LexState *ls) {
-  int c[3], i;  /* keep input for error message */
-  int r = 0;  /* result accumulator */
-  c[0] = 'x';  /* for error message */
-  for (i = 1; i < 3; i++) {  /* read two hexadecimal digits */
-    c[i] = next(ls);
-    if (!lisxdigit(c[i]))
-      escerror(ls, c, i + 1, "hexadecimal digit expected");
-    r = (r << 4) + luaO_hexavalue(c[i]);
-  }
+  int r = gethexa(ls);
+  r = (r << 4) + gethexa(ls);
+  luaZ_buffremove(ls->buff, 2);  /* remove saved chars from buffer */
   return r;
 }
 
 
+static unsigned long readutf8esc (LexState *ls) {
+  unsigned long r;
+  int i = 4;  /* chars to be removed: '\', 'u', '{', and first digit */
+  save_and_next(ls);  /* skip 'u' */
+  esccheck(ls, ls->current == '{', "missing '{'");
+  r = gethexa(ls);  /* must have at least one digit */
+  while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) {
+    i++;
+    esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large");
+    r = (r << 4) + luaO_hexavalue(ls->current);
+  }
+  esccheck(ls, ls->current == '}', "missing '}'");
+  next(ls);  /* skip '}' */
+  luaZ_buffremove(ls->buff, i);  /* remove saved chars from buffer */
+  return r;
+}
+
+
+static void utf8esc (LexState *ls) {
+  char buff[UTF8BUFFSZ];
+  int n = luaO_utf8esc(buff, readutf8esc(ls));
+  for (; n > 0; n--)  /* add 'buff' to string */
+    save(ls, buff[UTF8BUFFSZ - n]);
+}
+
+
 static int readdecesc (LexState *ls) {
-  int c[3], i;
+  int i;
   int r = 0;  /* result accumulator */
   for (i = 0; i < 3 && lisdigit(ls->current); i++) {  /* read up to 3 digits */
-    c[i] = ls->current;
-    r = 10*r + c[i] - '0';
-    next(ls);
+    r = 10*r + ls->current - '0';
+    save_and_next(ls);
   }
-  if (r > UCHAR_MAX)
-    escerror(ls, c, i, "decimal escape too large");
+  esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
+  luaZ_buffremove(ls->buff, i);  /* remove read digits from buffer */
   return r;
 }
 
@@ -353,7 +392,7 @@ static void read_string (LexState *ls, int del, SemInfo *seminfo) {
         break;  /* to avoid warnings */
       case '\\': {  /* escape sequences */
         int c;  /* final character to be saved */
-        next(ls);  /* do not save the `\' */
+        save_and_next(ls);  /* keep '\\' for error messages */
         switch (ls->current) {
           case 'a': c = '\a'; goto read_save;
           case 'b': c = '\b'; goto read_save;
@@ -363,12 +402,14 @@ static void read_string (LexState *ls, int del, SemInfo *seminfo) {
           case 't': c = '\t'; goto read_save;
           case 'v': c = '\v'; goto read_save;
           case 'x': c = readhexaesc(ls); goto read_save;
+          case 'u': utf8esc(ls);  goto no_save;
           case '\n': case '\r':
             inclinenumber(ls); c = '\n'; goto only_save;
           case '\\': case '\"': case '\'':
             c = ls->current; goto read_save;
           case EOZ: goto no_save;  /* will raise an error next loop */
           case 'z': {  /* zap following span of spaces */
+            luaZ_buffremove(ls->buff, 1);  /* remove '\\' */
             next(ls);  /* skip the 'z' */
             while (lisspace(ls->current)) {
               if (currIsNewline(ls)) inclinenumber(ls);
@@ -377,15 +418,18 @@ static void read_string (LexState *ls, int del, SemInfo *seminfo) {
             goto no_save;
           }
           default: {
-            if (!lisdigit(ls->current))
-              escerror(ls, &ls->current, 1, "invalid escape sequence");
-            /* digital escape \ddd */
-            c = readdecesc(ls);
+            esccheck(ls, lisdigit(ls->current), "invalid escape sequence");
+            c = readdecesc(ls);  /* digital escape '\ddd' */
             goto only_save;
           }
         }
-       read_save: next(ls);  /* read next character */
-       only_save: save(ls, c);  /* save 'c' */
+       read_save:
+         next(ls);
+         /* go through */
+       only_save:
+         luaZ_buffremove(ls->buff, 1);  /* remove '\\' */
+         save(ls, c);
+         /* go through */
        no_save: break;
       }
       default:
@@ -416,9 +460,9 @@ static int llex (LexState *ls, SemInfo *seminfo) {
         /* else is a comment */
         next(ls);
         if (ls->current == '[') {  /* long comment? */
-          int sep = skip_sep(ls);
-          luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */
-          if (sep >= 0) {
+          size_t sep = skip_sep(ls);
+          luaZ_resetbuffer(ls->buff);  /* 'skip_sep' may dirty the buffer */
+          if (sep >= 2) {
             read_long_string(ls, NULL, sep);  /* skip long comment */
             luaZ_resetbuffer(ls->buff);  /* previous call may dirty the buff. */
             break;
@@ -430,38 +474,46 @@ static int llex (LexState *ls, SemInfo *seminfo) {
         break;
       }
       case '[': {  /* long string or simply '[' */
-        int sep = skip_sep(ls);
-        if (sep >= 0) {
+        size_t sep = skip_sep(ls);
+        if (sep >= 2) {
           read_long_string(ls, seminfo, sep);
           return TK_STRING;
         }
-        else if (sep == -1) return '[';
-        else lexerror(ls, "invalid long string delimiter", TK_STRING);
+        else if (sep == 0)  /* '[=...' missing second bracket? */
+          lexerror(ls, "invalid long string delimiter", TK_STRING);
+        return '[';
       }
       case '=': {
         next(ls);
-        if (ls->current != '=') return '=';
-        else { next(ls); return TK_EQ; }
+        if (check_next1(ls, '=')) return TK_EQ;  /* '==' */
+        else return '=';
       }
       case '<': {
         next(ls);
-        if (ls->current != '=') return '<';
-        else { next(ls); return TK_LE; }
+        if (check_next1(ls, '=')) return TK_LE;  /* '<=' */
+        else if (check_next1(ls, '<')) return TK_SHL;  /* '<<' */
+        else return '<';
       }
       case '>': {
         next(ls);
-        if (ls->current != '=') return '>';
-        else { next(ls); return TK_GE; }
+        if (check_next1(ls, '=')) return TK_GE;  /* '>=' */
+        else if (check_next1(ls, '>')) return TK_SHR;  /* '>>' */
+        else return '>';
+      }
+      case '/': {
+        next(ls);
+        if (check_next1(ls, '/')) return TK_IDIV;  /* '//' */
+        else return '/';
       }
       case '~': {
         next(ls);
-        if (ls->current != '=') return '~';
-        else { next(ls); return TK_NE; }
+        if (check_next1(ls, '=')) return TK_NE;  /* '~=' */
+        else return '~';
       }
       case ':': {
         next(ls);
-        if (ls->current != ':') return ':';
-        else { next(ls); return TK_DBCOLON; }
+        if (check_next1(ls, ':')) return TK_DBCOLON;  /* '::' */
+        else return ':';
       }
       case '"': case '\'': {  /* short literal strings */
         read_string(ls, ls->current, seminfo);
@@ -469,18 +521,17 @@ static int llex (LexState *ls, SemInfo *seminfo) {
       }
       case '.': {  /* '.', '..', '...', or number */
         save_and_next(ls);
-        if (check_next(ls, ".")) {
-          if (check_next(ls, "."))
+        if (check_next1(ls, '.')) {
+          if (check_next1(ls, '.'))
             return TK_DOTS;   /* '...' */
           else return TK_CONCAT;   /* '..' */
         }
         else if (!lisdigit(ls->current)) return '.';
-        /* else go through */
+        else return read_numeral(ls, seminfo);
       }
       case '0': case '1': case '2': case '3': case '4':
       case '5': case '6': case '7': case '8': case '9': {
-        read_numeral(ls, seminfo);
-        return TK_NUMBER;
+        return read_numeral(ls, seminfo);
       }
       case EOZ: {
         return TK_EOS;
@@ -495,12 +546,12 @@ static int llex (LexState *ls, SemInfo *seminfo) {
                                   luaZ_bufflen(ls->buff));
           seminfo->ts = ts;
           if (isreserved(ts))  /* reserved word? */
-            return ts->tsv.extra - 1 + FIRST_RESERVED;
+            return ts->extra - 1 + FIRST_RESERVED;
           else {
             return TK_NAME;
           }
         }
-        else {  /* single-char tokens (+ - / ...) */
+        else {  /* single-char tokens ('+', '*', '%', '{', '}', ...) */
           int c = ls->current;
           next(ls);
           return c;

3rd/lua/llex.h

@@ -1,5 +1,5 @@
 /*
-** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: llex.h $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
@@ -7,13 +7,23 @@
 #ifndef llex_h
 #define llex_h
 
+#include <limits.h>
+
 #include "lobject.h"
 #include "lzio.h"
 
 
-#define FIRST_RESERVED	257
+/*
+** Single-char tokens (terminal symbols) are represented by their own
+** numeric code. Other tokens start at the following value.
+*/
+#define FIRST_RESERVED	(UCHAR_MAX + 1)
 
 
+#if !defined(LUA_ENV)
+#define LUA_ENV		"_ENV"
+#endif
+
 
 /*
 * WARNING: if you change the order of this enumeration,
@@ -26,16 +36,19 @@ enum RESERVED {
   TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
   /* other terminal symbols */
-  TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_DBCOLON, TK_EOS,
-  TK_NUMBER, TK_NAME, TK_STRING
+  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
 };
 
 /* number of reserved words */
-#define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
+#define NUM_RESERVED	(cast_int(TK_WHILE-FIRST_RESERVED + 1))
 
 
 typedef union {
   lua_Number r;
+  lua_Integer i;
   TString *ts;
 } SemInfo;  /* semantics information */
 
@@ -51,17 +64,17 @@ typedef struct Token {
 typedef struct LexState {
   int current;  /* current character (charint) */
   int linenumber;  /* input line counter */
-  int lastline;  /* line of last token `consumed' */
+  int lastline;  /* line of last token 'consumed' */
   Token t;  /* current token */
   Token lookahead;  /* look ahead token */
   struct FuncState *fs;  /* current function (parser) */
   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 */
-  char decpoint;  /* locale decimal point */
 } LexState;
 
 

3rd/lua/llimits.h

@@ -1,6 +1,6 @@
 /*
-** $Id: llimits.h,v 1.103.1.1 2013/04/12 18:48:47 roberto Exp $
-** Limits, basic types, and some other `installation-dependent' definitions
+** $Id: llimits.h $
+** Limits, basic types, and some other 'installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
 
@@ -15,53 +15,101 @@
 #include "lua.h"
 
 
-typedef unsigned LUA_INT32 lu_int32;
-
+/*
+** 'lu_mem' and 'l_mem' are unsigned/signed integers big enough to count
+** the total memory used by Lua (in bytes). Usually, 'size_t' and
+** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines.
+*/
+#if defined(LUAI_MEM)		/* { external definitions? */
 typedef LUAI_UMEM lu_mem;
-
 typedef LUAI_MEM l_mem;
+#elif LUAI_IS32INT	/* }{ */
+typedef size_t lu_mem;
+typedef ptrdiff_t l_mem;
+#else  /* 16-bit ints */	/* }{ */
+typedef unsigned long lu_mem;
+typedef long l_mem;
+#endif				/* } */
 
 
-
-/* chars used as small naturals (so that `char' is reserved for characters) */
+/* chars used as small naturals (so that 'char' is reserved for characters) */
 typedef unsigned char lu_byte;
+typedef signed char ls_byte;
 
 
-#define MAX_SIZET	((size_t)(~(size_t)0)-2)
+/* maximum value for size_t */
+#define MAX_SIZET	((size_t)(~(size_t)0))
 
-#define MAX_LUMEM	((lu_mem)(~(lu_mem)0)-2)
-
-#define MAX_LMEM	((l_mem) ((MAX_LUMEM >> 1) - 2))
+/* maximum size visible for Lua (must be representable in a lua_Integer) */
+#define MAX_SIZE	(sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
+                          : (size_t)(LUA_MAXINTEGER))
 
 
-#define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
+#define MAX_LUMEM	((lu_mem)(~(lu_mem)0))
+
+#define MAX_LMEM	((l_mem)(MAX_LUMEM >> 1))
+
+
+#define MAX_INT		INT_MAX  /* maximum value of an int */
+
 
 /*
-** conversion of pointer to integer
-** this is for hashing only; there is no problem if the integer
-** cannot hold the whole pointer value
+** floor of the log2 of the maximum signed value for integral type 't'.
+** (That is, maximum 'n' such that '2^n' fits in the given signed type.)
 */
-#define IntPoint(p)  ((unsigned int)(lu_mem)(p))
+#define log2maxs(t)	(sizeof(t) * 8 - 2)
 
 
+/*
+** test whether an unsigned value is a power of 2 (or zero)
+*/
+#define ispow2(x)	(((x) & ((x) - 1)) == 0)
 
-/* type to ensure maximum alignment */
-#if !defined(LUAI_USER_ALIGNMENT_T)
-#define LUAI_USER_ALIGNMENT_T	union { double u; void *s; long l; }
+
+/* number of chars of a literal string without the ending \0 */
+#define LL(x)   (sizeof(x)/sizeof(char) - 1)
+
+
+/*
+** conversion of pointer to unsigned integer: this is for hashing only;
+** there is no problem if the integer cannot hold the whole pointer
+** value. (In strict ISO C this may cause undefined behavior, but no
+** actual machine seems to bother.)
+*/
+#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
+    __STDC_VERSION__ >= 199901L
+#include <stdint.h>
+#if defined(UINTPTR_MAX)  /* even in C99 this type is optional */
+#define L_P2I	uintptr_t
+#else  /* no 'intptr'? */
+#define L_P2I	uintmax_t  /* use the largest available integer */
+#endif
+#else  /* C89 option */
+#define L_P2I	size_t
 #endif
 
-typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
+#define point2uint(p)	((unsigned int)((L_P2I)(p) & UINT_MAX))
 
 
-/* result of a `usual argument conversion' over lua_Number */
+
+/* types of 'usual argument conversions' for lua_Number and lua_Integer */
 typedef LUAI_UACNUMBER l_uacNumber;
+typedef LUAI_UACINT l_uacInt;
 
 
-/* internal assertions for in-house debugging */
+/*
+** Internal assertions for in-house debugging
+*/
+#if defined LUAI_ASSERT
+#undef NDEBUG
+#include <assert.h>
+#define lua_assert(c)           assert(c)
+#endif
+
 #if defined(lua_assert)
 #define check_exp(c,e)		(lua_assert(c), (e))
 /* to avoid problems with conditions too long */
-#define lua_longassert(c)	{ if (!(c)) lua_assert(0); }
+#define lua_longassert(c)	((c) ? (void)0 : lua_assert(0))
 #else
 #define lua_assert(c)		((void)0)
 #define check_exp(c,e)		(e)
@@ -72,76 +120,122 @@ typedef LUAI_UACNUMBER l_uacNumber;
 ** assertion for checking API calls
 */
 #if !defined(luai_apicheck)
-
-#if defined(LUA_USE_APICHECK)
-#include <assert.h>
-#define luai_apicheck(L,e)	assert(e)
-#else
-#define luai_apicheck(L,e)	lua_assert(e)
-#endif
-
+#define luai_apicheck(l,e)	((void)l, lua_assert(e))
 #endif
 
 #define api_check(l,e,msg)	luai_apicheck(l,(e) && msg)
 
 
+/* macro to avoid warnings about unused variables */
 #if !defined(UNUSED)
-#define UNUSED(x)	((void)(x))	/* to avoid warnings */
+#define UNUSED(x)	((void)(x))
 #endif
 
 
+/* type casts (a macro highlights casts in the code) */
 #define cast(t, exp)	((t)(exp))
 
-#define cast_byte(i)	cast(lu_byte, (i))
+#define cast_void(i)	cast(void, (i))
+#define cast_voidp(i)	cast(void *, (i))
 #define cast_num(i)	cast(lua_Number, (i))
 #define cast_int(i)	cast(int, (i))
+#define cast_uint(i)	cast(unsigned int, (i))
+#define cast_byte(i)	cast(lu_byte, (i))
 #define cast_uchar(i)	cast(unsigned char, (i))
+#define cast_char(i)	cast(char, (i))
+#define cast_charp(i)	cast(char *, (i))
+#define cast_sizet(i)	cast(size_t, (i))
+
+
+/* cast a signed lua_Integer to lua_Unsigned */
+#if !defined(l_castS2U)
+#define l_castS2U(i)	((lua_Unsigned)(i))
+#endif
+
+/*
+** cast a lua_Unsigned to a signed lua_Integer; this cast is
+** not strict ISO C, but two-complement architectures should
+** work fine.
+*/
+#if !defined(l_castU2S)
+#define l_castU2S(i)	((lua_Integer)(i))
+#endif
 
 
 /*
 ** non-return type
 */
+#if !defined(l_noret)
+
 #if defined(__GNUC__)
 #define l_noret		void __attribute__((noreturn))
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) && _MSC_VER >= 1200
 #define l_noret		void __declspec(noreturn)
 #else
 #define l_noret		void
 #endif
 
-
-
-/*
-** maximum depth for nested C calls and syntactical nested non-terminals
-** in a program. (Value must fit in an unsigned short int.)
-*/
-#if !defined(LUAI_MAXCCALLS)
-#define LUAI_MAXCCALLS		200
 #endif
 
+
 /*
-** maximum number of upvalues in a closure (both C and Lua). (Value
-** must fit in an unsigned char.)
+** Inline functions
 */
-#define MAXUPVAL	UCHAR_MAX
+#if !defined(LUA_USE_C89)
+#define l_inline	inline
+#elif defined(__GNUC__)
+#define l_inline	__inline__
+#else
+#define l_inline	/* empty */
+#endif
+
+#define l_sinline	static l_inline
 
 
 /*
-** type for virtual-machine instructions
+** type for virtual-machine instructions;
 ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
 */
-typedef lu_int32 Instruction;
+#if LUAI_IS32INT
+typedef unsigned int l_uint32;
+#else
+typedef unsigned long l_uint32;
+#endif
+
+typedef l_uint32 Instruction;
 
 
 
-/* maximum stack for a Lua function */
-#define MAXSTACK	250
+/*
+** Maximum length for short strings, that is, strings that are
+** internalized. (Cannot be smaller than reserved words or tags for
+** metamethods, as these strings must be internalized;
+** #("function") = 8, #("__newindex") = 10.)
+*/
+#if !defined(LUAI_MAXSHORTLEN)
+#define LUAI_MAXSHORTLEN	40
+#endif
 
 
-
-/* minimum size for the string table (must be power of 2) */
+/*
+** Initial size for the string table (must be power of 2).
+** The Lua core alone registers ~50 strings (reserved words +
+** metaevent keys + a few others). Libraries would typically add
+** a few dozens more.
+*/
 #if !defined(MINSTRTABSIZE)
-#define MINSTRTABSIZE	32
+#define MINSTRTABSIZE	128
+#endif
+
+
+/*
+** Size of cache for strings in the API. 'N' is the number of
+** sets (better be a prime) and "M" is the size of each set (M == 1
+** makes a direct cache.)
+*/
+#if !defined(STRCACHE_N)
+#define STRCACHE_N		53
+#define STRCACHE_M		2
 #endif
 
 
@@ -151,19 +245,37 @@ typedef lu_int32 Instruction;
 #endif
 
 
-#if !defined(lua_lock)
-#define lua_lock(L)     ((void) 0)
-#define lua_unlock(L)   ((void) 0)
-#endif
-
-#if !defined(luai_threadyield)
-#define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
+/*
+** Maximum depth for nested C calls, syntactical nested non-terminals,
+** and other features implemented through recursion in C. (Value must
+** fit in a 16-bit unsigned integer. It must also be compatible with
+** the size of the C stack.)
+*/
+#if !defined(LUAI_MAXCCALLS)
+#define LUAI_MAXCCALLS		200
 #endif
 
 
 /*
-** these macros allow user-specific actions on threads when you defined
-** LUAI_EXTRASPACE and need to do something extra when a thread is
+** macros that are executed whenever program enters the Lua core
+** ('lua_lock') and leaves the core ('lua_unlock')
+*/
+#if !defined(lua_lock)
+#define lua_lock(L)	((void) 0)
+#define lua_unlock(L)	((void) 0)
+#endif
+
+/*
+** macro executed during Lua functions at points where the
+** function can yield.
+*/
+#if !defined(luai_threadyield)
+#define luai_threadyield(L)	{lua_unlock(L); lua_lock(L);}
+#endif
+
+
+/*
+** these macros allow user-specific actions when a thread is
 ** created/deleted/resumed/yielded.
 */
 #if !defined(luai_userstateopen)
@@ -183,127 +295,86 @@ typedef lu_int32 Instruction;
 #endif
 
 #if !defined(luai_userstateresume)
-#define luai_userstateresume(L,n)       ((void)L)
+#define luai_userstateresume(L,n)	((void)L)
 #endif
 
 #if !defined(luai_userstateyield)
-#define luai_userstateyield(L,n)        ((void)L)
+#define luai_userstateyield(L,n)	((void)L)
+#endif
+
+
+
+/*
+** The luai_num* macros define the primitive operations over numbers.
+*/
+
+/* floor division (defined as 'floor(a/b)') */
+#if !defined(luai_numidiv)
+#define luai_numidiv(L,a,b)     ((void)L, l_floor(luai_numdiv(L,a,b)))
+#endif
+
+/* float division */
+#if !defined(luai_numdiv)
+#define luai_numdiv(L,a,b)      ((a)/(b))
 #endif
 
 /*
-** lua_number2int is a macro to convert lua_Number to int.
-** lua_number2integer is a macro to convert lua_Number to lua_Integer.
-** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned.
-** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number.
-** luai_hashnum is a macro to hash a lua_Number value into an integer.
-** The hash must be deterministic and give reasonable values for
-** both small and large values (outside the range of integers).
+** modulo: defined as 'a - floor(a/b)*b'; the direct computation
+** using this definition has several problems with rounding errors,
+** so it is better to use 'fmod'. 'fmod' gives the result of
+** 'a - trunc(a/b)*b', and therefore must be corrected when
+** 'trunc(a/b) ~= floor(a/b)'. That happens when the division has a
+** non-integer negative result: non-integer result is equivalent to
+** a non-zero remainder 'm'; negative result is equivalent to 'a' and
+** 'b' with different signs, or 'm' and 'b' with different signs
+** (as the result 'm' of 'fmod' has the same sign of 'a').
 */
-
-#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK)	/* { */
-/* trick with Microsoft assembler for X86 */
-
-#define lua_number2int(i,n)  __asm {__asm fld n   __asm fistp i}
-#define lua_number2integer(i,n)		lua_number2int(i, n)
-#define lua_number2unsigned(i,n)  \
-  {__int64 l; __asm {__asm fld n   __asm fistp l} i = (unsigned int)l;}
-
-
-#elif defined(LUA_IEEE754TRICK)		/* }{ */
-/* the next trick should work on any machine using IEEE754 with
-   a 32-bit int type */
-
-union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
-
-#if !defined(LUA_IEEEENDIAN)	/* { */
-#define LUAI_EXTRAIEEE	\
-  static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
-#define LUA_IEEEENDIANLOC	(ieeeendian.l_p[1] == 33)
-#else
-#define LUA_IEEEENDIANLOC	LUA_IEEEENDIAN
-#define LUAI_EXTRAIEEE		/* empty */
-#endif				/* } */
-
-#define lua_number2int32(i,n,t) \
-  { LUAI_EXTRAIEEE \
-    volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
-    (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; }
-
-#define luai_hashnum(i,n)  \
-  { volatile union luai_Cast u; u.l_d = (n) + 1.0;  /* avoid -0 */ \
-    (i) = u.l_p[0]; (i) += u.l_p[1]; }  /* add double bits for his hash */
-
-#define lua_number2int(i,n)		lua_number2int32(i, n, int)
-#define lua_number2unsigned(i,n)	lua_number2int32(i, n, lua_Unsigned)
-
-/* the trick can be expanded to lua_Integer when it is a 32-bit value */
-#if defined(LUA_IEEELL)
-#define lua_number2integer(i,n)		lua_number2int32(i, n, lua_Integer)
+#if !defined(luai_nummod)
+#define luai_nummod(L,a,b,m)  \
+  { (void)L; (m) = l_mathop(fmod)(a,b); \
+    if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); }
 #endif
 
-#endif				/* } */
-
-
-/* the following definitions always work, but may be slow */
-
-#if !defined(lua_number2int)
-#define lua_number2int(i,n)	((i)=(int)(n))
+/* exponentiation */
+#if !defined(luai_numpow)
+#define luai_numpow(L,a,b)  \
+  ((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b))
 #endif
 
-#if !defined(lua_number2integer)
-#define lua_number2integer(i,n)	((i)=(lua_Integer)(n))
-#endif
-
-#if !defined(lua_number2unsigned)	/* { */
-/* the following definition assures proper modulo behavior */
-#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)
-#include <math.h>
-#define SUPUNSIGNED	((lua_Number)(~(lua_Unsigned)0) + 1)
-#define lua_number2unsigned(i,n)  \
-	((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))
-#else
-#define lua_number2unsigned(i,n)	((i)=(lua_Unsigned)(n))
-#endif
-#endif				/* } */
-
-
-#if !defined(lua_unsigned2number)
-/* on several machines, coercion from unsigned to double is slow,
-   so it may be worth to avoid */
-#define lua_unsigned2number(u)  \
-    (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))
+/* the others are quite standard operations */
+#if !defined(luai_numadd)
+#define luai_numadd(L,a,b)      ((a)+(b))
+#define luai_numsub(L,a,b)      ((a)-(b))
+#define luai_nummul(L,a,b)      ((a)*(b))
+#define luai_numunm(L,a)        (-(a))
+#define luai_numeq(a,b)         ((a)==(b))
+#define luai_numlt(a,b)         ((a)<(b))
+#define luai_numle(a,b)         ((a)<=(b))
+#define luai_numgt(a,b)         ((a)>(b))
+#define luai_numge(a,b)         ((a)>=(b))
+#define luai_numisnan(a)        (!luai_numeq((a), (a)))
 #endif
 
 
 
-#if defined(ltable_c) && !defined(luai_hashnum)
-
-#include <float.h>
-#include <math.h>
-
-#define luai_hashnum(i,n) { int e;  \
-  n = l_mathop(frexp)(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP);  \
-  lua_number2int(i, n); i += e; }
-
-#endif
-
 
 
 /*
 ** macro to control inclusion of some hard tests on stack reallocation
 */
 #if !defined(HARDSTACKTESTS)
-#define condmovestack(L)	((void)0)
+#define condmovestack(L,pre,pos)	((void)0)
 #else
 /* realloc stack keeping its size */
-#define condmovestack(L)	luaD_reallocstack((L), (L)->stacksize)
+#define condmovestack(L,pre,pos)  \
+  { int sz_ = stacksize(L); pre; luaD_reallocstack((L), sz_, 0); pos; }
 #endif
 
 #if !defined(HARDMEMTESTS)
-#define condchangemem(L)	condmovestack(L)
+#define condchangemem(L,pre,pos)	((void)0)
 #else
-#define condchangemem(L)  \
-	((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1)))
+#define condchangemem(L,pre,pos)  \
+	{ if (gcrunning(G(L))) { pre; luaC_fullgc(L, 0); pos; } }
 #endif
 
 #endif

3rd/lua/lmathlib.c

@@ -1,16 +1,21 @@
 /*
-** $Id: lmathlib.c,v 1.83.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lmathlib.c $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
 
-
-#include <stdlib.h>
-#include <math.h>
-
 #define lmathlib_c
 #define LUA_LIB
 
+#include "lprefix.h"
+
+
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -18,13 +23,17 @@
 
 
 #undef PI
-#define PI	((lua_Number)(3.1415926535897932384626433832795))
-#define RADIANS_PER_DEGREE	((lua_Number)(PI/180.0))
-
+#define PI	(l_mathop(3.141592653589793238462643383279502884))
 
 
 static int math_abs (lua_State *L) {
-  lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
+  if (lua_isinteger(L, 1)) {
+    lua_Integer n = lua_tointeger(L, 1);
+    if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
+    lua_pushinteger(L, n);
+  }
+  else
+    lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
   return 1;
 }
 
@@ -33,31 +42,16 @@ static int math_sin (lua_State *L) {
   return 1;
 }
 
-static int math_sinh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
 static int math_cos (lua_State *L) {
   lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_cosh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
 static int math_tan (lua_State *L) {
   lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_tanh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
 static int math_asin (lua_State *L) {
   lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
   return 1;
@@ -69,49 +63,106 @@ static int math_acos (lua_State *L) {
 }
 
 static int math_atan (lua_State *L) {
-  lua_pushnumber(L, l_mathop(atan)(luaL_checknumber(L, 1)));
+  lua_Number y = luaL_checknumber(L, 1);
+  lua_Number x = luaL_optnumber(L, 2, 1);
+  lua_pushnumber(L, l_mathop(atan2)(y, x));
   return 1;
 }
 
-static int math_atan2 (lua_State *L) {
-  lua_pushnumber(L, l_mathop(atan2)(luaL_checknumber(L, 1),
-                                luaL_checknumber(L, 2)));
+
+static int math_toint (lua_State *L) {
+  int valid;
+  lua_Integer n = lua_tointegerx(L, 1, &valid);
+  if (l_likely(valid))
+    lua_pushinteger(L, n);
+  else {
+    luaL_checkany(L, 1);
+    luaL_pushfail(L);  /* value is not convertible to integer */
+  }
   return 1;
 }
 
-static int math_ceil (lua_State *L) {
-  lua_pushnumber(L, l_mathop(ceil)(luaL_checknumber(L, 1)));
-  return 1;
+
+static void pushnumint (lua_State *L, lua_Number d) {
+  lua_Integer n;
+  if (lua_numbertointeger(d, &n))  /* does 'd' fit in an integer? */
+    lua_pushinteger(L, n);  /* result is integer */
+  else
+    lua_pushnumber(L, d);  /* result is float */
 }
 
+
 static int math_floor (lua_State *L) {
-  lua_pushnumber(L, l_mathop(floor)(luaL_checknumber(L, 1)));
+  if (lua_isinteger(L, 1))
+    lua_settop(L, 1);  /* integer is its own floor */
+  else {
+    lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
+    pushnumint(L, d);
+  }
   return 1;
 }
 
+
+static int math_ceil (lua_State *L) {
+  if (lua_isinteger(L, 1))
+    lua_settop(L, 1);  /* integer is its own ceil */
+  else {
+    lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
+    pushnumint(L, d);
+  }
+  return 1;
+}
+
+
 static int math_fmod (lua_State *L) {
-  lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
-                               luaL_checknumber(L, 2)));
+  if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
+    lua_Integer d = lua_tointeger(L, 2);
+    if ((lua_Unsigned)d + 1u <= 1u) {  /* special cases: -1 or 0 */
+      luaL_argcheck(L, d != 0, 2, "zero");
+      lua_pushinteger(L, 0);  /* avoid overflow with 0x80000... / -1 */
+    }
+    else
+      lua_pushinteger(L, lua_tointeger(L, 1) % d);
+  }
+  else
+    lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
+                                     luaL_checknumber(L, 2)));
   return 1;
 }
 
+
+/*
+** next function does not use 'modf', avoiding problems with 'double*'
+** (which is not compatible with 'float*') when lua_Number is not
+** 'double'.
+*/
 static int math_modf (lua_State *L) {
-  lua_Number ip;
-  lua_Number fp = l_mathop(modf)(luaL_checknumber(L, 1), &ip);
-  lua_pushnumber(L, ip);
-  lua_pushnumber(L, fp);
+  if (lua_isinteger(L ,1)) {
+    lua_settop(L, 1);  /* number is its own integer part */
+    lua_pushnumber(L, 0);  /* no fractional part */
+  }
+  else {
+    lua_Number n = luaL_checknumber(L, 1);
+    /* integer part (rounds toward zero) */
+    lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
+    pushnumint(L, ip);
+    /* fractional part (test needed for inf/-inf) */
+    lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
+  }
   return 2;
 }
 
+
 static int math_sqrt (lua_State *L) {
   lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_pow (lua_State *L) {
-  lua_Number x = luaL_checknumber(L, 1);
-  lua_Number y = luaL_checknumber(L, 2);
-  lua_pushnumber(L, l_mathop(pow)(x, y));
+
+static int math_ult (lua_State *L) {
+  lua_Integer a = luaL_checkinteger(L, 1);
+  lua_Integer b = luaL_checkinteger(L, 2);
+  lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
   return 1;
 }
 
@@ -122,32 +173,508 @@ static int math_log (lua_State *L) {
     res = l_mathop(log)(x);
   else {
     lua_Number base = luaL_checknumber(L, 2);
-    if (base == (lua_Number)10.0) res = l_mathop(log10)(x);
-    else res = l_mathop(log)(x)/l_mathop(log)(base);
+#if !defined(LUA_USE_C89)
+    if (base == l_mathop(2.0))
+      res = l_mathop(log2)(x);
+    else
+#endif
+    if (base == l_mathop(10.0))
+      res = l_mathop(log10)(x);
+    else
+      res = l_mathop(log)(x)/l_mathop(log)(base);
   }
   lua_pushnumber(L, res);
   return 1;
 }
 
-#if defined(LUA_COMPAT_LOG10)
-static int math_log10 (lua_State *L) {
-  lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
-  return 1;
-}
-#endif
-
 static int math_exp (lua_State *L) {
   lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
   return 1;
 }
 
 static int math_deg (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
+  lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
   return 1;
 }
 
 static int math_rad (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
+  lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
+  return 1;
+}
+
+
+static int math_min (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int imin = 1;  /* index of current minimum value */
+  int i;
+  luaL_argcheck(L, n >= 1, 1, "value expected");
+  for (i = 2; i <= n; i++) {
+    if (lua_compare(L, i, imin, LUA_OPLT))
+      imin = i;
+  }
+  lua_pushvalue(L, imin);
+  return 1;
+}
+
+
+static int math_max (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int imax = 1;  /* index of current maximum value */
+  int i;
+  luaL_argcheck(L, n >= 1, 1, "value expected");
+  for (i = 2; i <= n; i++) {
+    if (lua_compare(L, imax, i, LUA_OPLT))
+      imax = i;
+  }
+  lua_pushvalue(L, imax);
+  return 1;
+}
+
+
+static int math_type (lua_State *L) {
+  if (lua_type(L, 1) == LUA_TNUMBER)
+    lua_pushstring(L, (lua_isinteger(L, 1)) ? "integer" : "float");
+  else {
+    luaL_checkany(L, 1);
+    luaL_pushfail(L);
+  }
+  return 1;
+}
+
+
+
+/*
+** {==================================================================
+** Pseudo-Random Number Generator based on 'xoshiro256**'.
+** ===================================================================
+*/
+
+/* number of binary digits in the mantissa of a float */
+#define FIGS	l_floatatt(MANT_DIG)
+
+#if FIGS > 64
+/* there are only 64 random bits; use them all */
+#undef FIGS
+#define FIGS	64
+#endif
+
+
+/*
+** LUA_RAND32 forces the use of 32-bit integers in the implementation
+** of the PRN generator (mainly for testing).
+*/
+#if !defined(LUA_RAND32) && !defined(Rand64)
+
+/* try to find an integer type with at least 64 bits */
+
+#if ((ULONG_MAX >> 31) >> 31) >= 3
+
+/* 'long' has at least 64 bits */
+#define Rand64		unsigned long
+
+#elif !defined(LUA_USE_C89) && defined(LLONG_MAX)
+
+/* there is a 'long long' type (which must have at least 64 bits) */
+#define Rand64		unsigned long long
+
+#elif ((LUA_MAXUNSIGNED >> 31) >> 31) >= 3
+
+/* 'lua_Unsigned' has at least 64 bits */
+#define Rand64		lua_Unsigned
+
+#endif
+
+#endif
+
+
+#if defined(Rand64)  /* { */
+
+/*
+** Standard implementation, using 64-bit integers.
+** If 'Rand64' has more than 64 bits, the extra bits do not interfere
+** with the 64 initial bits, except in a right shift. Moreover, the
+** final result has to discard the extra bits.
+*/
+
+/* avoid using extra bits when needed */
+#define trim64(x)	((x) & 0xffffffffffffffffu)
+
+
+/* rotate left 'x' by 'n' bits */
+static Rand64 rotl (Rand64 x, int n) {
+  return (x << n) | (trim64(x) >> (64 - n));
+}
+
+static Rand64 nextrand (Rand64 *state) {
+  Rand64 state0 = state[0];
+  Rand64 state1 = state[1];
+  Rand64 state2 = state[2] ^ state0;
+  Rand64 state3 = state[3] ^ state1;
+  Rand64 res = rotl(state1 * 5, 7) * 9;
+  state[0] = state0 ^ state3;
+  state[1] = state1 ^ state2;
+  state[2] = state2 ^ (state1 << 17);
+  state[3] = rotl(state3, 45);
+  return res;
+}
+
+
+/* must take care to not shift stuff by more than 63 slots */
+
+
+/*
+** Convert bits from a random integer into a float in the
+** interval [0,1), getting the higher FIG bits from the
+** random unsigned integer and converting that to a float.
+*/
+
+/* must throw out the extra (64 - FIGS) bits */
+#define shift64_FIG	(64 - FIGS)
+
+/* to scale to [0, 1), multiply by scaleFIG = 2^(-FIGS) */
+#define scaleFIG	(l_mathop(0.5) / ((Rand64)1 << (FIGS - 1)))
+
+static lua_Number I2d (Rand64 x) {
+  return (lua_Number)(trim64(x) >> shift64_FIG) * scaleFIG;
+}
+
+/* convert a 'Rand64' to a 'lua_Unsigned' */
+#define I2UInt(x)	((lua_Unsigned)trim64(x))
+
+/* convert a 'lua_Unsigned' to a 'Rand64' */
+#define Int2I(x)	((Rand64)(x))
+
+
+#else	/* no 'Rand64'   }{ */
+
+/* get an integer with at least 32 bits */
+#if LUAI_IS32INT
+typedef unsigned int lu_int32;
+#else
+typedef unsigned long lu_int32;
+#endif
+
+
+/*
+** Use two 32-bit integers to represent a 64-bit quantity.
+*/
+typedef struct Rand64 {
+  lu_int32 h;  /* higher half */
+  lu_int32 l;  /* lower half */
+} Rand64;
+
+
+/*
+** If 'lu_int32' has more than 32 bits, the extra bits do not interfere
+** with the 32 initial bits, except in a right shift and comparisons.
+** Moreover, the final result has to discard the extra bits.
+*/
+
+/* avoid using extra bits when needed */
+#define trim32(x)	((x) & 0xffffffffu)
+
+
+/*
+** basic operations on 'Rand64' values
+*/
+
+/* build a new Rand64 value */
+static Rand64 packI (lu_int32 h, lu_int32 l) {
+  Rand64 result;
+  result.h = h;
+  result.l = l;
+  return result;
+}
+
+/* return i << n */
+static Rand64 Ishl (Rand64 i, int n) {
+  lua_assert(n > 0 && n < 32);
+  return packI((i.h << n) | (trim32(i.l) >> (32 - n)), i.l << n);
+}
+
+/* i1 ^= i2 */
+static void Ixor (Rand64 *i1, Rand64 i2) {
+  i1->h ^= i2.h;
+  i1->l ^= i2.l;
+}
+
+/* return i1 + i2 */
+static Rand64 Iadd (Rand64 i1, Rand64 i2) {
+  Rand64 result = packI(i1.h + i2.h, i1.l + i2.l);
+  if (trim32(result.l) < trim32(i1.l))  /* carry? */
+    result.h++;
+  return result;
+}
+
+/* return i * 5 */
+static Rand64 times5 (Rand64 i) {
+  return Iadd(Ishl(i, 2), i);  /* i * 5 == (i << 2) + i */
+}
+
+/* return i * 9 */
+static Rand64 times9 (Rand64 i) {
+  return Iadd(Ishl(i, 3), i);  /* i * 9 == (i << 3) + i */
+}
+
+/* return 'i' rotated left 'n' bits */
+static Rand64 rotl (Rand64 i, int n) {
+  lua_assert(n > 0 && n < 32);
+  return packI((i.h << n) | (trim32(i.l) >> (32 - n)),
+               (trim32(i.h) >> (32 - n)) | (i.l << n));
+}
+
+/* for offsets larger than 32, rotate right by 64 - offset */
+static Rand64 rotl1 (Rand64 i, int n) {
+  lua_assert(n > 32 && n < 64);
+  n = 64 - n;
+  return packI((trim32(i.h) >> n) | (i.l << (32 - n)),
+               (i.h << (32 - n)) | (trim32(i.l) >> n));
+}
+
+/*
+** implementation of 'xoshiro256**' algorithm on 'Rand64' values
+*/
+static Rand64 nextrand (Rand64 *state) {
+  Rand64 res = times9(rotl(times5(state[1]), 7));
+  Rand64 t = Ishl(state[1], 17);
+  Ixor(&state[2], state[0]);
+  Ixor(&state[3], state[1]);
+  Ixor(&state[1], state[2]);
+  Ixor(&state[0], state[3]);
+  Ixor(&state[2], t);
+  state[3] = rotl1(state[3], 45);
+  return res;
+}
+
+
+/*
+** Converts a 'Rand64' into a float.
+*/
+
+/* an unsigned 1 with proper type */
+#define UONE		((lu_int32)1)
+
+
+#if FIGS <= 32
+
+/* 2^(-FIGS) */
+#define scaleFIG       (l_mathop(0.5) / (UONE << (FIGS - 1)))
+
+/*
+** get up to 32 bits from higher half, shifting right to
+** throw out the extra bits.
+*/
+static lua_Number I2d (Rand64 x) {
+  lua_Number h = (lua_Number)(trim32(x.h) >> (32 - FIGS));
+  return h * scaleFIG;
+}
+
+#else	/* 32 < FIGS <= 64 */
+
+/* must take care to not shift stuff by more than 31 slots */
+
+/* 2^(-FIGS) = 1.0 / 2^30 / 2^3 / 2^(FIGS-33) */
+#define scaleFIG  \
+    (l_mathop(1.0) / (UONE << 30) / l_mathop(8.0) / (UONE << (FIGS - 33)))
+
+/*
+** use FIGS - 32 bits from lower half, throwing out the other
+** (32 - (FIGS - 32)) = (64 - FIGS) bits
+*/
+#define shiftLOW	(64 - FIGS)
+
+/*
+** higher 32 bits go after those (FIGS - 32) bits: shiftHI = 2^(FIGS - 32)
+*/
+#define shiftHI		((lua_Number)(UONE << (FIGS - 33)) * l_mathop(2.0))
+
+
+static lua_Number I2d (Rand64 x) {
+  lua_Number h = (lua_Number)trim32(x.h) * shiftHI;
+  lua_Number l = (lua_Number)(trim32(x.l) >> shiftLOW);
+  return (h + l) * scaleFIG;
+}
+
+#endif
+
+
+/* convert a 'Rand64' to a 'lua_Unsigned' */
+static lua_Unsigned I2UInt (Rand64 x) {
+  return (((lua_Unsigned)trim32(x.h) << 31) << 1) | (lua_Unsigned)trim32(x.l);
+}
+
+/* convert a 'lua_Unsigned' to a 'Rand64' */
+static Rand64 Int2I (lua_Unsigned n) {
+  return packI((lu_int32)((n >> 31) >> 1), (lu_int32)n);
+}
+
+#endif  /* } */
+
+
+/*
+** A state uses four 'Rand64' values.
+*/
+typedef struct {
+  Rand64 s[4];
+} RanState;
+
+
+/*
+** Project the random integer 'ran' into the interval [0, n].
+** Because 'ran' has 2^B possible values, the projection can only be
+** uniform when the size of the interval is a power of 2 (exact
+** division). Otherwise, to get a uniform projection into [0, n], we
+** first compute 'lim', the smallest Mersenne number not smaller than
+** 'n'. We then project 'ran' into the interval [0, lim].  If the result
+** is inside [0, n], we are done. Otherwise, we try with another 'ran',
+** until we have a result inside the interval.
+*/
+static lua_Unsigned project (lua_Unsigned ran, lua_Unsigned n,
+                             RanState *state) {
+  if ((n & (n + 1)) == 0)  /* is 'n + 1' a power of 2? */
+    return ran & n;  /* no bias */
+  else {
+    lua_Unsigned lim = n;
+    /* compute the smallest (2^b - 1) not smaller than 'n' */
+    lim |= (lim >> 1);
+    lim |= (lim >> 2);
+    lim |= (lim >> 4);
+    lim |= (lim >> 8);
+    lim |= (lim >> 16);
+#if (LUA_MAXUNSIGNED >> 31) >= 3
+    lim |= (lim >> 32);  /* integer type has more than 32 bits */
+#endif
+    lua_assert((lim & (lim + 1)) == 0  /* 'lim + 1' is a power of 2, */
+      && lim >= n  /* not smaller than 'n', */
+      && (lim >> 1) < n);  /* and it is the smallest one */
+    while ((ran &= lim) > n)  /* project 'ran' into [0..lim] */
+      ran = I2UInt(nextrand(state->s));  /* not inside [0..n]? try again */
+    return ran;
+  }
+}
+
+
+static int math_random (lua_State *L) {
+  lua_Integer low, up;
+  lua_Unsigned p;
+  RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
+  Rand64 rv = nextrand(state->s);  /* next pseudo-random value */
+  switch (lua_gettop(L)) {  /* check number of arguments */
+    case 0: {  /* no arguments */
+      lua_pushnumber(L, I2d(rv));  /* float between 0 and 1 */
+      return 1;
+    }
+    case 1: {  /* only upper limit */
+      low = 1;
+      up = luaL_checkinteger(L, 1);
+      if (up == 0) {  /* single 0 as argument? */
+        lua_pushinteger(L, I2UInt(rv));  /* full random integer */
+        return 1;
+      }
+      break;
+    }
+    case 2: {  /* lower and upper limits */
+      low = luaL_checkinteger(L, 1);
+      up = luaL_checkinteger(L, 2);
+      break;
+    }
+    default: return luaL_error(L, "wrong number of arguments");
+  }
+  /* random integer in the interval [low, up] */
+  luaL_argcheck(L, low <= up, 1, "interval is empty");
+  /* project random integer into the interval [0, up - low] */
+  p = project(I2UInt(rv), (lua_Unsigned)up - (lua_Unsigned)low, state);
+  lua_pushinteger(L, p + (lua_Unsigned)low);
+  return 1;
+}
+
+
+static void setseed (lua_State *L, Rand64 *state,
+                     lua_Unsigned n1, lua_Unsigned n2) {
+  int i;
+  state[0] = Int2I(n1);
+  state[1] = Int2I(0xff);  /* avoid a zero state */
+  state[2] = Int2I(n2);
+  state[3] = Int2I(0);
+  for (i = 0; i < 16; i++)
+    nextrand(state);  /* discard initial values to "spread" seed */
+  lua_pushinteger(L, n1);
+  lua_pushinteger(L, n2);
+}
+
+
+/*
+** Set a "random" seed. To get some randomness, use the current time
+** and the address of 'L' (in case the machine does address space layout
+** randomization).
+*/
+static void randseed (lua_State *L, RanState *state) {
+  lua_Unsigned seed1 = (lua_Unsigned)time(NULL);
+  lua_Unsigned seed2 = (lua_Unsigned)(size_t)L;
+  setseed(L, state->s, seed1, seed2);
+}
+
+
+static int math_randomseed (lua_State *L) {
+  RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
+  if (lua_isnone(L, 1)) {
+    randseed(L, state);
+  }
+  else {
+    lua_Integer n1 = luaL_checkinteger(L, 1);
+    lua_Integer n2 = luaL_optinteger(L, 2, 0);
+    setseed(L, state->s, n1, n2);
+  }
+  return 2;  /* return seeds */
+}
+
+
+static const luaL_Reg randfuncs[] = {
+  {"random", math_random},
+  {"randomseed", math_randomseed},
+  {NULL, NULL}
+};
+
+
+/*
+** Register the random functions and initialize their state.
+*/
+static void setrandfunc (lua_State *L) {
+  RanState *state = (RanState *)lua_newuserdatauv(L, sizeof(RanState), 0);
+  randseed(L, state);  /* initialize with a "random" seed */
+  lua_pop(L, 2);  /* remove pushed seeds */
+  luaL_setfuncs(L, randfuncs, 1);
+}
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Deprecated functions (for compatibility only)
+** ===================================================================
+*/
+#if defined(LUA_COMPAT_MATHLIB)
+
+static int math_cosh (lua_State *L) {
+  lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_sinh (lua_State *L) {
+  lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_tanh (lua_State *L) {
+  lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_pow (lua_State *L) {
+  lua_Number x = luaL_checknumber(L, 1);
+  lua_Number y = luaL_checknumber(L, 2);
+  lua_pushnumber(L, l_mathop(pow)(x, y));
   return 1;
 }
 
@@ -160,107 +687,60 @@ static int math_frexp (lua_State *L) {
 
 static int math_ldexp (lua_State *L) {
   lua_Number x = luaL_checknumber(L, 1);
-  int ep = luaL_checkint(L, 2);
+  int ep = (int)luaL_checkinteger(L, 2);
   lua_pushnumber(L, l_mathop(ldexp)(x, ep));
   return 1;
 }
 
-
-
-static int math_min (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  lua_Number dmin = luaL_checknumber(L, 1);
-  int i;
-  for (i=2; i<=n; i++) {
-    lua_Number d = luaL_checknumber(L, i);
-    if (d < dmin)
-      dmin = d;
-  }
-  lua_pushnumber(L, dmin);
+static int math_log10 (lua_State *L) {
+  lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
   return 1;
 }
 
+#endif
+/* }================================================================== */
 
-static int math_max (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  lua_Number dmax = luaL_checknumber(L, 1);
-  int i;
-  for (i=2; i<=n; i++) {
-    lua_Number d = luaL_checknumber(L, i);
-    if (d > dmax)
-      dmax = d;
-  }
-  lua_pushnumber(L, dmax);
-  return 1;
-}
-
-
-static int math_random (lua_State *L) {
-  /* the `%' avoids the (rare) case of r==1, and is needed also because on
-     some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
-  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
-  switch (lua_gettop(L)) {  /* check number of arguments */
-    case 0: {  /* no arguments */
-      lua_pushnumber(L, r);  /* Number between 0 and 1 */
-      break;
-    }
-    case 1: {  /* only upper limit */
-      lua_Number u = luaL_checknumber(L, 1);
-      luaL_argcheck(L, (lua_Number)1.0 <= u, 1, "interval is empty");
-      lua_pushnumber(L, l_mathop(floor)(r*u) + (lua_Number)(1.0));  /* [1, u] */
-      break;
-    }
-    case 2: {  /* lower and upper limits */
-      lua_Number l = luaL_checknumber(L, 1);
-      lua_Number u = luaL_checknumber(L, 2);
-      luaL_argcheck(L, l <= u, 2, "interval is empty");
-      lua_pushnumber(L, l_mathop(floor)(r*(u-l+1)) + l);  /* [l, u] */
-      break;
-    }
-    default: return luaL_error(L, "wrong number of arguments");
-  }
-  return 1;
-}
-
-
-static int math_randomseed (lua_State *L) {
-  srand(luaL_checkunsigned(L, 1));
-  (void)rand(); /* discard first value to avoid undesirable correlations */
-  return 0;
-}
 
 
 static const luaL_Reg mathlib[] = {
   {"abs",   math_abs},
   {"acos",  math_acos},
   {"asin",  math_asin},
-  {"atan2", math_atan2},
   {"atan",  math_atan},
   {"ceil",  math_ceil},
-  {"cosh",   math_cosh},
   {"cos",   math_cos},
   {"deg",   math_deg},
   {"exp",   math_exp},
+  {"tointeger", math_toint},
   {"floor", math_floor},
   {"fmod",   math_fmod},
-  {"frexp", math_frexp},
-  {"ldexp", math_ldexp},
-#if defined(LUA_COMPAT_LOG10)
-  {"log10", math_log10},
-#endif
+  {"ult",   math_ult},
   {"log",   math_log},
   {"max",   math_max},
   {"min",   math_min},
   {"modf",   math_modf},
-  {"pow",   math_pow},
   {"rad",   math_rad},
-  {"random",     math_random},
-  {"randomseed", math_randomseed},
-  {"sinh",   math_sinh},
   {"sin",   math_sin},
   {"sqrt",  math_sqrt},
-  {"tanh",   math_tanh},
   {"tan",   math_tan},
+  {"type", math_type},
+#if defined(LUA_COMPAT_MATHLIB)
+  {"atan2", math_atan},
+  {"cosh",   math_cosh},
+  {"sinh",   math_sinh},
+  {"tanh",   math_tanh},
+  {"pow",   math_pow},
+  {"frexp", math_frexp},
+  {"ldexp", math_ldexp},
+  {"log10", math_log10},
+#endif
+  /* placeholders */
+  {"random", NULL},
+  {"randomseed", NULL},
+  {"pi", NULL},
+  {"huge", NULL},
+  {"maxinteger", NULL},
+  {"mininteger", NULL},
   {NULL, NULL}
 };
 
@@ -272,8 +752,13 @@ LUAMOD_API int luaopen_math (lua_State *L) {
   luaL_newlib(L, mathlib);
   lua_pushnumber(L, PI);
   lua_setfield(L, -2, "pi");
-  lua_pushnumber(L, HUGE_VAL);
+  lua_pushnumber(L, (lua_Number)HUGE_VAL);
   lua_setfield(L, -2, "huge");
+  lua_pushinteger(L, LUA_MAXINTEGER);
+  lua_setfield(L, -2, "maxinteger");
+  lua_pushinteger(L, LUA_MININTEGER);
+  lua_setfield(L, -2, "mininteger");
+  setrandfunc(L);
   return 1;
 }
 

3rd/lua/lmem.c

@@ -1,15 +1,17 @@
 /*
-** $Id: lmem.c,v 1.84.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lmem.c $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
 
-
-#include <stddef.h>
-
 #define lmem_c
 #define LUA_CORE
 
+#include "lprefix.h"
+
+
+#include <stddef.h>
+
 #include "lua.h"
 
 #include "ldebug.h"
@@ -23,77 +25,191 @@
 
 /*
 ** About the realloc function:
-** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
-** (`osize' is the old size, `nsize' is the new size)
+** void *frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
+** ('osize' is the old size, 'nsize' is the new size)
 **
-** * frealloc(ud, NULL, x, s) creates a new block of size `s' (no
-** matter 'x').
+** - frealloc(ud, p, x, 0) frees the block 'p' and returns NULL.
+** Particularly, frealloc(ud, NULL, 0, 0) does nothing,
+** which is equivalent to free(NULL) in ISO C.
 **
-** * frealloc(ud, p, x, 0) frees the block `p'
-** (in this specific case, frealloc must return NULL);
-** particularly, frealloc(ud, NULL, 0, 0) does nothing
-** (which is equivalent to free(NULL) in ANSI C)
+** - frealloc(ud, NULL, x, s) creates a new block of size 's'
+** (no matter 'x'). Returns NULL if it cannot create the new block.
 **
-** frealloc returns NULL if it cannot create or reallocate the area
-** (any reallocation to an equal or smaller size cannot fail!)
+** - otherwise, frealloc(ud, b, x, y) reallocates the block 'b' from
+** size 'x' to size 'y'. Returns NULL if it cannot reallocate the
+** block to the new size.
 */
 
 
+/*
+** Macro to call the allocation function.
+*/
+#define callfrealloc(g,block,os,ns)    ((*g->frealloc)(g->ud, block, os, ns))
 
+
+/*
+** When an allocation fails, it will try again after an emergency
+** collection, except when it cannot run a collection.  The GC should
+** not be called while the state is not fully built, as the collector
+** is not yet fully initialized. Also, it should not be called when
+** 'gcstopem' is true, because then the interpreter is in the middle of
+** a collection step.
+*/
+#define cantryagain(g)	(completestate(g) && !g->gcstopem)
+
+
+
+
+#if defined(EMERGENCYGCTESTS)
+/*
+** First allocation will fail except when freeing a block (frees never
+** fail) and when it cannot try again; this fail will trigger 'tryagain'
+** and a full GC cycle at every allocation.
+*/
+static void *firsttry (global_State *g, void *block, size_t os, size_t ns) {
+  if (ns > 0 && cantryagain(g))
+    return NULL;  /* fail */
+  else  /* normal allocation */
+    return callfrealloc(g, block, os, ns);
+}
+#else
+#define firsttry(g,block,os,ns)    callfrealloc(g, block, os, ns)
+#endif
+
+
+
+
+
+/*
+** {==================================================================
+** Functions to allocate/deallocate arrays for the Parser
+** ===================================================================
+*/
+
+/*
+** Minimum size for arrays during parsing, to avoid overhead of
+** reallocating to size 1, then 2, and then 4. All these arrays
+** will be reallocated to exact sizes or erased when parsing ends.
+*/
 #define MINSIZEARRAY	4
 
 
-void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
-                     int limit, const char *what) {
+void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize,
+                     int size_elems, int limit, const char *what) {
   void *newblock;
-  int newsize;
-  if (*size >= limit/2) {  /* cannot double it? */
-    if (*size >= limit)  /* cannot grow even a little? */
+  int size = *psize;
+  if (nelems + 1 <= size)  /* does one extra element still fit? */
+    return block;  /* nothing to be done */
+  if (size >= limit / 2) {  /* cannot double it? */
+    if (l_unlikely(size >= limit))  /* cannot grow even a little? */
       luaG_runerror(L, "too many %s (limit is %d)", what, limit);
-    newsize = limit;  /* still have at least one free place */
+    size = limit;  /* still have at least one free place */
   }
   else {
-    newsize = (*size)*2;
-    if (newsize < MINSIZEARRAY)
-      newsize = MINSIZEARRAY;  /* minimum size */
+    size *= 2;
+    if (size < MINSIZEARRAY)
+      size = MINSIZEARRAY;  /* minimum size */
   }
-  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
-  *size = newsize;  /* update only when everything else is OK */
+  lua_assert(nelems + 1 <= size && size <= limit);
+  /* 'limit' ensures that multiplication will not overflow */
+  newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems,
+                                         cast_sizet(size) * size_elems);
+  *psize = size;  /* update only when everything else is OK */
   return newblock;
 }
 
 
+/*
+** In prototypes, the size of the array is also its number of
+** elements (to save memory). So, if it cannot shrink an array
+** to its number of elements, the only option is to raise an
+** error.
+*/
+void *luaM_shrinkvector_ (lua_State *L, void *block, int *size,
+                          int final_n, int size_elem) {
+  void *newblock;
+  size_t oldsize = cast_sizet((*size) * size_elem);
+  size_t newsize = cast_sizet(final_n * size_elem);
+  lua_assert(newsize <= oldsize);
+  newblock = luaM_saferealloc_(L, block, oldsize, newsize);
+  *size = final_n;
+  return newblock;
+}
+
+/* }================================================================== */
+
+
 l_noret luaM_toobig (lua_State *L) {
   luaG_runerror(L, "memory allocation error: block too big");
 }
 
 
+/*
+** Free memory
+*/
+void luaM_free_ (lua_State *L, void *block, size_t osize) {
+  global_State *g = G(L);
+  lua_assert((osize == 0) == (block == NULL));
+  callfrealloc(g, block, osize, 0);
+  g->GCdebt -= osize;
+}
+
 
 /*
-** generic allocation routine.
+** In case of allocation fail, this function will do an emergency
+** collection to free some memory and then try the allocation again.
+*/
+static void *tryagain (lua_State *L, void *block,
+                       size_t osize, size_t nsize) {
+  global_State *g = G(L);
+  if (cantryagain(g)) {
+    luaC_fullgc(L, 1);  /* try to free some memory... */
+    return callfrealloc(g, block, osize, nsize);  /* try again */
+  }
+  else return NULL;  /* cannot run an emergency collection */
+}
+
+
+/*
+** Generic allocation routine.
 */
 void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
   void *newblock;
   global_State *g = G(L);
-  size_t realosize = (block) ? osize : 0;
-  lua_assert((realosize == 0) == (block == NULL));
-#if defined(HARDMEMTESTS)
-  if (nsize > realosize && g->gcrunning)
-    luaC_fullgc(L, 1);  /* force a GC whenever possible */
-#endif
-  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
-  if (newblock == NULL && nsize > 0) {
-    api_check(L, nsize > realosize,
-                 "realloc cannot fail when shrinking a block");
-    if (g->gcrunning) {
-      luaC_fullgc(L, 1);  /* try to free some memory... */
-      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
-    }
-    if (newblock == NULL)
-      luaD_throw(L, LUA_ERRMEM);
+  lua_assert((osize == 0) == (block == NULL));
+  newblock = firsttry(g, block, osize, nsize);
+  if (l_unlikely(newblock == NULL && nsize > 0)) {
+    newblock = tryagain(L, block, osize, nsize);
+    if (newblock == NULL)  /* still no memory? */
+      return NULL;  /* do not update 'GCdebt' */
   }
   lua_assert((nsize == 0) == (newblock == NULL));
-  g->GCdebt = (g->GCdebt + nsize) - realosize;
+  g->GCdebt = (g->GCdebt + nsize) - osize;
   return newblock;
 }
 
+
+void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize,
+                                                    size_t nsize) {
+  void *newblock = luaM_realloc_(L, block, osize, nsize);
+  if (l_unlikely(newblock == NULL && nsize > 0))  /* allocation failed? */
+    luaM_error(L);
+  return newblock;
+}
+
+
+void *luaM_malloc_ (lua_State *L, size_t size, int tag) {
+  if (size == 0)
+    return NULL;  /* that's all */
+  else {
+    global_State *g = G(L);
+    void *newblock = firsttry(g, NULL, tag, size);
+    if (l_unlikely(newblock == NULL)) {
+      newblock = tryagain(L, NULL, tag, size);
+      if (newblock == NULL)
+        luaM_error(L);
+    }
+    g->GCdebt += size;
+    return newblock;
+  }
+}

3rd/lua/lmem.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lmem.h $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -14,44 +14,80 @@
 #include "lua.h"
 
 
+#define luaM_error(L)	luaD_throw(L, LUA_ERRMEM)
+
+
 /*
-** This macro avoids the runtime division MAX_SIZET/(e), as 'e' is
-** always constant.
-** The macro is somewhat complex to avoid warnings:
-** +1 avoids warnings of "comparison has constant result";
-** cast to 'void' avoids warnings of "value unused".
+** This macro tests whether it is safe to multiply 'n' by the size of
+** type 't' without overflows. Because 'e' is always constant, it avoids
+** the runtime division MAX_SIZET/(e).
+** (The macro is somewhat complex to avoid warnings:  The 'sizeof'
+** comparison avoids a runtime comparison when overflow cannot occur.
+** The compiler should be able to optimize the real test by itself, but
+** when it does it, it may give a warning about "comparison is always
+** false due to limited range of data type"; the +1 tricks the compiler,
+** avoiding this warning but also this optimization.)
 */
-#define luaM_reallocv(L,b,on,n,e) \
-  (cast(void, \
-     (cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \
-   luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
+#define luaM_testsize(n,e)  \
+	(sizeof(n) >= sizeof(size_t) && cast_sizet((n)) + 1 > MAX_SIZET/(e))
 
-#define luaM_freemem(L, b, s)	luaM_realloc_(L, (b), (s), 0)
-#define luaM_free(L, b)		luaM_realloc_(L, (b), sizeof(*(b)), 0)
-#define luaM_freearray(L, b, n)   luaM_reallocv(L, (b), n, 0, sizeof((b)[0]))
+#define luaM_checksize(L,n,e)  \
+	(luaM_testsize(n,e) ? luaM_toobig(L) : cast_void(0))
 
-#define luaM_malloc(L,s)	luaM_realloc_(L, NULL, 0, (s))
-#define luaM_new(L,t)		cast(t *, luaM_malloc(L, sizeof(t)))
-#define luaM_newvector(L,n,t) \
-		cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
 
-#define luaM_newobject(L,tag,s)	luaM_realloc_(L, NULL, tag, (s))
+/*
+** Computes the minimum between 'n' and 'MAX_SIZET/sizeof(t)', so that
+** the result is not larger than 'n' and cannot overflow a 'size_t'
+** when multiplied by the size of type 't'. (Assumes that 'n' is an
+** 'int' or 'unsigned int' and that 'int' is not larger than 'size_t'.)
+*/
+#define luaM_limitN(n,t)  \
+  ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) :  \
+     cast_uint((MAX_SIZET/sizeof(t))))
+
+
+/*
+** Arrays of chars do not need any test
+*/
+#define luaM_reallocvchar(L,b,on,n)  \
+  cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
+
+#define luaM_freemem(L, b, s)	luaM_free_(L, (b), (s))
+#define luaM_free(L, b)		luaM_free_(L, (b), sizeof(*(b)))
+#define luaM_freearray(L, b, n)   luaM_free_(L, (b), (n)*sizeof(*(b)))
+
+#define luaM_new(L,t)		cast(t*, luaM_malloc_(L, sizeof(t), 0))
+#define luaM_newvector(L,n,t)	cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0))
+#define luaM_newvectorchecked(L,n,t) \
+  (luaM_checksize(L,n,sizeof(t)), luaM_newvector(L,n,t))
+
+#define luaM_newobject(L,tag,s)	luaM_malloc_(L, (s), tag)
 
 #define luaM_growvector(L,v,nelems,size,t,limit,e) \
-          if ((nelems)+1 > (size)) \
-            ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
+	((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \
+                         luaM_limitN(limit,t),e)))
 
 #define luaM_reallocvector(L, v,oldn,n,t) \
-   ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
+   (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \
+                                  cast_sizet(n) * sizeof(t))))
+
+#define luaM_shrinkvector(L,v,size,fs,t) \
+   ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t))))
 
 LUAI_FUNC l_noret luaM_toobig (lua_State *L);
 
 /* not to be called directly */
 LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
                                                           size_t size);
-LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
-                               size_t size_elem, int limit,
+LUAI_FUNC void *luaM_saferealloc_ (lua_State *L, void *block, size_t oldsize,
+                                                              size_t size);
+LUAI_FUNC void luaM_free_ (lua_State *L, void *block, size_t osize);
+LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int nelems,
+                               int *size, int size_elem, int limit,
                                const char *what);
+LUAI_FUNC void *luaM_shrinkvector_ (lua_State *L, void *block, int *nelem,
+                                    int final_n, int size_elem);
+LUAI_FUNC void *luaM_malloc_ (lua_State *L, size_t size, int tag);
 
 #endif
 

3rd/lua/loadlib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: loadlib.c,v 1.111.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: loadlib.c $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
@@ -8,22 +8,16 @@
 ** systems.
 */
 
-
-/*
-** if needed, includes windows header before everything else
-*/
-#if defined(_WIN32)
-#include <windows.h>
-#endif
-
-
-#include <stdlib.h>
-#include <string.h>
-
-
 #define loadlib_c
 #define LUA_LIB
 
+#include "lprefix.h"
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -31,40 +25,9 @@
 
 
 /*
-** LUA_PATH and LUA_CPATH are the names of the environment
-** variables that Lua check to set its paths.
-*/
-#if !defined(LUA_PATH)
-#define LUA_PATH	"LUA_PATH"
-#endif
-
-#if !defined(LUA_CPATH)
-#define LUA_CPATH	"LUA_CPATH"
-#endif
-
-#define LUA_PATHSUFFIX		"_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
-
-#define LUA_PATHVERSION		LUA_PATH LUA_PATHSUFFIX
-#define LUA_CPATHVERSION	LUA_CPATH LUA_PATHSUFFIX
-
-/*
-** LUA_PATH_SEP is the character that separates templates in a path.
-** LUA_PATH_MARK is the string that marks the substitution points in a
-** template.
-** LUA_EXEC_DIR in a Windows path is replaced by the executable's
-** directory.
 ** LUA_IGMARK is a mark to ignore all before it when building the
 ** luaopen_ function name.
 */
-#if !defined (LUA_PATH_SEP)
-#define LUA_PATH_SEP		";"
-#endif
-#if !defined (LUA_PATH_MARK)
-#define LUA_PATH_MARK		"?"
-#endif
-#if !defined (LUA_EXEC_DIR)
-#define LUA_EXEC_DIR		"!"
-#endif
 #if !defined (LUA_IGMARK)
 #define LUA_IGMARK		"-"
 #endif
@@ -92,29 +55,53 @@
 #define LUA_OFSEP	"_"
 
 
-/* table (in the registry) that keeps handles for all loaded C libraries */
-#define CLIBS		"_CLIBS"
+/*
+** key for table in the registry that keeps handles
+** for all loaded C libraries
+*/
+static const char *const CLIBS = "_CLIBS";
 
 #define LIB_FAIL	"open"
 
 
-/* error codes for ll_loadfunc */
-#define ERRLIB		1
-#define ERRFUNC		2
+#define setprogdir(L)           ((void)0)
 
-#define setprogdir(L)		((void)0)
+
+/*
+** Special type equivalent to '(void*)' for functions in gcc
+** (to suppress warnings when converting function pointers)
+*/
+typedef void (*voidf)(void);
 
 
 /*
 ** system-dependent functions
 */
-static void ll_unloadlib (void *lib);
-static void *ll_load (lua_State *L, const char *path, int seeglb);
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);
+
+/*
+** unload library 'lib'
+*/
+static void lsys_unloadlib (void *lib);
+
+/*
+** load C library in file 'path'. If 'seeglb', load with all names in
+** the library global.
+** Returns the library; in case of error, returns NULL plus an
+** error string in the stack.
+*/
+static void *lsys_load (lua_State *L, const char *path, int seeglb);
+
+/*
+** Try to find a function named 'sym' in library 'lib'.
+** Returns the function; in case of error, returns NULL plus an
+** error string in the stack.
+*/
+static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym);
 
 
 
-#if defined(LUA_USE_DLOPEN)
+
+#if defined(LUA_USE_DLOPEN)	/* { */
 /*
 ** {========================================================================
 ** This is an implementation of loadlib based on the dlfcn interface.
@@ -126,21 +113,35 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);
 
 #include <dlfcn.h>
 
-static void ll_unloadlib (void *lib) {
+/*
+** Macro to convert pointer-to-void* to pointer-to-function. This cast
+** is undefined according to ISO C, but POSIX assumes that it works.
+** (The '__extension__' in gnu compilers is only to avoid warnings.)
+*/
+#if defined(__GNUC__)
+#define cast_func(p) (__extension__ (lua_CFunction)(p))
+#else
+#define cast_func(p) ((lua_CFunction)(p))
+#endif
+
+
+static void lsys_unloadlib (void *lib) {
   dlclose(lib);
 }
 
 
-static void *ll_load (lua_State *L, const char *path, int seeglb) {
+static void *lsys_load (lua_State *L, const char *path, int seeglb) {
   void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
-  if (lib == NULL) lua_pushstring(L, dlerror());
+  if (l_unlikely(lib == NULL))
+    lua_pushstring(L, dlerror());
   return lib;
 }
 
 
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)dlsym(lib, sym);
-  if (f == NULL) lua_pushstring(L, dlerror());
+static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
+  lua_CFunction f = cast_func(dlsym(lib, sym));
+  if (l_unlikely(f == NULL))
+    lua_pushstring(L, dlerror());
   return f;
 }
 
@@ -148,14 +149,15 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
 
 
 
-#elif defined(LUA_DL_DLL)
+#elif defined(LUA_DL_DLL)	/* }{ */
 /*
 ** {======================================================================
 ** This is an implementation of loadlib for Windows using native functions.
 ** =======================================================================
 */
 
-#undef setprogdir
+#include <windows.h>
+
 
 /*
 ** optional flags for LoadLibraryEx
@@ -165,21 +167,30 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
 #endif
 
 
+#undef setprogdir
+
+
+/*
+** Replace in the path (on the top of the stack) any occurrence
+** of LUA_EXEC_DIR with the executable's path.
+*/
 static void setprogdir (lua_State *L) {
   char buff[MAX_PATH + 1];
   char *lb;
   DWORD nsize = sizeof(buff)/sizeof(char);
-  DWORD n = GetModuleFileNameA(NULL, buff, nsize);
+  DWORD n = GetModuleFileNameA(NULL, buff, nsize);  /* get exec. name */
   if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
     luaL_error(L, "unable to get ModuleFileName");
   else {
-    *lb = '\0';
+    *lb = '\0';  /* cut name on the last '\\' to get the path */
     luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff);
     lua_remove(L, -2);  /* remove original string */
   }
 }
 
 
+
+
 static void pusherror (lua_State *L) {
   int error = GetLastError();
   char buffer[128];
@@ -190,12 +201,12 @@ static void pusherror (lua_State *L) {
     lua_pushfstring(L, "system error %d\n", error);
 }
 
-static void ll_unloadlib (void *lib) {
+static void lsys_unloadlib (void *lib) {
   FreeLibrary((HMODULE)lib);
 }
 
 
-static void *ll_load (lua_State *L, const char *path, int seeglb) {
+static void *lsys_load (lua_State *L, const char *path, int seeglb) {
   HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
   (void)(seeglb);  /* not used: symbols are 'global' by default */
   if (lib == NULL) pusherror(L);
@@ -203,8 +214,8 @@ static void *ll_load (lua_State *L, const char *path, int seeglb) {
 }
 
 
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym);
+static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
+  lua_CFunction f = (lua_CFunction)(voidf)GetProcAddress((HMODULE)lib, sym);
   if (f == NULL) pusherror(L);
   return f;
 }
@@ -212,7 +223,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
 /* }====================================================== */
 
 
-#else
+#else				/* }{ */
 /*
 ** {======================================================
 ** Fallback for other systems
@@ -226,29 +237,102 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
 #define DLMSG	"dynamic libraries not enabled; check your Lua installation"
 
 
-static void ll_unloadlib (void *lib) {
+static void lsys_unloadlib (void *lib) {
   (void)(lib);  /* not used */
 }
 
 
-static void *ll_load (lua_State *L, const char *path, int seeglb) {
+static void *lsys_load (lua_State *L, const char *path, int seeglb) {
   (void)(path); (void)(seeglb);  /* not used */
   lua_pushliteral(L, DLMSG);
   return NULL;
 }
 
 
-static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
+static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
   (void)(lib); (void)(sym);  /* not used */
   lua_pushliteral(L, DLMSG);
   return NULL;
 }
 
 /* }====================================================== */
+#endif				/* } */
+
+
+/*
+** {==================================================================
+** Set Paths
+** ===================================================================
+*/
+
+/*
+** 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_VAR)
+#define LUA_PATH_VAR    "LUA_PATH"
+#endif
+
+#if !defined(LUA_CPATH_VAR)
+#define LUA_CPATH_VAR   "LUA_CPATH"
 #endif
 
 
-static void *ll_checkclib (lua_State *L, const char *path) {
+
+/*
+** return registry.LUA_NOENV as a boolean
+*/
+static int noenv (lua_State *L) {
+  int b;
+  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
+  b = lua_toboolean(L, -1);
+  lua_pop(L, 1);  /* remove value */
+  return b;
+}
+
+
+/*
+** Set a path
+*/
+static void setpath (lua_State *L, const char *fieldname,
+                                   const char *envname,
+                                   const char *dft) {
+  const char *dftmark;
+  const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
+  const char *path = getenv(nver);  /* try versioned name */
+  if (path == NULL)  /* no versioned environment variable? */
+    path = getenv(envname);  /* try unversioned name */
+  if (path == NULL || noenv(L))  /* no environment variable? */
+    lua_pushstring(L, dft);  /* use default */
+  else if ((dftmark = strstr(path, LUA_PATH_SEP LUA_PATH_SEP)) == NULL)
+    lua_pushstring(L, path);  /* nothing to change */
+  else {  /* path contains a ";;": insert default path in its place */
+    size_t len = strlen(path);
+    luaL_Buffer b;
+    luaL_buffinit(L, &b);
+    if (path < dftmark) {  /* is there a prefix before ';;'? */
+      luaL_addlstring(&b, path, dftmark - path);  /* add it */
+      luaL_addchar(&b, *LUA_PATH_SEP);
+    }
+    luaL_addstring(&b, dft);  /* add default */
+    if (dftmark < path + len - 2) {  /* is there a suffix after ';;'? */
+      luaL_addchar(&b, *LUA_PATH_SEP);
+      luaL_addlstring(&b, dftmark + 2, (path + len - 2) - dftmark);
+    }
+    luaL_pushresult(&b);
+  }
+  setprogdir(L);
+  lua_setfield(L, -3, fieldname);  /* package[fieldname] = path value */
+  lua_pop(L, 1);  /* pop versioned variable name ('nver') */
+}
+
+/* }================================================================== */
+
+
+/*
+** return registry.CLIBS[path]
+*/
+static void *checkclib (lua_State *L, const char *path) {
   void *plib;
   lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
   lua_getfield(L, -1, path);
@@ -258,7 +342,11 @@ static void *ll_checkclib (lua_State *L, const char *path) {
 }
 
 
-static void ll_addtoclib (lua_State *L, const char *path, void *plib) {
+/*
+** registry.CLIBS[path] = plib        -- for queries
+** registry.CLIBS[#CLIBS + 1] = plib  -- also keep a list of all libraries
+*/
+static void addtoclib (lua_State *L, const char *path, void *plib) {
   lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
   lua_pushlightuserdata(L, plib);
   lua_pushvalue(L, -1);
@@ -269,33 +357,49 @@ static void ll_addtoclib (lua_State *L, const char *path, void *plib) {
 
 
 /*
-** __gc tag method for CLIBS table: calls 'll_unloadlib' for all lib
+** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib
 ** handles in list CLIBS
 */
 static int gctm (lua_State *L) {
-  int n = luaL_len(L, 1);
+  lua_Integer n = luaL_len(L, 1);
   for (; n >= 1; n--) {  /* for each handle, in reverse order */
     lua_rawgeti(L, 1, n);  /* get handle CLIBS[n] */
-    ll_unloadlib(lua_touserdata(L, -1));
+    lsys_unloadlib(lua_touserdata(L, -1));
     lua_pop(L, 1);  /* pop handle */
   }
   return 0;
 }
 
 
-static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
-  void *reg = ll_checkclib(L, path);  /* check loaded C libraries */
+
+/* error codes for 'lookforfunc' */
+#define ERRLIB		1
+#define ERRFUNC		2
+
+/*
+** Look for a C function named 'sym' in a dynamically loaded library
+** 'path'.
+** First, check whether the library is already loaded; if not, try
+** to load it.
+** Then, if 'sym' is '*', return true (as library has been loaded).
+** Otherwise, look for symbol 'sym' in the library and push a
+** C function with that symbol.
+** Return 0 and 'true' or a function in the stack; in case of
+** errors, return an error code and an error message in the stack.
+*/
+static int lookforfunc (lua_State *L, const char *path, const char *sym) {
+  void *reg = checkclib(L, path);  /* check loaded C libraries */
   if (reg == NULL) {  /* must load library? */
-    reg = ll_load(L, path, *sym == '*');
+    reg = lsys_load(L, path, *sym == '*');  /* global symbols if 'sym'=='*' */
     if (reg == NULL) return ERRLIB;  /* unable to load library */
-    ll_addtoclib(L, path, reg);
+    addtoclib(L, path, reg);
   }
   if (*sym == '*') {  /* loading only library (no function)? */
     lua_pushboolean(L, 1);  /* return 'true' */
     return 0;  /* no errors */
   }
   else {
-    lua_CFunction f = ll_sym(L, reg, sym);
+    lua_CFunction f = lsys_sym(L, reg, sym);
     if (f == NULL)
       return ERRFUNC;  /* unable to find function */
     lua_pushcfunction(L, f);  /* else create new function */
@@ -307,14 +411,14 @@ static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
 static int ll_loadlib (lua_State *L) {
   const char *path = luaL_checkstring(L, 1);
   const char *init = luaL_checkstring(L, 2);
-  int stat = ll_loadfunc(L, path, init);
-  if (stat == 0)  /* no errors? */
+  int stat = lookforfunc(L, path, init);
+  if (l_likely(stat == 0))  /* no errors? */
     return 1;  /* return the loaded function */
   else {  /* error; error message is on stack top */
-    lua_pushnil(L);
+    luaL_pushfail(L);
     lua_insert(L, -2);
     lua_pushstring(L, (stat == ERRLIB) ?  LIB_FAIL : "init");
-    return 3;  /* return nil, error message, and where */
+    return 3;  /* return fail, error message, and where */
   }
 }
 
@@ -335,14 +439,42 @@ static int readable (const char *filename) {
 }
 
 
-static const char *pushnexttemplate (lua_State *L, const char *path) {
-  const char *l;
-  while (*path == *LUA_PATH_SEP) path++;  /* skip separators */
-  if (*path == '\0') return NULL;  /* no more templates */
-  l = strchr(path, *LUA_PATH_SEP);  /* find next separator */
-  if (l == NULL) l = path + strlen(path);
-  lua_pushlstring(L, path, l - path);  /* template */
-  return l;
+/*
+** Get the next name in '*path' = 'name1;name2;name3;...', changing
+** the ending ';' to '\0' to create a zero-terminated string. Return
+** NULL when list ends.
+*/
+static const char *getnextfilename (char **path, char *end) {
+  char *sep;
+  char *name = *path;
+  if (name == end)
+    return NULL;  /* no more names */
+  else if (*name == '\0') {  /* from previous iteration? */
+    *name = *LUA_PATH_SEP;  /* restore separator */
+    name++;  /* skip it */
+  }
+  sep = strchr(name, *LUA_PATH_SEP);  /* find next separator */
+  if (sep == NULL)  /* separator not found? */
+    sep = end;  /* name goes until the end */
+  *sep = '\0';  /* finish file name */
+  *path = sep;  /* will start next search from here */
+  return name;
+}
+
+
+/*
+** Given a path such as ";blabla.so;blublu.so", pushes the string
+**
+** no file 'blabla.so'
+**	no file 'blublu.so'
+*/
+static void pusherrornotfound (lua_State *L, const char *path) {
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  luaL_addstring(&b, "no file '");
+  luaL_addgsub(&b, path, LUA_PATH_SEP, "'\n\tno file '");
+  luaL_addstring(&b, "'");
+  luaL_pushresult(&b);
 }
 
 
@@ -350,21 +482,25 @@ static const char *searchpath (lua_State *L, const char *name,
                                              const char *path,
                                              const char *sep,
                                              const char *dirsep) {
-  luaL_Buffer msg;  /* to build error message */
-  luaL_buffinit(L, &msg);
-  if (*sep != '\0')  /* non-empty separator? */
+  luaL_Buffer buff;
+  char *pathname;  /* path with name inserted */
+  char *endpathname;  /* its end */
+  const char *filename;
+  /* separator is non-empty and appears in 'name'? */
+  if (*sep != '\0' && strchr(name, *sep) != NULL)
     name = luaL_gsub(L, name, sep, dirsep);  /* replace it by 'dirsep' */
-  while ((path = pushnexttemplate(L, path)) != NULL) {
-    const char *filename = luaL_gsub(L, lua_tostring(L, -1),
-                                     LUA_PATH_MARK, name);
-    lua_remove(L, -2);  /* remove path template */
+  luaL_buffinit(L, &buff);
+  /* add path to the buffer, replacing marks ('?') with the file name */
+  luaL_addgsub(&buff, path, LUA_PATH_MARK, name);
+  luaL_addchar(&buff, '\0');
+  pathname = luaL_buffaddr(&buff);  /* writable list of file names */
+  endpathname = pathname + luaL_bufflen(&buff) - 1;
+  while ((filename = getnextfilename(&pathname, endpathname)) != NULL) {
     if (readable(filename))  /* does file exist and is readable? */
-      return filename;  /* return that file name */
-    lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
-    lua_remove(L, -2);  /* remove file name */
-    luaL_addvalue(&msg);  /* concatenate error msg. entry */
+      return lua_pushstring(L, filename);  /* save and return name */
   }
-  luaL_pushresult(&msg);  /* create error message */
+  luaL_pushresult(&buff);  /* push path to create error message */
+  pusherrornotfound(L, lua_tostring(L, -1));  /* create error message */
   return NULL;  /* not found */
 }
 
@@ -376,9 +512,9 @@ static int ll_searchpath (lua_State *L) {
                                 luaL_optstring(L, 4, LUA_DIRSEP));
   if (f != NULL) return 1;
   else {  /* error message is on top of the stack */
-    lua_pushnil(L);
+    luaL_pushfail(L);
     lua_insert(L, -2);
-    return 2;  /* return nil + error message */
+    return 2;  /* return fail + error message */
   }
 }
 
@@ -389,20 +525,19 @@ static const char *findfile (lua_State *L, const char *name,
   const char *path;
   lua_getfield(L, lua_upvalueindex(1), pname);
   path = lua_tostring(L, -1);
-  if (path == NULL)
-    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
+  if (l_unlikely(path == NULL))
+    luaL_error(L, "'package.%s' must be a string", pname);
   return searchpath(L, name, path, ".", dirsep);
 }
 
 
 static int checkload (lua_State *L, int stat, const char *filename) {
-  if (stat) {  /* module loaded successfully? */
+  if (l_likely(stat)) {  /* module loaded successfully? */
     lua_pushstring(L, filename);  /* will be 2nd argument to module */
     return 2;  /* return open function and file name */
   }
   else
-    return luaL_error(L, "error loading module " LUA_QS
-                         " from file " LUA_QS ":\n\t%s",
+    return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
                           lua_tostring(L, 1), filename, lua_tostring(L, -1));
 }
 
@@ -416,21 +551,29 @@ static int searcher_Lua (lua_State *L) {
 }
 
 
+/*
+** Try to find a load function for module 'modname' at file 'filename'.
+** First, change '.' to '_' in 'modname'; then, if 'modname' has
+** the form X-Y (that is, it has an "ignore mark"), build a function
+** name "luaopen_X" and look for it. (For compatibility, if that
+** fails, it also tries "luaopen_Y".) If there is no ignore mark,
+** look for a function named "luaopen_modname".
+*/
 static int loadfunc (lua_State *L, const char *filename, const char *modname) {
-  const char *funcname;
+  const char *openfunc;
   const char *mark;
   modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
   mark = strchr(modname, *LUA_IGMARK);
   if (mark) {
     int stat;
-    funcname = lua_pushlstring(L, modname, mark - modname);
-    funcname = lua_pushfstring(L, LUA_POF"%s", funcname);
-    stat = ll_loadfunc(L, filename, funcname);
+    openfunc = lua_pushlstring(L, modname, mark - modname);
+    openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
+    stat = lookforfunc(L, filename, openfunc);
     if (stat != ERRFUNC) return stat;
     modname = mark + 1;  /* else go ahead and try old-style name */
   }
-  funcname = lua_pushfstring(L, LUA_POF"%s", modname);
-  return ll_loadfunc(L, filename, funcname);
+  openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
+  return lookforfunc(L, filename, openfunc);
 }
 
 
@@ -455,8 +598,7 @@ static int searcher_Croot (lua_State *L) {
     if (stat != ERRFUNC)
       return checkload(L, 0, filename);  /* real error */
     else {  /* open function not found */
-      lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
-                         name, filename);
+      lua_pushfstring(L, "no module '%s' in file '%s'", name, filename);
       return 1;
     }
   }
@@ -467,29 +609,34 @@ static int searcher_Croot (lua_State *L) {
 
 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_isnil(L, -1))  /* not found? */
-    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
-  return 1;
+  lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
+  if (lua_getfield(L, -1, name) == LUA_TNIL) {  /* not found? */
+    lua_pushfstring(L, "no field package.preload['%s']", name);
+    return 1;
+  }
+  else {
+    lua_pushliteral(L, ":preload:");
+    return 2;
+  }
 }
 
 
 static void findloader (lua_State *L, const char *name) {
   int i;
   luaL_Buffer msg;  /* to build error message */
+  /* push 'package.searchers' to index 3 in the stack */
+  if (l_unlikely(lua_getfield(L, lua_upvalueindex(1), "searchers")
+                 != LUA_TTABLE))
+    luaL_error(L, "'package.searchers' must be a table");
   luaL_buffinit(L, &msg);
-  lua_getfield(L, lua_upvalueindex(1), "searchers");  /* will be at index 3 */
-  if (!lua_istable(L, 3))
-    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_isnil(L, -1)) {  /* no more searchers? */
+    luaL_addstring(&msg, "\n\t");  /* error-message prefix */
+    if (l_unlikely(lua_rawgeti(L, 3, i) == LUA_TNIL)) {  /* no more searchers? */
       lua_pop(L, 1);  /* remove nil */
+      luaL_buffsub(&msg, 2);  /* remove prefix */
       luaL_pushresult(&msg);  /* create error message */
-      luaL_error(L, "module " LUA_QS " not found:%s",
-                    name, lua_tostring(L, -1));
+      luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1));
     }
     lua_pushstring(L, name);
     lua_call(L, 1, 2);  /* call it */
@@ -499,222 +646,117 @@ static void findloader (lua_State *L, const char *name) {
       lua_pop(L, 1);  /* remove extra return */
       luaL_addvalue(&msg);  /* concatenate error message */
     }
-    else
+    else {  /* no error message */
       lua_pop(L, 2);  /* remove both returns */
+      luaL_buffsub(&msg, 2);  /* remove prefix */
+    }
   }
 }
 
 
 static int ll_require (lua_State *L) {
   const char *name = luaL_checkstring(L, 1);
-  lua_settop(L, 1);  /* _LOADED table will be at index 2 */
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, 2, name);  /* _LOADED[name] */
+  lua_settop(L, 1);  /* LOADED table will be at index 2 */
+  lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
+  lua_getfield(L, 2, name);  /* LOADED[name] */
   if (lua_toboolean(L, -1))  /* is it there? */
     return 1;  /* package is already loaded */
   /* else must load package */
   lua_pop(L, 1);  /* remove 'getfield' result */
   findloader(L, name);
-  lua_pushstring(L, name);  /* pass name as argument to module loader */
-  lua_insert(L, -2);  /* name is 1st argument (before search data) */
+  lua_rotate(L, -2, 1);  /* function <-> loader data */
+  lua_pushvalue(L, 1);  /* name is 1st argument to module loader */
+  lua_pushvalue(L, -3);  /* loader data is 2nd argument */
+  /* stack: ...; loader data; loader function; mod. name; loader data */
   lua_call(L, 2, 1);  /* run loader to load module */
+  /* stack: ...; loader data; result from loader */
   if (!lua_isnil(L, -1))  /* non-nil return? */
-    lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
-  lua_getfield(L, 2, name);
-  if (lua_isnil(L, -1)) {   /* module did not set a value? */
+    lua_setfield(L, 2, name);  /* LOADED[name] = returned value */
+  else
+    lua_pop(L, 1);  /* pop nil */
+  if (lua_getfield(L, 2, name) == LUA_TNIL) {   /* module set no 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 */
+    lua_copy(L, -1, -2);  /* replace loader result */
+    lua_setfield(L, 2, name);  /* LOADED[name] = true */
   }
-  return 1;
+  lua_rotate(L, -2, 1);  /* loader data <-> module result  */
+  return 2;  /* return module result and loader data */
 }
 
 /* }====================================================== */
 
 
 
-/*
-** {======================================================
-** 'module' function
-** =======================================================
-*/
-#if defined(LUA_COMPAT_MODULE)
-
-/*
-** changes the environment variable of calling function
-*/
-static void set_env (lua_State *L) {
-  lua_Debug ar;
-  if (lua_getstack(L, 1, &ar) == 0 ||
-      lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
-      lua_iscfunction(L, -1))
-    luaL_error(L, LUA_QL("module") " not called from a Lua function");
-  lua_pushvalue(L, -2);  /* copy new environment table to top */
-  lua_setupvalue(L, -2, 1);
-  lua_pop(L, 1);  /* remove function */
-}
-
-
-static void dooptions (lua_State *L, int n) {
-  int i;
-  for (i = 2; i <= n; i++) {
-    if (lua_isfunction(L, i)) {  /* avoid 'calling' extra info. */
-      lua_pushvalue(L, i);  /* get option (a function) */
-      lua_pushvalue(L, -2);  /* module */
-      lua_call(L, 1, 0);
-    }
-  }
-}
-
-
-static void modinit (lua_State *L, const char *modname) {
-  const char *dot;
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -2, "_M");  /* module._M = module */
-  lua_pushstring(L, modname);
-  lua_setfield(L, -2, "_NAME");
-  dot = strrchr(modname, '.');  /* look for last dot in module name */
-  if (dot == NULL) dot = modname;
-  else dot++;
-  /* set _PACKAGE as package name (full module name minus last part) */
-  lua_pushlstring(L, modname, dot - modname);
-  lua_setfield(L, -2, "_PACKAGE");
-}
-
-
-static int ll_module (lua_State *L) {
-  const char *modname = luaL_checkstring(L, 1);
-  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_isnil(L, -1))  /* is table an initialized module? */
-    lua_pop(L, 1);
-  else {  /* no; initialize it */
-    lua_pop(L, 1);
-    modinit(L, modname);
-  }
-  lua_pushvalue(L, -1);
-  set_env(L);
-  dooptions(L, lastarg);
-  return 1;
-}
-
-
-static int ll_seeall (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  if (!lua_getmetatable(L, 1)) {
-    lua_createtable(L, 0, 1); /* create new metatable */
-    lua_pushvalue(L, -1);
-    lua_setmetatable(L, 1);
-  }
-  lua_pushglobaltable(L);
-  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
-  return 0;
-}
-
-#endif
-/* }====================================================== */
-
-
-
-/* auxiliary mark (for internal use) */
-#define AUXMARK		"\1"
-
-
-/*
-** return registry.LUA_NOENV as a boolean
-*/
-static int noenv (lua_State *L) {
-  int b;
-  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
-  b = lua_toboolean(L, -1);
-  lua_pop(L, 1);  /* remove value */
-  return b;
-}
-
-
-static void setpath (lua_State *L, const char *fieldname, const char *envname1,
-                                   const char *envname2, const char *def) {
-  const char *path = getenv(envname1);
-  if (path == NULL)  /* no environment variable? */
-    path = getenv(envname2);  /* try alternative name */
-  if (path == NULL || noenv(L))  /* no environment variable? */
-    lua_pushstring(L, def);  /* use default */
-  else {
-    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
-    path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
-                              LUA_PATH_SEP AUXMARK LUA_PATH_SEP);
-    luaL_gsub(L, path, AUXMARK, def);
-    lua_remove(L, -2);
-  }
-  setprogdir(L);
-  lua_setfield(L, -2, fieldname);
-}
-
 
 static const luaL_Reg pk_funcs[] = {
   {"loadlib", ll_loadlib},
   {"searchpath", ll_searchpath},
-#if defined(LUA_COMPAT_MODULE)
-  {"seeall", ll_seeall},
-#endif
+  /* placeholders */
+  {"preload", NULL},
+  {"cpath", NULL},
+  {"path", NULL},
+  {"searchers", NULL},
+  {"loaded", NULL},
   {NULL, NULL}
 };
 
 
 static const luaL_Reg ll_funcs[] = {
-#if defined(LUA_COMPAT_MODULE)
-  {"module", ll_module},
-#endif
   {"require", ll_require},
   {NULL, NULL}
 };
 
 
 static void createsearcherstable (lua_State *L) {
-  static const lua_CFunction searchers[] =
-    {searcher_preload, searcher_Lua, searcher_C, searcher_Croot, NULL};
+  static const lua_CFunction searchers[] = {
+    searcher_preload,
+    searcher_Lua,
+    searcher_C,
+    searcher_Croot,
+    NULL
+  };
   int i;
   /* create 'searchers' table */
   lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
-  /* fill it with pre-defined searchers */
+  /* fill it with predefined searchers */
   for (i=0; searchers[i] != NULL; i++) {
     lua_pushvalue(L, -2);  /* set 'package' as upvalue for all searchers */
     lua_pushcclosure(L, searchers[i], 1);
     lua_rawseti(L, -2, i+1);
   }
+  lua_setfield(L, -2, "searchers");  /* put it in field 'searchers' */
+}
+
+
+/*
+** create table CLIBS to keep track of loaded C libraries,
+** setting a finalizer to close all libraries when closing state.
+*/
+static void createclibstable (lua_State *L) {
+  luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS);  /* create CLIBS table */
+  lua_createtable(L, 0, 1);  /* create metatable for CLIBS */
+  lua_pushcfunction(L, gctm);
+  lua_setfield(L, -2, "__gc");  /* set finalizer for CLIBS table */
+  lua_setmetatable(L, -2);
 }
 
 
 LUAMOD_API int luaopen_package (lua_State *L) {
-  /* create table CLIBS to keep track of loaded C libraries */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS);
-  lua_createtable(L, 0, 1);  /* metatable for CLIBS */
-  lua_pushcfunction(L, gctm);
-  lua_setfield(L, -2, "__gc");  /* set finalizer for CLIBS table */
-  lua_setmetatable(L, -2);
-  /* create `package' table */
-  luaL_newlib(L, pk_funcs);
+  createclibstable(L);
+  luaL_newlib(L, pk_funcs);  /* create 'package' table */
   createsearcherstable(L);
-#if defined(LUA_COMPAT_LOADERS)
-  lua_pushvalue(L, -1);  /* make a copy of 'searchers' table */
-  lua_setfield(L, -3, "loaders");  /* put it in field `loaders' */
-#endif
-  lua_setfield(L, -2, "searchers");  /* put it in field 'searchers' */
-  /* set field 'path' */
-  setpath(L, "path", LUA_PATHVERSION, LUA_PATH, LUA_PATH_DEFAULT);
-  /* set field 'cpath' */
-  setpath(L, "cpath", LUA_CPATHVERSION, LUA_CPATH, LUA_CPATH_DEFAULT);
+  /* set paths */
+  setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
+  setpath(L, "cpath", 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");
   lua_setfield(L, -2, "config");
-  /* set field `loaded' */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
+  /* set field 'loaded' */
+  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
   lua_setfield(L, -2, "loaded");
-  /* set field `preload' */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
+  /* set field 'preload' */
+  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
   lua_setfield(L, -2, "preload");
   lua_pushglobaltable(L);
   lua_pushvalue(L, -2);  /* set 'package' as upvalue for next lib */