candle 0.0.1

data/lib/candle/generators/lua/wax/lib/lua/ldo.h

@@ -0,0 +1,57 @@
+/*
+** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $
+** Stack and Call structure of Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ldo_h
+#define ldo_h
+
+
+#include "lobject.h"
+#include "lstate.h"
+#include "lzio.h"
+
+
+#define luaD_checkstack(L,n)    \
+  if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
+    luaD_growstack(L, n); \
+  else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
+
+
+#define incr_top(L) {luaD_checkstack(L,1); L->top++;}
+
+#define savestack(L,p)        ((char *)(p) - (char *)L->stack)
+#define restorestack(L,n)    ((TValue *)((char *)L->stack + (n)))
+
+#define saveci(L,p)        ((char *)(p) - (char *)L->base_ci)
+#define restoreci(L,n)        ((CallInfo *)((char *)L->base_ci + (n)))
+
+
+/* results from luaD_precall */
+#define PCRLUA        0    /* initiated a call to a Lua function */
+#define PCRC        1    /* did a call to a C function */
+#define PCRYIELD    2    /* C funtion yielded */
+
+
+/* type of protected functions, to be ran by `runprotected' */
+typedef void (*Pfunc) (lua_State *L, void *ud);
+
+LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
+LUAI_FUNC void luaD_callhook (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);
+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_reallocCI (lua_State *L, int newsize);
+LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
+LUAI_FUNC void luaD_growstack (lua_State *L, int n);
+
+LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
+LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
+
+LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
+
+#endif
+

data/lib/candle/generators/lua/wax/lib/lua/ldump.c

