/*

 ** $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);

     }

   }

 }