89 ** Protected access to objects in values
180 ** table. Non-collectable objects are never removed from weak
182 ** other objects: if really collected, cannot keep them; for objects
200 ** objects. So, it is marked as OLD0. In the next cycle it will become
291 ** by the thread or by 'remarkupvals'.  Other objects are added to the
343 ** mark all objects in list of being-finalized
423 ** post-processing by 'correctgraylist'. (It could put all old objects
426 ** TOUCHED1 objects need to be in the list. TOUCHED2 doesn't need to go
620 ** ensures that the entire stack have valid (non-dead) objects.
622 ** at every cycle, because they might point to young objects.  In inc.
819 ** objects, where a dead object is one marked with the old (non current)
820 ** white; change all non-dead objects back to white, preparing for next
968 ** Move all unreachable objects (or 'all' objects) that need
970 ** (Note that objects after 'finobjold1' cannot be white, so they
978   while ((curr = *p) != g->finobjold1) {  /* traverse all finalizable objects */  in separatetobefnz()
1004 ** Correct pointers to objects inside 'allgc' list when
1074 ** Sweep a list of objects to enter generational mode.  Deletes dead
1075 ** objects and turns the non dead to old. All non-dead threads---which
1088     else {  /* all surviving objects become old */  in sweep2old()
1105 ** Sweep for generational mode. Delete dead objects. (Because the
1106 ** collection is not incremental, there are no "new white" objects
1108 ** non-dead objects, advance their ages and clear the color of
1109 ** new objects. (Old objects keep their colors.)
1110 ** The ages of G_TOUCHED1 and G_TOUCHED2 objects cannot be advanced
1111 ** here, because these old-generation objects are usually not swept
1113 ** will also remove objects turned white here from any gray list.
1135       if (getage(curr) == G_NEW) {  /* new objects go back to white */  in sweepgen()
1139       else {  /* all other objects will be old, and so keep their color */  in sweepgen()
1153 ** age. In incremental mode, all objects are 'new' all the time,
1164 ** Correct a list of gray objects. Return pointer to where rest of the
1166 ** Because this correction is done after sweeping, young objects might
1168 ** 'TOUCHED1' objects are advanced to 'TOUCHED2' and remain on the list;
1169 ** Non-white threads also remain on the list; 'TOUCHED2' objects become
1177       goto remove;  /* remove all white objects */  in correctgraylist()
1189       lua_assert(isold(curr));  /* young objects should be white here */  in correctgraylist()
1217 ** Mark black 'OLD1' objects when starting a new young collection.
1218 ** Gray objects are already in some gray list, and so will be visited
1247 ** Does a young collection. First, mark 'OLD1' objects. Then does the
1255   if (g->firstold1) {  /* are there regular OLD1 objects? */  in youngcollection()
1257     g->firstold1 = NULL;  /* no more OLD1 objects (for now) */  in youngcollection()
1287 ** Clears all gray lists, sweeps objects, and prepare sublists to enter
1288 ** generational mode. The sweeps remove dead objects and turn all
1289 ** surviving objects to old. Threads go back to 'grayagain'; everything
1299   g->firstold1 = NULL;  /* there are no OLD1 objects anywhere */  in atomic2gen()
1325 ** to ensure that all objects are correctly marked and weak tables
1326 ** are cleared. Then, turn all objects into old and finishes the
1341 ** Enter incremental mode. Turn all objects white, make all
1388 ** collection that frees too few objects. To avoid the cost of switching
1392 ** after a "good" collection (one that traverses less than 9/8 objects
1398 ** number of objects traversed (returned by 'atomic') as a proxy. The
1403   lu_mem newatomic;  /* count of traversed objects */  in stepgenfull()
1483 ** not need to skip objects created between "now" and the start of the
1495 ** Delete all objects in list 'p' until (but not including) object
1508 ** Call all finalizers of the objects in the given Lua state, and
1509 ** then free all objects, except for the main thread.
1515   separatetobefnz(g, 1);  /* separate all objects with finalizers */  in luaC_freeallobjects()
1520   deletelist(L, g->fixedgc, NULL);  /* collect fixed objects */  in luaC_freeallobjects()
1545   /* at this point, all strongly accessible objects are marked. */  in atomic()
1550   separatetobefnz(g, 0);  /* separate objects to be finalized */  in atomic()
1551   work += markbeingfnz(g);  /* mark objects that will be finalized */  in atomic()
1554   /* at this point, all resurrected objects are marked. */  in atomic()
1555   /* remove dead objects from weak tables */  in atomic()
1598       if (g->gray == NULL) {  /* no more gray objects? */  in singlestep()
1612     case GCSswpallgc: {  /* sweep "regular" objects */  in singlestep()
1616     case GCSswpfinobj: {  /* sweep objects with finalizers */  in singlestep()
1620     case GCSswptobefnz: {  /* sweep objects to be finalized */  in singlestep()
1706 ** there may be some objects marked as black, so the collector has
1707 ** to sweep all objects to turn them back to white (as white has not
1711   if (keepinvariant(g))  /* black objects? */  in fullinc()