@@ -0,0 +1,164 @@
+/*
+** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
+** save precompiled Lua chunks
+** See Copyright Notice in lua.h
+*/
+
+#include <stddef.h>
+
+#define ldump_c
+#define LUA_CORE
+
+#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;
+} 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);
+ }
+}
+
+static void DumpChar(int y, DumpState* D)
+{
+ char x=(char)y;
+ DumpVar(x,D);
+}
+
+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 || getstr(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,D);
+ }
+}
+
+#define DumpCode(f,D)     DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
+
+static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
+
+static void DumpConstants(const Proto* f, DumpState* D)
+{
+ int i,n=f->sizek;
+ DumpInt(n,D);
+ for (i=0; i<n; i++)
+ {
+  const TValue* o=&f->k[i];
+  DumpChar(ttype(o),D);
+  switch (ttype(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);            /* cannot happen */
+    break;
+  }
+ }
+ n=f->sizep;
+ DumpInt(n,D);
+ for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
+}
+
+static void DumpDebug(const Proto* f, DumpState* D)
+{
+ int i,n;
+ 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],D);
+}
+
+static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
+{
+ DumpString((f->source==p || D->strip) ? NULL : f->source,D);
+ DumpInt(f->linedefined,D);
+ DumpInt(f->lastlinedefined,D);
+ DumpChar(f->nups,D);
+ DumpChar(f->numparams,D);
+ DumpChar(f->is_vararg,D);
+ DumpChar(f->maxstacksize,D);
+ DumpCode(f,D);
+ DumpConstants(f,D);
+ DumpDebug(f,D);
+}
+
+static void DumpHeader(DumpState* D)
+{
+ char h[LUAC_HEADERSIZE];
+ luaU_header(h);
+ DumpBlock(h,LUAC_HEADERSIZE,D);
+}
+
+/*
+** 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,NULL,&D);
+ return D.status;
+}

data/lib/candle/generators/lua/wax/lib/lua/lfunc.c

@@ -0,0 +1,174 @@
+/*
+** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $
+** Auxiliary functions to manipulate prototypes and closures
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stddef.h>
+
+#define lfunc_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+
+
+
+Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
+  Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
+  c->c.isC = 1;
+  c->c.env = e;
+  c->c.nupvalues = cast_byte(nelems);
+  return c;
+}
+
+
+Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
+  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
+  c->l.isC = 0;
+  c->l.env = e;
+  c->l.nupvalues = cast_byte(nelems);
+  while (nelems--) c->l.upvals[nelems] = NULL;
+  return c;
+}
+
+
+UpVal *luaF_newupval (lua_State *L) {
+  UpVal *uv = luaM_new(L, UpVal);
+  luaC_link(L, obj2gco(uv), LUA_TUPVAL);
+  uv->v = &uv->u.value;
+  setnilvalue(uv->v);
+  return uv;
+}
+
+
+UpVal *luaF_findupval (lua_State *L, StkId level) {
+  global_State *g = G(L);
+  GCObject **pp = &L->openupval;
+  UpVal *p;
+  UpVal *uv;
+  while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
+    lua_assert(p->v != &p->u.value);
+    if (p->v == level) {  /* found a corresponding upvalue? */
+      if (isdead(g, obj2gco(p)))  /* is it dead? */
+        changewhite(obj2gco(p));  /* ressurect it */
+      return p;
+    }
+    pp = &p->next;
+  }
+  uv = luaM_new(L, UpVal);  /* not found: create a new one */
+  uv->tt = LUA_TUPVAL;
+  uv->marked = luaC_white(g);
+  uv->v = level;  /* current value lives in the stack */
+  uv->next = *pp;  /* chain it in the proper position */
+  *pp = obj2gco(uv);
+  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;
+}
+
+
+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;
+}
+
+
+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 */
+}
+
+
+void luaF_close (lua_State *L, StkId level) {
+  UpVal *uv;
+  global_State *g = G(L);
+  while (L->openupval != NULL && (uv = ngcotouv(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);
+      setobj(L, &uv->u.value, uv->v);
+      uv->v = &uv->u.value;  /* now current value lives here */
+      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
+    }
+  }
+}
+
+
+Proto *luaF_newproto (lua_State *L) {
+  Proto *f = luaM_new(L, Proto);
+  luaC_link(L, obj2gco(f), LUA_TPROTO);
+  f->k = NULL;
+  f->sizek = 0;
+  f->p = NULL;
+  f->sizep = 0;
+  f->code = NULL;
+  f->sizecode = 0;
+  f->sizelineinfo = 0;
+  f->sizeupvalues = 0;
+  f->nups = 0;
+  f->upvalues = NULL;
+  f->numparams = 0;
+  f->is_vararg = 0;
+  f->maxstacksize = 0;
+  f->lineinfo = NULL;
+  f->sizelocvars = 0;
+  f->locvars = NULL;
+  f->linedefined = 0;
+  f->lastlinedefined = 0;
+  f->source = NULL;
+  return f;
+}
+
+
+void luaF_freeproto (lua_State *L, Proto *f) {
+  luaM_freearray(L, f->code, f->sizecode, Instruction);
+  luaM_freearray(L, f->p, f->sizep, Proto *);
+  luaM_freearray(L, f->k, f->sizek, TValue);
+  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
+  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
+  luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
+  luaM_free(L, f);
+}
+
+
+void luaF_freeclosure (lua_State *L, Closure *c) {
+  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
+                          sizeLclosure(c->l.nupvalues);
+  luaM_freemem(L, c, size);
+}
+
+
+/*
+** Look for n-th local variable at line `line' in function `func'.
+** Returns NULL if not found.
+*/
+const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
+  int i;
+  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
+    if (pc < f->locvars[i].endpc) {  /* is variable active? */
+      local_number--;
+      if (local_number == 0)
+        return getstr(f->locvars[i].varname);
+    }
+  }
+  return NULL;  /* not found */
+}
+

data/lib/candle/generators/lua/wax/lib/lua/lfunc.h

@@ -0,0 +1,34 @@
+/*
+** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions to manipulate prototypes and closures
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lfunc_h
+#define lfunc_h
+
+
+#include "lobject.h"
+
+
+#define sizeCclosure(n)    (cast(int, sizeof(CClosure)) + \
+                         cast(int, sizeof(TValue)*((n)-1)))
+
+#define sizeLclosure(n)    (cast(int, sizeof(LClosure)) + \
+                         cast(int, sizeof(TValue *)*((n)-1)))
+
+
+LUAI_FUNC Proto *luaF_newproto (lua_State *L);
+LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);
+LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);
+LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
+LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
+LUAI_FUNC void luaF_close (lua_State *L, StkId level);
+LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
+LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);
+LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
+LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
+                                         int pc);
+
+
+#endif

data/lib/candle/generators/lua/wax/lib/lua/lgc.c

@@ -0,0 +1,711 @@
+/*
+ ** $Id: lgc.c,v 2.38.1.1 2007/12/27 13:02:25 roberto Exp $
+ ** Garbage Collector
+ ** See Copyright Notice in lua.h
+ */
+
+#include <string.h>
+
+#define lgc_c
+#define LUA_CORE
+
+#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"
+#include "ltable.h"
+#include "ltm.h"
+
+
+#define GCSTEPSIZE	1024u
+#define GCSWEEPMAX	40
+#define GCSWEEPCOST	10
+#define GCFINALIZECOST	100
+
+
+#define maskmarks	cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
+
+#define makewhite(g,x)	\
+((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
+
+#define white2gray(x)	reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
+#define black2gray(x)	resetbit((x)->gch.marked, BLACKBIT)
+
+#define stringmark(s)	reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
+
+
+#define isfinalized(u)		testbit((u)->marked, FINALIZEDBIT)
+#define markfinalized(u)	l_setbit((u)->marked, FINALIZEDBIT)
+
+
+#define KEYWEAK         bitmask(KEYWEAKBIT)
+#define VALUEWEAK       bitmask(VALUEWEAKBIT)
+
+
+
+#define markvalue(g,o) { checkconsistency(o); \
+if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
+
+#define markobject(g,t) { if (iswhite(obj2gco(t))) \
+reallymarkobject(g, obj2gco(t)); }
+
+
+#define setthreshold(g)  (g->GCthreshold = (g->estimate/100) * g->gcpause)
+
+
+static void removeentry (Node *n) {
+    lua_assert(ttisnil(gval(n)));
+    if (iscollectable(gkey(n)))
+        setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */
+}
+
+
+static void reallymarkobject (global_State *g, GCObject *o) {
+    lua_assert(iswhite(o) && !isdead(g, o));
+    white2gray(o);
+    switch (o->gch.tt) {
+        case LUA_TSTRING: {
+            return;
+        }
+        case LUA_TUSERDATA: {
+            Table *mt = gco2u(o)->metatable;
+            gray2black(o);  /* udata are never gray */
+            if (mt) markobject(g, mt);
+            markobject(g, gco2u(o)->env);
+            return;
+        }
+        case LUA_TUPVAL: {
+            UpVal *uv = gco2uv(o);
+            markvalue(g, uv->v);
+            if (uv->v == &uv->u.value)  /* closed? */
+                gray2black(o);  /* open upvalues are never black */
+            return;
+        }
+        case LUA_TFUNCTION: {
+            gco2cl(o)->c.gclist = g->gray;
+            g->gray = o;
+            break;
+        }
+        case LUA_TTABLE: {
+            gco2h(o)->gclist = g->gray;
+            g->gray = o;
+            break;
+        }
+        case LUA_TTHREAD: {
+            gco2th(o)->gclist = g->gray;
+            g->gray = o;
+            break;
+        }
+        case LUA_TPROTO: {
+            gco2p(o)->gclist = g->gray;
+            g->gray = o;
+            break;
+        }
+        default: lua_assert(0);
+    }
+}
+
+
+static void marktmu (global_State *g) {
+    GCObject *u = g->tmudata;
+    if (u) {
+        do {
+            u = u->gch.next;
+            makewhite(g, u);  /* may be marked, if left from previous GC */
+            reallymarkobject(g, u);
+        } while (u != g->tmudata);
+    }
+}
+
+
+/* move `dead' udata that need finalization to list `tmudata' */
+size_t luaC_separateudata (lua_State *L, int all) {
+    global_State *g = G(L);
+    size_t deadmem = 0;
+    GCObject **p = &g->mainthread->next;
+    GCObject *curr;
+    while ((curr = *p) != NULL) {
+        if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
+            p = &curr->gch.next;  /* don't bother with them */
+        else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
+            markfinalized(gco2u(curr));  /* don't need finalization */
+            p = &curr->gch.next;
+        }
+        else {  /* must call its gc method */
+            deadmem += sizeudata(gco2u(curr));
+            markfinalized(gco2u(curr));
+            *p = curr->gch.next;
+            /* link `curr' at the end of `tmudata' list */
+            if (g->tmudata == NULL)  /* list is empty? */
+                g->tmudata = curr->gch.next = curr;  /* creates a circular list */
+            else {
+                curr->gch.next = g->tmudata->gch.next;
+                g->tmudata->gch.next = curr;
+                g->tmudata = curr;
+            }
+        }
+    }
+    return deadmem;
+}
+
+
+static int traversetable (global_State *g, Table *h) {
+    int i;
+    int weakkey = 0;
+    int weakvalue = 0;
+    const TValue *mode;
+    if (h->metatable)
+        markobject(g, h->metatable);
+    mode = gfasttm(g, h->metatable, TM_MODE);
+    if (mode && ttisstring(mode)) {  /* is there a weak mode? */
+        weakkey = (strchr(svalue(mode), 'k') != NULL);
+        weakvalue = (strchr(svalue(mode), 'v') != NULL);
+        if (weakkey || weakvalue) {  /* is really weak? */
+            h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */
+            h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
+                                   (weakvalue << VALUEWEAKBIT));
+            h->gclist = g->weak;  /* must be cleared after GC, ... */
+            g->weak = obj2gco(h);  /* ... so put in the appropriate list */
+        }
+    }
+    if (weakkey && weakvalue) return 1;
+    if (!weakvalue) {
+        i = h->sizearray;
+        while (i--)
+            markvalue(g, &h->array[i]);
+    }
+    i = sizenode(h);
+    while (i--) {
+        Node *n = gnode(h, i);
+        lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
+        if (ttisnil(gval(n)))
+            removeentry(n);  /* remove empty entries */
+        else {
+            lua_assert(!ttisnil(gkey(n)));
+            if (!weakkey) markvalue(g, gkey(n));
+            if (!weakvalue) markvalue(g, gval(n));
+        }
+    }
+    return weakkey || weakvalue;
+}
+
+
+/*
+ ** All marks are conditional because a GC may happen while the
+ ** prototype is still being created
+ */
+static void traverseproto (global_State *g, Proto *f) {
+    int i;
+    if (f->source) stringmark(f->source);
+    for (i=0; i<f->sizek; i++)  /* mark literals */
+        markvalue(g, &f->k[i]);
+    for (i=0; i<f->sizeupvalues; i++) {  /* mark upvalue names */
+        if (f->upvalues[i])
+            stringmark(f->upvalues[i]);
+    }
+    for (i=0; i<f->sizep; i++) {  /* mark nested protos */
+        if (f->p[i])
+            markobject(g, f->p[i]);
+    }
+    for (i=0; i<f->sizelocvars; i++) {  /* mark local-variable names */
+        if (f->locvars[i].varname)
+            stringmark(f->locvars[i].varname);
+    }
+}
+
+
+
+static void traverseclosure (global_State *g, Closure *cl) {
+    markobject(g, cl->c.env);
+    if (cl->c.isC) {
+        int i;
+        for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */
+            markvalue(g, &cl->c.upvalue[i]);
+    }
+    else {
+        int i;
+        lua_assert(cl->l.nupvalues == cl->l.p->nups);
+        markobject(g, cl->l.p);
+        for (i=0; i<cl->l.nupvalues; i++)  /* mark its upvalues */
+            markobject(g, cl->l.upvals[i]);
+    }
+}
+
+
+static void checkstacksizes (lua_State *L, StkId max) {
+    int ci_used = cast_int(L->ci - L->base_ci);  /* number of `ci' in use */
+    int s_used = cast_int(max - L->stack);  /* part of stack in use */
+    if (L->size_ci > LUAI_MAXCALLS)  /* handling overflow? */
+        return;  /* do not touch the stacks */
+    if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
+        luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */
+    condhardstacktests(luaD_reallocCI(L, ci_used + 1));
+    if (4*s_used < L->stacksize &&
+        2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
+        luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */
+    condhardstacktests(luaD_reallocstack(L, s_used));
+}
+
+
+static void traversestack (global_State *g, lua_State *l) {
+    StkId o, lim;
+    CallInfo *ci;
+    markvalue(g, gt(l));
+    lim = l->top;
+    for (ci = l->base_ci; ci <= l->ci; ci++) {
+        lua_assert(ci->top <= l->stack_last);
+        if (lim < ci->top) lim = ci->top;
+    }
+    for (o = l->stack; o < l->top; o++)
+        markvalue(g, o);
+    for (; o <= lim; o++)
+        setnilvalue(o);
+    checkstacksizes(l, lim);
+}
+
+
+/*
+ ** traverse one gray object, turning it to black.
+ ** Returns `quantity' traversed.
+ */
+static l_mem propagatemark (global_State *g) {
+    GCObject *o = g->gray;
+    lua_assert(isgray(o));
+    gray2black(o);
+    switch (o->gch.tt) {
+        case LUA_TTABLE: {
+            Table *h = gco2h(o);
+            g->gray = h->gclist;
+            if (traversetable(g, h))  /* table is weak? */
+                black2gray(o);  /* keep it gray */
+            return sizeof(Table) + sizeof(TValue) * h->sizearray +
+            sizeof(Node) * sizenode(h);
+        }
+        case LUA_TFUNCTION: {
+            Closure *cl = gco2cl(o);
+            g->gray = cl->c.gclist;
+            traverseclosure(g, cl);
+            return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
+            sizeLclosure(cl->l.nupvalues);
+        }
+        case LUA_TTHREAD: {
+            lua_State *th = gco2th(o);
+            g->gray = th->gclist;
+            th->gclist = g->grayagain;
+            g->grayagain = o;
+            black2gray(o);
+            traversestack(g, th);
+            return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
+            sizeof(CallInfo) * th->size_ci;
+        }
+        case LUA_TPROTO: {
+            Proto *p = gco2p(o);
+            g->gray = p->gclist;
+            traverseproto(g, p);
+            return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
+            sizeof(Proto *) * p->sizep +
+            sizeof(TValue) * p->sizek + 
+            sizeof(int) * p->sizelineinfo +
+            sizeof(LocVar) * p->sizelocvars +
+            sizeof(TString *) * p->sizeupvalues;
+        }
+        default: lua_assert(0); return 0;
+    }
+}
+
+
+static size_t propagateall (global_State *g) {
+    size_t m = 0;
+    while (g->gray) m += propagatemark(g);
+    return m;
+}
+
+
+/*
+ ** The next function tells whether a key or value can be cleared from
+ ** a weak table. Non-collectable objects are never removed from weak
+ ** tables. Strings behave as `values', so are never removed too. for
+ ** other objects: if really collected, cannot keep them; for userdata
+ ** being finalized, keep them in keys, but not in values
+ */
+static int iscleared (const TValue *o, int iskey) {
+    if (!iscollectable(o)) return 0;
+    if (ttisstring(o)) {
+        stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
+        return 0;
+    }
+    return iswhite(gcvalue(o)) ||
+    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
+}
+
+
+/*
+ ** clear collected entries from weaktables
+ */
+static void cleartable (GCObject *l) {
+    while (l) {
+        Table *h = gco2h(l);
+        int i = h->sizearray;
+        lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
+                   testbit(h->marked, KEYWEAKBIT));
+        if (testbit(h->marked, VALUEWEAKBIT)) {
+            while (i--) {
+                TValue *o = &h->array[i];
+                if (iscleared(o, 0))  /* value was collected? */
+                    setnilvalue(o);  /* remove value */
+            }
+        }
+        i = sizenode(h);
+        while (i--) {
+            Node *n = gnode(h, i);
+            if (!ttisnil(gval(n)) &&  /* non-empty entry? */
+                (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
+                setnilvalue(gval(n));  /* remove value ... */
+                removeentry(n);  /* remove entry from table */
+            }
+        }
+        l = h->gclist;
+    }
+}
+
+
+static void freeobj (lua_State *L, GCObject *o) {
+    switch (o->gch.tt) {
+        case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
+        case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
+        case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
+        case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
+        case LUA_TTHREAD: {
+            lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
+            luaE_freethread(L, gco2th(o));
+            break;
+        }
+        case LUA_TSTRING: {
+            G(L)->strt.nuse--;
+            luaM_freemem(L, o, sizestring(gco2ts(o)));
+            break;
+        }
+        case LUA_TUSERDATA: {
+            luaM_freemem(L, o, sizeudata(gco2u(o)));
+            break;
+        }
+        default: lua_assert(0);
+    }
+}
+
+
+
+#define sweepwholelist(L,p)	sweeplist(L,p,MAX_LUMEM)
+
+
+static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
+    GCObject *curr;
+    global_State *g = G(L);
+    int deadmask = otherwhite(g);
+    while ((curr = *p) != NULL && count-- > 0) {
+        if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
+            sweepwholelist(L, &gco2th(curr)->openupval);
+        if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
+            lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
+            makewhite(g, curr);  /* make it white (for next cycle) */
+            p = &curr->gch.next;
+        }
+        else {  /* must erase `curr' */
+            lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
+            *p = curr->gch.next;
+            if (curr == g->rootgc)  /* is the first element of the list? */
+                g->rootgc = curr->gch.next;  /* adjust first */
+            freeobj(L, curr);
+        }
+    }
+    return p;
+}
+
+
+static void checkSizes (lua_State *L) {
+    global_State *g = G(L);
+    /* check size of string hash */
+    if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
+        g->strt.size > MINSTRTABSIZE*2)
+        luaS_resize(L, g->strt.size/2);  /* table is too big */
+    /* check size of buffer */
+    if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */
+        size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
+        luaZ_resizebuffer(L, &g->buff, newsize);
+    }
+}
+
+
+static void GCTM (lua_State *L) {
+    global_State *g = G(L);
+    GCObject *o = g->tmudata->gch.next;  /* get first element */
+    Udata *udata = rawgco2u(o);
+    const TValue *tm;
+    /* remove udata from `tmudata' */
+    if (o == g->tmudata)  /* last element? */
+        g->tmudata = NULL;
+    else
+        g->tmudata->gch.next = udata->uv.next;
+    udata->uv.next = g->mainthread->next;  /* return it to `root' list */
+    g->mainthread->next = o;
+    makewhite(g, o);
+    tm = fasttm(L, udata->uv.metatable, TM_GC);
+    if (tm != NULL) {
+        lu_byte oldah = L->allowhook;
+        lu_mem oldt = g->GCthreshold;
+        L->allowhook = 0;  /* stop debug hooks during GC tag method */
+        g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
+        setobj2s(L, L->top, tm);
+        setuvalue(L, L->top+1, udata);
+        L->top += 2;
+        luaD_call(L, L->top - 2, 0);
+        L->allowhook = oldah;  /* restore hooks */
+        g->GCthreshold = oldt;  /* restore threshold */
+    }
+}
+
+
+/*
+ ** Call all GC tag methods
+ */
+void luaC_callGCTM (lua_State *L) {
+    while (G(L)->tmudata)
+        GCTM(L);
+}
+
+
+void luaC_freeall (lua_State *L) {
+    global_State *g = G(L);
+    int i;
+    g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
+    sweepwholelist(L, &g->rootgc);
+    for (i = 0; i < g->strt.size; i++)  /* free all string lists */
+        sweepwholelist(L, &g->strt.hash[i]);
+}
+
+
+static void markmt (global_State *g) {
+    int i;
+    for (i=0; i<NUM_TAGS; i++)
+        if (g->mt[i]) markobject(g, g->mt[i]);
+}
+
+
+/* mark root set */
+static void markroot (lua_State *L) {
+    global_State *g = G(L);
+    g->gray = NULL;
+    g->grayagain = NULL;
+    g->weak = NULL;
+    markobject(g, g->mainthread);
+    /* make global table be traversed before main stack */
+    markvalue(g, gt(g->mainthread));
+    markvalue(g, registry(L));
+    markmt(g);
+    g->gcstate = GCSpropagate;
+}
+
+
+static void remarkupvals (global_State *g) {
+    UpVal *uv;
+    for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
+        lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
+        if (isgray(obj2gco(uv)))
+            markvalue(g, uv->v);
+    }
+}
+
+
+static void atomic (lua_State *L) {
+    global_State *g = G(L);
+    size_t udsize;  /* total size of userdata to be finalized */
+    /* remark occasional upvalues of (maybe) dead threads */
+    remarkupvals(g);
+    /* traverse objects cautch by write barrier and by 'remarkupvals' */
+    propagateall(g);
+    /* remark weak tables */
+    g->gray = g->weak;
+    g->weak = NULL;
+    lua_assert(!iswhite(obj2gco(g->mainthread)));
+    markobject(g, L);  /* mark running thread */
+    markmt(g);  /* mark basic metatables (again) */
+    propagateall(g);
+    /* remark gray again */
+    g->gray = g->grayagain;
+    g->grayagain = NULL;
+    propagateall(g);
+    udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */
+    marktmu(g);  /* mark `preserved' userdata */
+    udsize += propagateall(g);  /* remark, to propagate `preserveness' */
+    cleartable(g->weak);  /* remove collected objects from weak tables */
+    /* flip current white */
+    g->currentwhite = cast_byte(otherwhite(g));
+    g->sweepstrgc = 0;
+    g->sweepgc = &g->rootgc;
+    g->gcstate = GCSsweepstring;
+    g->estimate = g->totalbytes - udsize;  /* first estimate */
+}
+
+
+static l_mem singlestep (lua_State *L) {
+    global_State *g = G(L);
+    /*lua_checkmemory(L);*/
+    switch (g->gcstate) {
+        case GCSpause: {
+            markroot(L);  /* start a new collection */
+            return 0;
+        }
+        case GCSpropagate: {
+            if (g->gray)
+                return propagatemark(g);
+            else {  /* no more `gray' objects */
+                atomic(L);  /* finish mark phase */
+                return 0;
+            }
+        }
+        case GCSsweepstring: {
+            lu_mem old = g->totalbytes;
+            sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
+            if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */
+                g->gcstate = GCSsweep;  /* end sweep-string phase */
+            lua_assert(old >= g->totalbytes);
+            g->estimate -= old - g->totalbytes;
+            return GCSWEEPCOST;
+        }
+        case GCSsweep: {
+            lu_mem old = g->totalbytes;
+            g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+            if (*g->sweepgc == NULL) {  /* nothing more to sweep? */
+                checkSizes(L);
+                g->gcstate = GCSfinalize;  /* end sweep phase */
+            }
+            lua_assert(old >= g->totalbytes);
+            g->estimate -= old - g->totalbytes;
+            return GCSWEEPMAX*GCSWEEPCOST;
+        }
+        case GCSfinalize: {
+            if (g->tmudata) {
+                GCTM(L);
+                if (g->estimate > GCFINALIZECOST)
+                    g->estimate -= GCFINALIZECOST;
+                return GCFINALIZECOST;
+            }
+            else {
+                g->gcstate = GCSpause;  /* end collection */
+                g->gcdept = 0;
+                return 0;
+            }
+        }
+        default: lua_assert(0); return 0;
+    }
+}
+
+
+void luaC_step (lua_State *L) {
+    global_State *g = G(L);
+    l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
+    if (lim == 0)
+        lim = (MAX_LUMEM-1)/2;  /* no limit */
+    g->gcdept += g->totalbytes - g->GCthreshold;
+    do {
+        lim -= singlestep(L);
+        if (g->gcstate == GCSpause)
+            break;
+    } while (lim > 0);
+    if (g->gcstate != GCSpause) {
+        if (g->gcdept < GCSTEPSIZE)
+            g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
+        else {
+            g->gcdept -= GCSTEPSIZE;
+            g->GCthreshold = g->totalbytes;
+        }
+    }
+    else {
+        lua_assert(g->totalbytes >= g->estimate);
+        setthreshold(g);
+    }
+}
+
+
+void luaC_fullgc (lua_State *L) {
+    global_State *g = G(L);
+    if (g->gcstate <= GCSpropagate) {
+        /* reset sweep marks to sweep all elements (returning them to white) */
+        g->sweepstrgc = 0;
+        g->sweepgc = &g->rootgc;
+        /* reset other collector lists */
+        g->gray = NULL;
+        g->grayagain = NULL;
+        g->weak = NULL;
+        g->gcstate = GCSsweepstring;
+    }
+    lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
+    /* finish any pending sweep phase */
+    while (g->gcstate != GCSfinalize) {
+        lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
+        singlestep(L);
+    }
+    markroot(L);
+    while (g->gcstate != GCSpause) {
+        singlestep(L);
+    }
+    setthreshold(g);
+}
+
+
+void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
+    global_State *g = G(L);
+    lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
+    lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+    lua_assert(ttype(&o->gch) != LUA_TTABLE);
+    /* must keep invariant? */
+    if (g->gcstate == GCSpropagate)
+        reallymarkobject(g, v);  /* restore invariant */
+    else  /* don't mind */
+        makewhite(g, o);  /* mark as white just to avoid other barriers */
+}
+
+
+void luaC_barrierback (lua_State *L, Table *t) {
+    global_State *g = G(L);
+    GCObject *o = obj2gco(t);
+    lua_assert(isblack(o) && !isdead(g, o));
+    lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+    black2gray(o);  /* make table gray (again) */
+    t->gclist = g->grayagain;
+    g->grayagain = o;
+}
+
+
+void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
+    global_State *g = G(L);
+    o->gch.next = g->rootgc;
+    g->rootgc = o;
+    o->gch.marked = luaC_white(g);
+    o->gch.tt = tt;
+}
+
+
+void luaC_linkupval (lua_State *L, UpVal *uv) {
+    global_State *g = G(L);
+    GCObject *o = obj2gco(uv);
+    o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
+    g->rootgc = o;
+    if (isgray(o)) { 
+        if (g->gcstate == GCSpropagate) {
+            gray2black(o);  /* closed upvalues need barrier */
+            luaC_barrier(L, uv, uv->v);
+        }
+        else {  /* sweep phase: sweep it (turning it into white) */
+            makewhite(g, o);
+            lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+        }
+    }
+}
+