text:
#define lgc_c
#define LUA_CORE

#include "lprefix.h"

#include <string.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"
#include "ltable.h"
#include "ltm.h"

/*
** internal state for collector while inside the atomic phase. The
** collector should never be in this state while running regular code.
*/
#define GCSinsideatomic		(GCSpause + 1)

/*
** cost of sweeping one element (the size of a small object divided
** by some adjust for the sweep speed)
*/
#define GCSWEEPCOST	((sizeof(TString) + 4) / 4)

/* maximum number of elements to sweep in each single step */
#define GCSWEEPMAX	(cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))

/* cost of calling one finalizer */
#define GCFINALIZECOST	GCSWEEPCOST

/*
** macro to adjust 'stepmul': 'stepmul' is actually used like
** 'stepmul / STEPMULADJ' (value chosen by tests)
*/
#define STEPMULADJ		200

/*
** macro to adjust 'pause': 'pause' is actually used like
** 'pause / PAUSEADJ' (value chosen by tests)
*/
#define PAUSEADJ		100

/*
** 'makewhite' erases all color bits then sets only the current white
** bit
*/
#define maskcolors	(~(bitmask(BLACKBIT) | WHITEBITS))
#define makewhite(g,x)	\
 (x->marked = cast_byte((x->marked & maskcolors) | luaC_white(g)))

#define white2gray(x)	resetbits(x->marked, WHITEBITS)
#define black2gray(x)	resetbit(x->marked, BLACKBIT)

#define valiswhite(x)   (iscollectable(x) && iswhite(gcvalue(x)))

#define checkdeadkey(n)	lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n)))

#define checkconsistency(obj)  \
  lua_longassert(!iscollectable(obj) || righttt(obj))

#define markvalue(g,o) { checkconsistency(o); \
  if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }

#define markobject(g,t)	{ if (iswhite(t)) reallymarkobject(g, obj2gco(t)); }

/*
** mark an object that can be NULL (either because it is really optional,
** or it was stripped as debug info, or inside an uncompleted structure)
*/
#define markobjectN(g,t)	{ if (t) markobject(g,t); }

static void reallymarkobject (global_State *g, GCObject *o);

/*
** {======================================================
** Generic functions
** =======================================================
*/

/*
** one after last element in a hash array
*/
#define gnodelast(h)	gnode(h, cast(size_t, sizenode(h)))

/*
** link collectable object 'o' into list pointed by 'p'
*/
#define linkgclist(o,p)	((o)->gclist = (p), (p) = obj2gco(o))

/*
** If key is not marked, mark its entry as dead. This allows key to be
** collected, but keeps its entry in the table.  A dead node is needed
** when Lua looks up for a key (it may be part of a chain) and when
** traversing a weak table (key might be removed from the table during
** traversal). Other places never manipulate dead keys, because its
** associated nil value is enough to signal that the entry is logically
** empty.
*/
static void removeentry (Node *n) {
  lua_assert(ttisnil(gval(n)));
  if (valiswhite(gkey(n)))
    setdeadvalue(wgkey(n));  /* unused and unmarked key; remove it */
}

/*
** 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 objects
** being finalized, keep them in keys, but not in values
*/
static int iscleared (global_State *g, const TValue *o) {
  if (!iscollectable(o)) return 0;
  else if (ttisstring(o)) {
    markobject(g, tsvalue(o));  /* strings are 'values', so are never weak */
    return 0;
  }
  else return iswhite(gcvalue(o));
}

/*
** barrier that moves collector forward, that is, mark the white object
** being pointed by a black object. (If in sweep phase, clear the black
** object to white [sweep it] to avoid other barrier calls for this
** same object.)
*/
void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) {
  global_State *g = G(L);
  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  if (keepinvariant(g))  /* must keep invariant? */
    reallymarkobject(g, v);  /* restore invariant */
  else {  /* sweep phase */
    lua_assert(issweepphase(g));
    makewhite(g, o);  /* mark main obj. as white to avoid other barriers */
  }
}

/*
** barrier that moves collector backward, that is, mark the black object
** pointing to a white object as gray again.
*/
void luaC_barrierback_ (lua_State *L, Table *t) {
  global_State *g = G(L);
  lua_assert(isblack(t) && !isdead(g, t));
  black2gray(t);  /* make table gray (again) */
  linkgclist(t, g->grayagain);
}

/*
** barrier for assignments to closed upvalues. Because upvalues are
** shared among closures, it is impossible to know the color of all
** closures pointing to it. So, we assume that the object being assigned
** must be marked.
*/
void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
  global_State *g = G(L);
  GCObject *o = gcvalue(uv->v);
  lua_assert(!upisopen(uv));  /* ensured by macro luaC_upvalbarrier */
  if (keepinvariant(g))
    markobject(g, o);
}

void luaC_fix (lua_State *L, GCObject *o) {
  global_State *g = G(L);
  lua_assert(g->allgc == o);  /* object must be 1st in 'allgc' list! */
  white2gray(o);  /* they will be gray forever */
  g->allgc = o->next;  /* remove object from 'allgc' list */
  o->next = g->fixedgc;  /* link it to 'fixedgc' list */
  g->fixedgc = o;
}

/*
** create a new collectable object (with given type and size) and link
** it to 'allgc' list.
*/
GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
  global_State *g = G(L);
  GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
  o->marked = luaC_white(g);
  o->tt = tt;
  o->next = g->allgc;
  g->allgc = o;
  return o;
}

/* }====================================================== */

/*
** {======================================================
** Mark functions
** =======================================================
*/

/*
** mark an object. Userdata, strings, and closed upvalues are visited
** and turned black here. Other objects are marked gray and added
** to appropriate list to be visited (and turned black) later. (Open
** upvalues are already linked in 'headuv' list.)
*/
static void reallymarkobject (global_State *g, GCObject *o) {
 reentry:
  white2gray(o);
  switch (o->tt) {
    case LUA_TSHRSTR: {
      gray2black(o);
      g->GCmemtrav += sizelstring(gco2ts(o)->shrlen);
      break;
    }
    case LUA_TLNGSTR: {
      gray2black(o);
      g->GCmemtrav += sizelstring(gco2ts(o)->u.lnglen);
      break;
    }
    case LUA_TUSERDATA: {
      TValue uvalue;
      markobjectN(g, gco2u(o)->metatable);  /* mark its metatable */
      gray2black(o);
      g->GCmemtrav += sizeudata(gco2u(o));
      getuservalue(g->mainthread, gco2u(o), &uvalue);
      if (valiswhite(&uvalue)) {  /* markvalue(g, &uvalue); */
        o = gcvalue(&uvalue);
        goto reentry;
      }
      break;
    }
    case LUA_TLCL: {
      linkgclist(gco2lcl(o), g->gray);
      break;
    }
    case LUA_TCCL: {
      linkgclist(gco2ccl(o), g->gray);
      break;
    }
    case LUA_TTABLE: {
      linkgclist(gco2t(o), g->gray);
      break;
    }
    case LUA_TTHREAD: {
      linkgclist(gco2th(o), g->gray);
      break;
    }
    case LUA_TPROTO: {
      linkgclist(gco2p(o), g->gray);
      break;
    }
    default: lua_assert(0); break;
  }
}

/*
** mark metamethods for basic types
*/
static void markmt (global_State *g) {
  int i;
  for (i=0; i < LUA_NUMTAGS; i++)
    markobjectN(g, g->mt[i]);
}

/*
** mark all objects in list of being-finalized
*/
static void markbeingfnz (global_State *g) {
  GCObject *o;
  for (o = g->tobefnz; o != NULL; o = o->next)
    markobject(g, o);
}

/*
** Mark all values stored in marked open upvalues from non-marked threads.
** (Values from marked threads were already marked when traversing the
** thread.) Remove from the list threads that no longer have upvalues and
** not-marked threads.
*/
static void remarkupvals (global_State *g) {
  lua_State *thread;
  lua_State **p = &g->twups;
  while ((thread = *p) != NULL) {
    lua_assert(!isblack(thread));  /* threads are never black */
    if (isgray(thread) && thread->openupval != NULL)
      p = &thread->twups;  /* keep marked thread with upvalues in the list */
    else {  /* thread is not marked or without upvalues */
      UpVal *uv;
      *p = thread->twups;  /* remove thread from the list */
      thread->twups = thread;  /* mark that it is out of list */
      for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) {
        if (uv->u.open.touched) {
          markvalue(g, uv->v);  /* remark upvalue's value */
          uv->u.open.touched = 0;
        }
      }
    }
  }
}

/*
** mark root set and reset all gray lists, to start a new collection
*/
static void restartcollection (global_State *g) {
  g->gray = g->grayagain = NULL;
  g->weak = g->allweak = g->ephemeron = NULL;
  markobject(g, g->mainthread);
  markvalue(g, &g->l_registry);
  markmt(g);
  markbeingfnz(g);  /* mark any finalizing object left from previous cycle */
}

/* }====================================================== */

/*
** {======================================================
** Traverse functions
** =======================================================
*/

/*
** Traverse a table with weak values and link it to proper list. During
** propagate phase, keep it in 'grayagain' list, to be revisited in the
** atomic phase. In the atomic phase, if table has any white value,
** put it in 'weak' list, to be cleared.
*/
static void traverseweakvalue (global_State *g, Table *h) {
  Node *n, *limit = gnodelast(h);
  /* if there is array part, assume it may have white values (it is not
     worth traversing it now just to check) */
  int hasclears = (h->sizearray > 0);
  for (n = gnode(h, 0); n < limit; n++) {  /* traverse hash part */
    checkdeadkey(n);
    if (ttisnil(gval(n)))  /* entry is empty? */
      removeentry(n);  /* remove it */
    else {
      lua_assert(!ttisnil(gkey(n)));
      markvalue(g, gkey(n));  /* mark key */
      if (!hasclears && iscleared(g, gval(n)))  /* is there a white value? */
        hasclears = 1;  /* table will have to be cleared */
    }
  }
  if (g->gcstate == GCSpropagate)
    linkgclist(h, g->grayagain);  /* must retraverse it in atomic phase */
  else if (hasclears)
    linkgclist(h, g->weak);  /* has to be cleared later */
}

/*
** Traverse an ephemeron table and link it to proper list. Returns true
** iff any object was marked during this traversal (which implies that
** convergence has to continue). During propagation phase, keep table
** in 'grayagain' list, to be visited again in the atomic phase. In
** the atomic phase, if table has any white->white entry, it has to
** be revisited during ephemeron convergence (as that key may turn
** black). Otherwise, if it has any white key, table has to be cleared
** (in the atomic phase).
*/
static int traverseephemeron (global_State *g, Table *h) {
  int marked = 0;  /* true if an object is marked in this traversal */
  int hasclears = 0;  /* true if table has white keys */
  int hasww = 0;  /* true if table has entry "white-key -> white-value" */
  Node *n, *limit = gnodelast(h);
  unsigned int i;
  /* traverse array part */
  for (i = 0; i < h->sizearray; i++) {
    if (valiswhite(&h->array[i])) {
      marked = 1;
      reallymarkobject(g, gcvalue(&h->array[i]));
    }
  }
  /* traverse hash part */
  for (n = gnode(h, 0); n < limit; n++) {
    checkdeadkey(n);
    if (ttisnil(gval(n)))  /* entry is empty? */
      removeentry(n);  /* remove it */
    else if (iscleared(g, gkey(n))) {  /* key is not marked (yet)? */
      hasclears = 1;  /* table must be cleared */
      if (valiswhite(gval(n)))  /* value not marked yet? */
        hasww = 1;  /* white-white entry */
    }
    else if (valiswhite(gval(n))) {  /* value not marked yet? */
      marked = 1;
      reallymarkobject(g, gcvalue(gval(n)));  /* mark it now */
    }
  }
  /* link table into proper list */
  if (g->gcstate == GCSpropagate)
    linkgclist(h, g->grayagain);  /* must retraverse it in atomic phase */
  else if (hasww)  /* table has white->white entries? */
    linkgclist(h, g->ephemeron);  /* have to propagate again */
  else if (hasclears)  /* table has white keys? */
    linkgclist(h, g->allweak);  /* may have to clean white keys */
  return marked;
}

static void traversestrongtable (global_State *g, Table *h) {
  Node *n, *limit = gnodelast(h);
  unsigned int i;
  for (i = 0; i < h->sizearray; i++)  /* traverse array part */
    markvalue(g, &h->array[i]);
  for (n = gnode(h, 0); n < limit; n++) {  /* traverse hash part */
    checkdeadkey(n);
    if (ttisnil(gval(n)))  /* entry is empty? */
      removeentry(n);  /* remove it */
    else {
      lua_assert(!ttisnil(gkey(n)));
      markvalue(g, gkey(n));  /* mark key */
      markvalue(g, gval(n));  /* mark value */
    }
  }
}

static lu_mem traversetable (global_State *g, Table *h) {
  const char *weakkey, *weakvalue;
  const TValue *mode = gfasttm(g, h->metatable, TM_MODE);
  markobjectN(g, h->metatable);
  if (mode && ttisstring(mode) &&  /* is there a weak mode? */
      ((weakkey = strchr(svalue(mode), 'k')),
       (weakvalue = strchr(svalue(mode), 'v')),
       (weakkey || weakvalue))) {  /* is really weak? */
    black2gray(h);  /* keep table gray */
    if (!weakkey)  /* strong keys? */
      traverseweakvalue(g, h);
    else if (!weakvalue)  /* strong values? */
      traverseephemeron(g, h);
    else  /* all weak */
      linkgclist(h, g->allweak);  /* nothing to traverse now */
  }
  else  /* not weak */
    traversestrongtable(g, h);
  return sizeof(Table) + sizeof(TValue) * h->sizearray +
                         sizeof(Node) * cast(size_t, allocsizenode(h));
}

/*
** Traverse a prototype. (While a prototype is being build, its
** arrays can be larger than needed; the extra slots are filled with
** NULL, so the use of 'markobjectN')
*/
static int traverseproto (global_State *g, Proto *f) {
  int i;
  if (f->cache && iswhite(f->cache))
    f->cache = NULL;  /* allow cache to be collected */
  markobjectN(g, 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 */
    markobjectN(g, f->upvalues[i].name);
  for (i = 0; i < f->sizep; i++)  /* mark nested protos */
    markobjectN(g, f->p[i]);
  for (i = 0; i < f->sizelocvars; i++)  /* mark local-variable names */
    markobjectN(g, f->locvars[i].varname);
  return sizeof(Proto) + sizeof(Instruction) * f->sizecode +
                         sizeof(Proto *) * f->sizep +
                         sizeof(TValue) * f->sizek +
                         sizeof(int) * f->sizelineinfo +
                         sizeof(LocVar) * f->sizelocvars +
                         sizeof(Upvaldesc) * f->sizeupvalues;
}

static lu_mem traverseCclosure (global_State *g, CClosure *cl) {
  int i;
  for (i = 0; i < cl->nupvalues; i++)  /* mark its upvalues */
    markvalue(g, &cl->upvalue[i]);
  return sizeCclosure(cl->nupvalues);
}

/*
** open upvalues point to values in a thread, so those values should
** be marked when the thread is traversed except in the atomic phase
** (because then the value cannot be changed by the thread and the
** thread may not be traversed again)
*/
static lu_mem traverseLclosure (global_State *g, LClosure *cl) {
  int i;
  markobjectN(g, cl->p);  /* mark its prototype */
  for (i = 0; i < cl->nupvalues; i++) {  /* mark its upvalues */
    UpVal *uv = cl->upvals[i];
    if (uv != NULL) {
      if (upisopen(uv) && g->gcstate != GCSinsideatomic)
        uv->u.open.touched = 1;  /* can be marked in 'remarkupvals' */
      else
        markvalue(g, uv->v);
    }
  }
  return sizeLclosure(cl->nupvalues);
}

static lu_mem traversethread (global_State *g, lua_State *th) {
  StkId o = th->stack;
  if (o == NULL)
    return 1;  /* stack not completely built yet */
  lua_assert(g->gcstate == GCSinsideatomic ||
             th->openupval == NULL || isintwups(th));
  for (; o < th->top; o++)  /* mark live elements in the stack */
    markvalue(g, o);
  if (g->gcstate == GCSinsideatomic) {  /* final traversal? */
    StkId lim = th->stack + th->stacksize;  /* real end of stack */
    for (; o < lim; o++)  /* clear not-marked stack slice */
      setnilvalue(o);
    /* 'remarkupvals' may have removed thread from 'twups' list */
    if (!isintwups(th) && th->openupval != NULL) {
      th->twups = g->twups;  /* link it back to the list */
      g->twups = th;
    }
  }
  else if (g->gckind != KGC_EMERGENCY)
    luaD_shrinkstack(th); /* do not change stack in emergency cycle */
  return (sizeof(lua_State) + sizeof(TValue) * th->stacksize +
          sizeof(CallInfo) * th->nci);
}

/*
** traverse one gray object, turning it to black (except for threads,
** which are always gray).
*/
static void propagatemark (global_State *g) {
  lu_mem size;
  GCObject *o = g->gray;
  lua_assert(isgray(o));
  gray2black(o);
  switch (o->tt) {
    case LUA_TTABLE: {
      Table *h = gco2t(o);
      g->gray = h->gclist;  /* remove from 'gray' list */
      size = traversetable(g, h);
      break;
    }
    case LUA_TLCL: {
      LClosure *cl = gco2lcl(o);
      g->gray = cl->gclist;  /* remove from 'gray' list */
      size = traverseLclosure(g, cl);
      break;
    }
    case LUA_TCCL: {
      CClosure *cl = gco2ccl(o);
      g->gray = cl->gclist;  /* remove from 'gray' list */
      size = traverseCclosure(g, cl);
      break;
    }
    case LUA_TTHREAD: {
      lua_State *th = gco2th(o);
      g->gray = th->gclist;  /* remove from 'gray' list */
      linkgclist(th, g->grayagain);  /* insert into 'grayagain' list */
      black2gray(o);
      size = traversethread(g, th);
      break;
    }
    case LUA_TPROTO: {
      Proto *p = gco2p(o);
      g->gray = p->gclist;  /* remove from 'gray' list */
      size = traverseproto(g, p);
      break;
    }
    default: lua_assert(0); return;
  }
  g->GCmemtrav += size;
}

static void propagateall (global_State *g) {
  while (g->gray) propagatemark(g);
}

static void convergeephemerons (global_State *g) {
  int changed;
  do {
    GCObject *w;
    GCObject *next = g->ephemeron;  /* get ephemeron list */
    g->ephemeron = NULL;  /* tables may return to this list when traversed */
    changed = 0;
    while ((w = next) != NULL) {
      next = gco2t(w)->gclist;
      if (traverseephemeron(g, gco2t(w))) {  /* traverse marked some value? */
        propagateall(g);  /* propagate changes */
        changed = 1;  /* will have to revisit all ephemeron tables */
      }
    }
  } while (changed);
}

/* }====================================================== */

/*
** {======================================================
** Sweep Functions
** =======================================================
*/

/*
** clear entries with unmarked keys from all weaktables in list 'l' up
** to element 'f'
*/
static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
  for (; l != f; l = gco2t(l)->gclist) {
    Table *h = gco2t(l);
    Node *n, *limit = gnodelast(h);
    for (n = gnode(h, 0); n < limit; n++) {
      if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
        setnilvalue(gval(n));  /* remove value ... */
      }
      if (ttisnil(gval(n)))  /* is entry empty? */
        removeentry(n);  /* remove entry from table */
    }
  }
}

/*
** clear entries with unmarked values from all weaktables in list 'l' up
** to element 'f'
*/
static void clearvalues (global_State *g, GCObject *l, GCObject *f) {
  for (; l != f; l = gco2t(l)->gclist) {
    Table *h = gco2t(l);
    Node *n, *limit = gnodelast(h);
    unsigned int i;
    for (i = 0; i < h->sizearray; i++) {
      TValue *o = &h->array[i];
      if (iscleared(g, o))  /* value was collected? */
        setnilvalue(o);  /* remove value */
    }
    for (n = gnode(h, 0); n < limit; n++) {
      if (!ttisnil(gval(n)) && iscleared(g, gval(n))) {
        setnilvalue(gval(n));  /* remove value ... */
        removeentry(n);  /* and remove entry from table */
      }
    }
  }
}

void luaC_upvdeccount (lua_State *L, UpVal *uv) {
  lua_assert(uv->refcount > 0);
  uv->refcount--;
  if (uv->refcount == 0 && !upisopen(uv))
    luaM_free(L, uv);
}

static void freeLclosure (lua_State *L, LClosure *cl) {
  int i;
  for (i = 0; i < cl->nupvalues; i++) {
    UpVal *uv = cl->upvals[i];
    if (uv)
      luaC_upvdeccount(L, uv);
  }
  luaM_freemem(L, cl, sizeLclosure(cl->nupvalues));
}

static void freeobj (lua_State *L, GCObject *o) {
  switch (o->tt) {
    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
    case LUA_TLCL: {
      freeLclosure(L, gco2lcl(o));
      break;
    }
    case LUA_TCCL: {
      luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues));
      break;
    }
    case LUA_TTABLE: luaH_free(L, gco2t(o)); break;
    case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break;
    case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break;
    case LUA_TSHRSTR:
      luaS_remove(L, gco2ts(o));  /* remove it from hash table */
      luaM_freemem(L, o, sizelstring(gco2ts(o)->shrlen));
      break;
    case LUA_TLNGSTR: {
      luaM_freemem(L, o, sizelstring(gco2ts(o)->u.lnglen));
      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);

/*
** sweep at most 'count' elements from a list of GCObjects erasing dead
** objects, where a dead object is one marked with the old (non current)
** white; change all non-dead objects back to white, preparing for next
** collection cycle. Return where to continue the traversal or NULL if
** list is finished.
*/
static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
  global_State *g = G(L);
  int ow = otherwhite(g);
  int white = luaC_white(g);  /* current white */
  while (*p != NULL && count-- > 0) {
    GCObject *curr = *p;
    int marked = curr->marked;
    if (isdeadm(ow, marked)) {  /* is 'curr' dead? */
      *p = curr->next;  /* remove 'curr' from list */
      freeobj(L, curr);  /* erase 'curr' */
    }
    else {  /* change mark to 'white' */
      curr->marked = cast_byte((marked & maskcolors) | white);
      p = &curr->next;  /* go to next element */
    }
  }
  return (*p == NULL) ? NULL : p;
}

/*
** sweep a list until a live object (or end of list)
*/
static GCObject **sweeptolive (lua_State *L, GCObject **p) {
  GCObject **old = p;
  do {
    p = sweeplist(L, p, 1);
  } while (p == old);
  return p;
}

/* }====================================================== */

/*
** {======================================================
** Finalization
** =======================================================
*/

/*
** If possible, shrink string table
*/
static void checkSizes (lua_State *L, global_State *g) {
  if (g->gckind != KGC_EMERGENCY) {
    l_mem olddebt = g->GCdebt;
    if (g->strt.nuse < g->strt.size / 4)  /* string table too big? */
      luaS_resize(L, g->strt.size / 2);  /* shrink it a little */
    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
  }
}

static GCObject *udata2finalize (global_State *g) {
  GCObject *o = g->tobefnz;  /* get first element */
  lua_assert(tofinalize(o));
  g->tobefnz = o->next;  /* remove it from 'tobefnz' list */
  o->next = g->allgc;  /* return it to 'allgc' list */
  g->allgc = o;
  resetbit(o->marked, FINALIZEDBIT);  /* object is "normal" again */
  if (issweepphase(g))
    makewhite(g, o);  /* "sweep" object */
  return o;
}

static void dothecall (lua_State *L, void *ud) {
  UNUSED(ud);
  luaD_callnoyield(L, L->top - 2, 0);
}

static void GCTM (lua_State *L, int propagateerrors) {
  global_State *g = G(L);
  const TValue *tm;
  TValue v;
  setgcovalue(L, &v, udata2finalize(g));
  tm = luaT_gettmbyobj(L, &v, TM_GC);
  if (tm != NULL && ttisfunction(tm)) {  /* is there a finalizer? */
    int status;
    lu_byte oldah = L->allowhook;
    int running  = g->gcrunning;
    L->allowhook = 0;  /* stop debug hooks during GC metamethod */
    g->gcrunning = 0;  /* avoid GC steps */
    setobj2s(L, L->top, tm);  /* push finalizer... */
    setobj2s(L, L->top + 1, &v);  /* ... and its argument */
    L->top += 2;  /* and (next line) call the finalizer */
    L->ci->callstatus |= CIST_FIN;  /* will run a finalizer */
    status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
    L->ci->callstatus &= ~CIST_FIN;  /* not running a finalizer anymore */
    L->allowhook = oldah;  /* restore hooks */
    g->gcrunning = running;  /* restore state */
    if (status != LUA_OK && propagateerrors) {  /* error while running __gc? */
      if (status == LUA_ERRRUN) {  /* is there an error object? */
        const char *msg = (ttisstring(L->top - 1))
                            ? svalue(L->top - 1)
                            : "no message";
        luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
        status = LUA_ERRGCMM;  /* error in __gc metamethod */
      }
      luaD_throw(L, status);  /* re-throw error */
    }
  }
}

/*
** call a few (up to 'g->gcfinnum') finalizers
*/
static int runafewfinalizers (lua_State *L) {
  global_State *g = G(L);
  unsigned int i;
  lua_assert(!g->tobefnz || g->gcfinnum > 0);
  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
    GCTM(L, 1);  /* call one finalizer */
  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
                    : g->gcfinnum * 2;  /* else call a few more next time */
  return i;
}

/*
** call all pending finalizers
*/
static void callallpendingfinalizers (lua_State *L) {
  global_State *g = G(L);
  while (g->tobefnz)
    GCTM(L, 0);
}

/*
** find last 'next' field in list 'p' list (to add elements in its end)
*/
static GCObject **findlast (GCObject **p) {
  while (*p != NULL)
    p = &(*p)->next;
  return p;
}

/*
** move all unreachable objects (or 'all' objects) that need
** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
*/
static void separatetobefnz (global_State *g, int all) {
  GCObject *curr;
  GCObject **p = &g->finobj;
  GCObject **lastnext = findlast(&g->tobefnz);
  while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
    lua_assert(tofinalize(curr));
    if (!(iswhite(curr) || all))  /* not being collected? */
      p = &curr->next;  /* don't bother with it */
    else {
      *p = curr->next;  /* remove 'curr' from 'finobj' list */
      curr->next = *lastnext;  /* link at the end of 'tobefnz' list */
      *lastnext = curr;
      lastnext = &curr->next;
    }
  }
}

/*
** if object 'o' has a finalizer, remove it from 'allgc' list (must
** search the list to find it) and link it in 'finobj' list.
*/
void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
  global_State *g = G(L);
  if (tofinalize(o) ||                 /* obj. is already marked... */
      gfasttm(g, mt, TM_GC) == NULL)   /* or has no finalizer? */
    return;  /* nothing to be done */
  else {  /* move 'o' to 'finobj' list */
    GCObject **p;
    if (issweepphase(g)) {
      makewhite(g, o);  /* "sweep" object 'o' */
      if (g->sweepgc == &o->next)  /* should not remove 'sweepgc' object */
        g->sweepgc = sweeptolive(L, g->sweepgc);  /* change 'sweepgc' */
    }
    /* search for pointer pointing to 'o' */
    for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ }
    *p = o->next;  /* remove 'o' from 'allgc' list */
    o->next = g->finobj;  /* link it in 'finobj' list */
    g->finobj = o;
    l_setbit(o->marked, FINALIZEDBIT);  /* mark it as such */
  }
}

/* }====================================================== */

/*
** {======================================================
** GC control
** =======================================================
*/

/*
** Set a reasonable "time" to wait before starting a new GC cycle; cycle
** will start when memory use hits threshold. (Division by 'estimate'
** should be OK: it cannot be zero (because Lua cannot even start with
** less than PAUSEADJ bytes).
*/
static void setpause (global_State *g) {
  l_mem threshold, debt;
  l_mem estimate = g->GCestimate / PAUSEADJ;  /* adjust 'estimate' */
  lua_assert(estimate > 0);
  threshold = (g->gcpause < MAX_LMEM / estimate)  /* overflow? */
            ? estimate * g->gcpause  /* no overflow */
            : MAX_LMEM;  /* overflow; truncate to maximum */
  debt = gettotalbytes(g) - threshold;
  luaE_setdebt(g, debt);
}

/*
** Enter first sweep phase.
** The call to 'sweeplist' tries to make pointer point to an object
** inside the list (instead of to the header), so that the real sweep do
** not need to skip objects created between "now" and the start of the
** real sweep.
*/
static void entersweep (lua_State *L) {
  global_State *g = G(L);
  g->gcstate = GCSswpallgc;
  lua_assert(g->sweepgc == NULL);
  g->sweepgc = sweeplist(L, &g->allgc, 1);
}

void luaC_freeallobjects (lua_State *L) {
  global_State *g = G(L);
  separatetobefnz(g, 1);  /* separate all objects with finalizers */
  lua_assert(g->finobj == NULL);
  callallpendingfinalizers(L);
  lua_assert(g->tobefnz == NULL);
  g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
  g->gckind = KGC_NORMAL;
  sweepwholelist(L, &g->finobj);
  sweepwholelist(L, &g->allgc);
  sweepwholelist(L, &g->fixedgc);  /* collect fixed objects */
  lua_assert(g->strt.nuse == 0);
}

static l_mem atomic (lua_State *L) {
  global_State *g = G(L);
  l_mem work;
  GCObject *origweak, *origall;
  GCObject *grayagain = g->grayagain;  /* save original list */
  lua_assert(g->ephemeron == NULL && g->weak == NULL);
  lua_assert(!iswhite(g->mainthread));
  g->gcstate = GCSinsideatomic;
  g->GCmemtrav = 0;  /* start counting work */
  markobject(g, L);  /* mark running thread */
  /* registry and global metatables may be changed by API */
  markvalue(g, &g->l_registry);
  markmt(g);  /* mark global metatables */
  /* remark occasional upvalues of (maybe) dead threads */
  remarkupvals(g);
  propagateall(g);  /* propagate changes */
  work = g->GCmemtrav;  /* stop counting (do not recount 'grayagain') */
  g->gray = grayagain;
  propagateall(g);  /* traverse 'grayagain' list */
  g->GCmemtrav = 0;  /* restart counting */
  convergeephemerons(g);
  /* at this point, all strongly accessible objects are marked. */
  /* Clear values from weak tables, before checking finalizers */
  clearvalues(g, g->weak, NULL);
  clearvalues(g, g->allweak, NULL);
  origweak = g->weak; origall = g->allweak;
  work += g->GCmemtrav;  /* stop counting (objects being finalized) */
  separatetobefnz(g, 0);  /* separate objects to be finalized */
  g->gcfinnum = 1;  /* there may be objects to be finalized */
  markbeingfnz(g);  /* mark objects that will be finalized */
  propagateall(g);  /* remark, to propagate 'resurrection' */
  g->GCmemtrav = 0;  /* restart counting */
  convergeephemerons(g);
  /* at this point, all resurrected objects are marked. */
  /* remove dead objects from weak tables */
  clearkeys(g, g->ephemeron, NULL);  /* clear keys from all ephemeron tables */
  clearkeys(g, g->allweak, NULL);  /* clear keys from all 'allweak' tables */
  /* clear values from resurrected weak tables */
  clearvalues(g, g->weak, origweak);
  clearvalues(g, g->allweak, origall);
  luaS_clearcache(g);
  g->currentwhite = cast_byte(otherwhite(g));  /* flip current white */
  work += g->GCmemtrav;  /* complete counting */
  return work;  /* estimate of memory marked by 'atomic' */
}

static lu_mem sweepstep (lua_State *L, global_State *g,
                         int nextstate, GCObject **nextlist) {
  if (g->sweepgc) {
    l_mem olddebt = g->GCdebt;
    g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
    if (g->sweepgc)  /* is there still something to sweep? */
      return (GCSWEEPMAX * GCSWEEPCOST);
  }
  /* else enter next state */
  g->gcstate = nextstate;
  g->sweepgc = nextlist;
  return 0;
}

static lu_mem singlestep (lua_State *L) {
  global_State *g = G(L);
  switch (g->gcstate) {
    case GCSpause: {
      g->GCmemtrav = g->strt.size * sizeof(GCObject*);
      restartcollection(g);
      g->gcstate = GCSpropagate;
      return g->GCmemtrav;
    }
    case GCSpropagate: {
      g->GCmemtrav = 0;
      lua_assert(g->gray);
      propagatemark(g);
       if (g->gray == NULL)  /* no more gray objects? */
        g->gcstate = GCSatomic;  /* finish propagate phase */
      return g->GCmemtrav;  /* memory traversed in this step */
    }
    case GCSatomic: {
      lu_mem work;
      propagateall(g);  /* make sure gray list is empty */
      work = atomic(L);  /* work is what was traversed by 'atomic' */
      entersweep(L);
      g->GCestimate = gettotalbytes(g);  /* first estimate */;
      return work;
    }
    case GCSswpallgc: {  /* sweep "regular" objects */
      return sweepstep(L, g, GCSswpfinobj, &g->finobj);
    }
    case GCSswpfinobj: {  /* sweep objects with finalizers */
      return sweepstep(L, g, GCSswptobefnz, &g->tobefnz);
    }
    case GCSswptobefnz: {  /* sweep objects to be finalized */
      return sweepstep(L, g, GCSswpend, NULL);
    }
    case GCSswpend: {  /* finish sweeps */
      makewhite(g, g->mainthread);  /* sweep main thread */
      checkSizes(L, g);
      g->gcstate = GCScallfin;
      return 0;
    }
    case GCScallfin: {  /* call remaining finalizers */
      if (g->tobefnz && g->gckind != KGC_EMERGENCY) {
        int n = runafewfinalizers(L);
        return (n * GCFINALIZECOST);
      }
      else {  /* emergency mode or no more finalizers */
        g->gcstate = GCSpause;  /* finish collection */
        return 0;
      }
    }
    default: lua_assert(0); return 0;
  }
}

/*
** advances the garbage collector until it reaches a state allowed
** by 'statemask'
*/
void luaC_runtilstate (lua_State *L, int statesmask) {
  global_State *g = G(L);
  while (!testbit(statesmask, g->gcstate))
    singlestep(L);
}

/*
** get GC debt and convert it from Kb to 'work units' (avoid zero debt
** and overflows)
*/
static l_mem getdebt (global_State *g) {
  l_mem debt = g->GCdebt;
  int stepmul = g->gcstepmul;
  if (debt <= 0) return 0;  /* minimal debt */
  else {
    debt = (debt / STEPMULADJ) + 1;
    debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
    return debt;
  }
}

/*
** performs a basic GC step when collector is running
*/
void luaC_step (lua_State *L) {
  global_State *g = G(L);
  l_mem debt = getdebt(g);  /* GC deficit (be paid now) */
  if (!g->gcrunning) {  /* not running? */
    luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
    return;
  }
  do {  /* repeat until pause or enough "credit" (negative debt) */
    lu_mem work = singlestep(L);  /* perform one single step */
    debt -= work;
  } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
  if (g->gcstate == GCSpause)
    setpause(g);  /* pause until next cycle */
  else {
    debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
    luaE_setdebt(g, debt);
    runafewfinalizers(L);
  }
}

/*
** Performs a full GC cycle; if 'isemergency', set a flag to avoid
** some operations which could change the interpreter state in some
** unexpected ways (running finalizers and shrinking some structures).
** Before running the collection, check 'keepinvariant'; if it is true,
** there may be some objects marked as black, so the collector has
** to sweep all objects to turn them back to white (as white has not
** changed, nothing will be collected).
*/
void luaC_fullgc (lua_State *L, int isemergency) {
  global_State *g = G(L);
  lua_assert(g->gckind == KGC_NORMAL);
  if (isemergency) g->gckind = KGC_EMERGENCY;  /* set flag */
  if (keepinvariant(g)) {  /* black objects? */
    entersweep(L); /* sweep everything to turn them back to white */
  }
  /* finish any pending sweep phase to start a new cycle */
  luaC_runtilstate(L, bitmask(GCSpause));
  luaC_runtilstate(L, ~bitmask(GCSpause));  /* start new collection */
  luaC_runtilstate(L, bitmask(GCScallfin));  /* run up to finalizers */
  /* estimate must be correct after a full GC cycle */
  lua_assert(g->GCestimate == gettotalbytes(g));
  luaC_runtilstate(L, bitmask(GCSpause));  /* finish collection */
  g->gckind = KGC_NORMAL;
  setpause(g);
}

/* }====================================================== */


text:
package monix.eval

import java.util.concurrent.TimeUnit

import cats.effect.{Clock, ContextShift, Timer}
import monix.execution.schedulers.TestScheduler

import scala.concurrent.duration._
import scala.util.Success

object TaskClockTimerAndContextShiftSuite extends BaseTestSuite {
  test("Task.clock is implicit") { _ =>
    assertEquals(Task.clock, implicitly[Clock[Task]])
  }

  test("Task.clock.monotonic") { implicit s =>
    s.tick(1.seconds)

    val f = Task.clock.monotonic(TimeUnit.SECONDS).runToFuture
    s.tick()

    assertEquals(f.value, Some(Success(1)))
  }

  test("Task.clock.realTime") { implicit s =>
    s.tick(1.seconds)

    val f = Task.clock.realTime(TimeUnit.SECONDS).runToFuture
    s.tick()

    assertEquals(f.value, Some(Success(1)))
  }

  test("Task.clock(s2).monotonic") { implicit s =>
    val s2 = TestScheduler()
    s2.tick(1.seconds)

    val f = Task.clock(s2).monotonic(TimeUnit.SECONDS).runToFuture
    s.tick()

    assertEquals(f.value, Some(Success(1)))
  }

  test("Task.clock(s).realTime") { implicit s =>
    val s2 = TestScheduler()
    s2.tick(1.seconds)

    val f = Task.clock(s2).realTime(TimeUnit.SECONDS).runToFuture
    s.tick()

    assertEquals(f.value, Some(Success(1)))
  }

  test("Task.timer is implicit") { implicit s =>
    assertEquals(Task.timer, implicitly[Timer[Task]])
    assertEquals(Task.timer.clock, implicitly[Clock[Task]])
  }

  test("Task.timer") { implicit s =>
    val f = Task.timer.sleep(1.second).runToFuture
    s.tick()
    assertEquals(f.value, None)
    s.tick(1.second)
    assertEquals(f.value, Some(Success(())))
  }

  test("Task.timer(s)") { implicit s =>
    val s2 = TestScheduler()
    val f = Task.timer(s2).sleep(1.second).runToFuture

    s.tick()
    assertEquals(f.value, None)
    s.tick(1.second)
    assertEquals(f.value, None)
    s2.tick(1.second)
    s.tick(1.second)
    assertEquals(f.value, Some(Success(())))
  }

  test("Task.timer(s).clock") { implicit s =>
    val s2 = TestScheduler()
    s2.tick(1.second)

    val f = Task.timer(s2).clock.monotonic(TimeUnit.SECONDS).runToFuture
    s.tick()
    assertEquals(f.value, Some(Success(1)))
  }

  test("Task.contextShift is implicit") { implicit s =>
    assertEquals(Task.contextShift, implicitly[ContextShift[Task]])
  }

  test("Task.contextShift.shift") { implicit s =>
    val f = Task.contextShift.shift.runToFuture
    assertEquals(f.value, None)
    s.tick()
    assertEquals(f.value, Some(Success(())))
  }

  test("Task.contextShift.evalOn(s2)") { implicit s =>
    val s2 = TestScheduler()
    val f = Task.contextShift.evalOn(s2)(Task(1)).runToFuture

    assertEquals(f.value, None)
    s.tick()
    assertEquals(f.value, None)
    s2.tick()
    s.tick()
    assertEquals(f.value, Some(Success(1)))
  }

  test("Task.contextShift(s).shift") { implicit s =>
    val f = Task.contextShift(s).shift.runToFuture
    assertEquals(f.value, None)
    s.tick()
    assertEquals(f.value, Some(Success(())))
  }

  test("Task.contextShift(s).evalOn(s2)") { implicit s =>
    val s2 = TestScheduler()
    val f = Task.contextShift(s).evalOn(s2)(Task(1)).runToFuture

    assertEquals(f.value, None)
    s.tick()
    assertEquals(f.value, None)
    s2.tick()
    s.tick()
    assertEquals(f.value, Some(Success(1)))
  }
}

redpajama_set_name: RedPajamaGithub


text:
/*
 * JavaScript support file for the clean_shaved gem.
 * (C) 2012 Frederic Jean
 * See https://github.com/fredjean/clean_shaved for further
 * information and license.
 */

// Loads the Handlebars JS file.
//= require 'handlebars-1.0.rc.1.js'

Handlebars.templates = Handlebars.templates || {};

jQuery(function() {

  // Compiles the templates that are declared in development mode.
  $('[type*=x-handlebars-template]').each(function() {
    var $tmpl = $(this);
    var name = $tmpl.attr('name')
    var html = '' + $tmpl.html();
    var template = Handlebars.compile(html);
    Handlebars.templates[name] = template;
  });
});


text:
module SiEngine
  class PDFResource < TextResource
    def initialize
      super('')
    end

    # A test file has been provided. Run in the rails console:
    # => SiEngine::PDFResource.analyze_pdf("{SiEngine::Engine.root/app/assets/docs/colorado_dmv.pdf}")
    def self.analyze_pdf(source_uri='')
      file = PDF::Reader.new(source_uri)
      pdf = PDFResource.new
      pdf.plain_text = ""
      file.pages.each do |page|
        pdf.plain_text += pdf.cleanup_plain_text(page.text)
      end
      pdf.process_text_semantics!(pdf.plain_text)
      pdf.source_uri = source_uri || ''
      pdf
    end
  end
end


text:
package com.accela.tetrixgame.conn.support.ReflectionSupport;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.lang.reflect.*;

/**
 *
 * 这个类用来从一个Class<?>对象中抽取其自身以及其所有父类的字段。 字段以固定方法排序,每个数组装有一个类的所有字段,并且其中static
 * 字段放在非static字段后头。
 *
 * //TODO 未经详尽测试,只是通过HPObjectStream间接验证过
 *
 */
public class FieldExtractor {
	private static final Map<Class<?>, List<Field[]>> fieldMap = new ConcurrentHashMap<Class<?>, List<Field[]>>();

	private static final FieldComparator fieldComparator = new FieldComparator();

	/**
	 *
	 * 排序规则:静态字段比非静态字段大,静态字段和静态字段都相等, 非静态字段和非静态字段之间用名字来按字典序比较
	 *
	 */
	private static class FieldComparator implements Comparator<Field> {
		@Override
		public int compare(Field left, Field right) {
			boolean isLeftStatic = Modifier.isStatic(left.getModifiers());
			boolean isRightStatic = Modifier.isStatic(right.getModifiers());

			if (!isLeftStatic && isRightStatic) {
				return -1;
			} else if (isLeftStatic && !isRightStatic) {
				return 1;
			} else if (isLeftStatic && isRightStatic) {
				return 0;
			} else {
				return left.getName().compareTo(right.getName());
			}

		}
	}

	/**
	 * 抽取一个类及其父类,以及父类的父类的所有字段。返回的链表中,每个数组 都装有一个类的所有字段。后一个数组是前一个数组的父类。在一个数组内,
	 * 所有静态字段都放在非静态字段后面,非静态字段按照其名字的字典序排列, 静态字段的顺序没有保证。
	 *
	 * 另外,返回的链表以及其中的数组都是存储在这个类中的,被所有人共享。如果 更改,则会引起错误。
	 */
	public List<Field[]> getSortedFieldsList(final Class<?> objectClass) {
		if (null == objectClass) {
			throw new NullPointerException("objectClass should not be null");
		}

		List<Field[]> fieldList = fieldMap.get(objectClass);
		if (fieldList != null) {
			assert (checkReturnListValid(fieldList));
			return fieldList;
		} else {
			// 计算并得到fieldList
			fieldList = new LinkedList<Field[]>();
			Class<?> aimClass = objectClass;
			while (aimClass != null) {
				Field[] fields = aimClass.getDeclaredFields();
				Arrays.sort(fields, fieldComparator);
				fieldList.add(fields);

				aimClass = aimClass.getSuperclass();
			}

			// 得到不可改变的表视图
			fieldList = Collections.unmodifiableList(fieldList);
			assert (fieldList != null);

			// 将新得到的fieldList记录入fieldMap,如果使用多线程,有可能重复
			// 放入相同的fieldList,不过不会引起错误
			fieldMap.put(objectClass, fieldList);

			// 检查得到的fieldList的正确性
			assert (checkReturnListValid(fieldList));

			return fieldList;
		}

	}

	private static boolean checkReturnListValid(List<Field[]> fieldList) {
		if (null == fieldList) {
			return false;
		}

		for (Field[] fields : fieldList) {
			if (null == fields) {
				return false;
			}

			boolean hasMetStatic = false;
			for (int i = 0; i < fields.length; i++) {
				final Field f = fields[i];
				if (null == f) {
					return false;
				}

				if (hasMetStatic) {
					if (!Modifier.isStatic(f.getModifiers())) {
						return false;
					}
				} else {
					if (Modifier.isStatic(f.getModifiers())) {
						hasMetStatic = true;
					} else {
						if (i > 0) {
							final Field lastF = fields[i - 1];
							if (lastF == null) {
								return false;
							}
							if (Modifier.isStatic(lastF.getModifiers())) {
								return false;
							}
							if (lastF.getName().compareTo(f.getName()) >= 0) {
								return false;
							}
						} else {
							if (hasMetStatic) {
								return false;
							}
						}
					}
				}
			}
		}// outer for

		return true;
	}

	/**
	 * FieldExtractor的创建使用了缓冲区技术,因此应该通过静态方法创建
	 */
	protected FieldExtractor() {

	}

	/**
	 * 装载字段提取器FieldExtractor对象的栈。这是为了优化FieldExtractor对象
	 * 的使用,避免频繁创建和释放FieldExtractor对象而设计。
	 */
	private static Stack<FieldExtractor> fieldExtractorStack = new Stack<FieldExtractor>();

	/**
	 * 获得一个FieldExtractor对象。通过这个方法来获得FieldExtractor 对象才能够优化它的新建。
	 */
	public synchronized static FieldExtractor getFieldExtractor() {
		if (fieldExtractorStack.isEmpty()) {
			return new FieldExtractor();
		} else {
			return fieldExtractorStack.pop();
		}
	}

	/**
	 * 释放一个FieldExtractor对象。通过这个方法来释放FieldExtractor 对象才能够优化它的释放。
	 */
	public synchronized static void disposeFieldExtractor(
			FieldExtractor fieldExtractor) {
		if (null == fieldExtractor) {
			throw new NullPointerException("fieldExtractor should not be null");
		}
		fieldExtractorStack.push(fieldExtractor);
	}

}


text:
{% load i18n %}
{% load hq_shared_tags %}

{% if add_ons.display_conditions %}

      {% trans "Display Condition" %}
      <span class="hq-help-template"
            data-title="{% trans "Display Condition" %}"
            data-content="{% blocktrans %}The form will not appear in the menu unless this condition is met. Read more on the Help Site.{% endblocktrans %}"
      >

            <textarea name="form_filter" class="form-control" data-bind="
                    xpathValidator: {text: formFilter, allowCaseHashtags: true,
                                     errorHtml: $('#formFilterXpathErrorHtml').html()}
            "></textarea>

            {% blocktrans %}
              To use display conditions which reference a case,

              (1) the Menu Mode setting must be set to
              Display menu and then forms

              (2) all the forms in the case list must update or close a case, which means registration
              forms must go in a separate case list, or if your project uses user properties, your
              display condition may use user properties.
            {% endblocktrans %}

            {% blocktrans %}
              To use display conditions which reference a user property, user properties must be
              enabled for your project.
            {% endblocktrans %}
            {% if allow_usercase %}

              <button class="btn btn-default btn-xs" data-bind="click: enableUsercase, disabled: enableUsercaseInProgress">

                {% trans "Enable user properties" %}
              </button>

            {% endif %}

        {% blocktrans %}
          There is something wrong with the logic in the Form Display Condition.
          Check to make sure your parentheses match and you are referencing case properties correctly.
        {% endblocktrans %}

{% endif %}


text:
package com.corosus.game;

/**
 * Created by kickban on 7/12/14.
 */
public class Cst {
    public static int SPRITESIZE = 64;
    public static int COLLIDESIZE_DEFAULT = 32;
    public static int COLLIDESIZE_SPRITE = 32+8;
    public static int COLLIDESIZE_PROJECTILE = 16;
    public static int TILESIZE   = 64;
    public static boolean  DEBUG = true;
}


text:
package com.lewisd.ksp.craftstats.cfg;

import java.io.InputStream;

import org.junit.Test;

public class CfgReaderTest {

    private final CfgReader cfgReader = new CfgReader();

    @Test
    public void test() throws Exception {
        InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("complex.cfg");
        final CfgGroup craft = cfgReader.readCfg(in);

        System.out.println(craft);
    }

}


text:
(function() {
  var CipherObject, E, crypto, decrypt, decryptAsync, decryptPromise, decryptSync, encrypt, encryptAsync, encryptPromise, encryptSync, incompatibleVersion, pkg, semver;

  crypto = require('crypto');

  semver = require('semver');

  pkg = require('./package.json');

  CipherObject = require('./CipherObject');

  E = require('./constants');

  encrypt = function(passphrase, plainfile, callback) {
    switch (arguments.length) {
      case 1:
        return encryptStream(passphrase);
      case 2:
        return encryptPromise(passphrase, plainfile);
      case 3:
        return encryptAsync(passphrase, plainfile, callback);
    }
  };

  decrypt = function(passphrase, cipherObject, callback) {
    switch (arguments.length) {
      case 1:
        return decryptStream(passphrase);
      case 2:
        return decryptPromise(passphrase, cipherObject);
      case 3:
        return decryptAsync(passphrase, cipherObject, callback);
    }
  };

  encryptAsync = function(passphrase, plainfile, callback) {
    var salt;
    salt = crypto.randomBytes(E.SALT_LENGTH);
    crypto.pbkdf2(passphrase, salt, E.ITERATIONS, E.KEY_LENGTH, E.HASH_ALGORITHM, function(err, key) {
      var cipher, iv;
      if (err != null) {
        return callback(err);
      }
      iv = crypto.randomBytes(E.IV_LENGTH);
      cipher = crypto.createCipheriv(E.CIPHER_ALGORITHM, key, iv);
      return cipher.end(plainfile, function(err) {
        var authtag, cipherfile, result;
        if (err != null) {
          return callback(err);
        }
        cipherfile = cipher.read();
        authtag = cipher.getAuthTag();
        result = new CipherObject({
          yael_version: pkg.version,
          cipherfile: cipherfile,
          iv: iv,
          salt: salt,
          authtag: authtag,
          return_type: (function() {
            switch (false) {
              case typeof plainfile !== 'string':
                return 'String';
              case !(plainfile instanceof Buffer):
                return 'Buffer';
              default:
                return 'undefined';
            }
          })(),
          details: {
            CIPHER_ALGORITHM: E.CIPHER_ALGORITHM,
            SALT_LENGTH: E.SALT_LENGTH,
            IV_LENGTH: E.IV_LENGTH,
            KEY_LENGTH: E.KEY_LENGTH,
            HASH_ALGORITHM: E.HASH_ALGORITHM,
            ITERATIONS: E.ITERATIONS
          }
        });
        return callback(null, result);
      });
    });
    return null;
  };

  decryptAsync = function(passphrase, cipherObject, callback) {
    var authtag, cipherfile, err, iv, return_type, salt, yael_version;
    yael_version = cipherObject.yael_version, cipherfile = cipherObject.cipherfile, iv = cipherObject.iv, salt = cipherObject.salt, authtag = cipherObject.authtag, return_type = cipherObject.return_type;
    err = incompatibleVersion(yael_version);
    if (err != null) {
      return callback(err);
    }
    crypto.pbkdf2(passphrase, salt, E.ITERATIONS, E.KEY_LENGTH, E.HASH_ALGORITHM, function(err, key) {
      var decipher, error;
      if (err != null) {
        return callback(err);
      }
      decipher = crypto.createDecipheriv(E.CIPHER_ALGORITHM, key, iv);
      decipher.setAuthTag(authtag);
      try {
        return decipher.end(cipherfile, function(err) {
          var plainfile;
          if (err != null) {
            return callback(err);
          }
          plainfile = decipher.read();
          if (return_type === 'String') {
            plainfile = plainfile.toString();
          }
          return callback(null, plainfile);
        });
      } catch (error) {
        err = error;
        if (err.message === "Unsupported state or unable to authenticate data") {
          return callback(new Error("Message Corrupted"));
        }
        if (err != null) {
          return callback(err);
        }
      }
    });
    return null;
  };

  encryptPromise = function(passphrase, plaintext) {
    return new Promise(function(resolve, reject) {
      return encryptAsync(passphrase, plaintext, function(err, result) {
        if (err != null) {
          return reject(err);
        }
        return resolve(result);
      });
    });
  };

  decryptPromise = function(passphrase, cipherObject) {
    return new Promise(function(resolve, reject) {
      return decryptAsync(passphrase, cipherObject, function(err, result) {
        if (err != null) {
          return reject(err);
        }
        return resolve(result);
      });
    });
  };

  encryptSync = function(passphrase, plainfile) {
    var authtag, cipher, cipherfile, iv, key, result, return_type, salt;
    return_type = (function() {
      switch (false) {
        case typeof plainfile !== 'string':
          return 'String';
        case !(plainfile instanceof Buffer):
          return 'Buffer';
        default:
          return 'undefined';
      }
    })();
    if (return_type === 'String') {
      plainfile = new Buffer(plainfile, 'utf8');
    }
    salt = crypto.randomBytes(E.SALT_LENGTH);
    key = crypto.pbkdf2Sync(passphrase, salt, E.ITERATIONS, E.KEY_LENGTH, E.HASH_ALGORITHM);
    iv = crypto.randomBytes(E.IV_LENGTH);
    cipher = crypto.createCipheriv(E.CIPHER_ALGORITHM, key, iv);
    cipherfile = Buffer.concat([cipher.update(plainfile), cipher.final()]);
    authtag = cipher.getAuthTag();
    result = new CipherObject({
      yael_version: pkg.version,
      cipherfile: cipherfile,
      iv: iv,
      salt: salt,
      authtag: authtag,
      return_type: return_type,
      details: {
        CIPHER_ALGORITHM: E.CIPHER_ALGORITHM,
        SALT_LENGTH: E.SALT_LENGTH,
        IV_LENGTH: E.IV_LENGTH,
        KEY_LENGTH: E.KEY_LENGTH,
        HASH_ALGORITHM: E.HASH_ALGORITHM,
        ITERATIONS: E.ITERATIONS
      }
    });
    return result;
  };

  decryptSync = function(passphrase, cipherObject) {
    var authtag, cipherfile, decipher, err, error, iv, key, plainfile, return_type, salt, yael_version;
    yael_version = cipherObject.yael_version, cipherfile = cipherObject.cipherfile, iv = cipherObject.iv, salt = cipherObject.salt, authtag = cipherObject.authtag, return_type = cipherObject.return_type;
    err = incompatibleVersion(yael_version);
    if (err != null) {
      throw err;
    }
    key = crypto.pbkdf2Sync(passphrase, salt, E.ITERATIONS, E.KEY_LENGTH, E.HASH_ALGORITHM);
    decipher = crypto.createDecipheriv(E.CIPHER_ALGORITHM, key, iv);
    decipher.setAuthTag(authtag);
    try {
      plainfile = Buffer.concat([decipher.update(cipherfile), decipher.final()]);
      if (return_type === 'String') {
        plainfile = plainfile.toString('utf8');
      }
      return plainfile;
    } catch (error) {
      err = error;
      if (err.message === "Unsupported state or unable to authenticate data") {
        throw new Error("Message Corrupted");
      }
    }
  };

  incompatibleVersion = function(yael_version) {
    if (semver.valid(yael_version) == null) {
      return new Error("cipherObject cannot be read because cipherObject.yael_version is not a valid semver");
    }
    if (semver.major(yael_version) !== semver.major(pkg.version)) {
      return new Error("cipherObject cannot be read because cipherObject.yael_version is incompatible with this version of yael");
    }
    if (semver.minor(yael_version) > semver.minor(pkg.version)) {
      return new Error("cipherObject cannot be read because cipherObject.yael_version indicates the cipherObject was made by a newer version of yael");
    }
    return null;
  };

  module.exports = {
    encrypt: encrypt,
    encryptSync: encryptSync,
    decrypt: decrypt,
    decryptSync: decryptSync,
    CipherObject: CipherObject
  };

}).call(this);


text:
var ADODBStream = WScript.CreateObject('ADODB.Stream');
ADODBStream.open();
ADODBStream.writeText('Hello world');
ADODBStream.saveToFile('filename.txt', 1);
ADODBStream.saveToFile('filename.txt', 1);


text:
title: Building a World
section_title: Building a World
type: unit3
layout: docs
parent_section: project3
order: 3
toc: true
---

Let's learn how to add and manipulate objects in Vizor! Many Vizor techniques work in other CG programs too.

### The Patches Menu
In Vizor, you add 3D objects using the "Patches Menu." The Patches Menu contains two tabs.

* The "Objects" tab shows objects you can add to your scene.
* The "Patches" tab allows you to use programming in Vizor and will be explored in later projects.

If you do not see the Patches Menus, click the "Patches" button in the Vizor editor. You can click again to make the Patches Menu disappear. You can also click on the Patches Menu and drag to move the menu around.

	Click the Patches button on the top right to turn the Patches menu on and off.

  Remember to hit "Tab" if your Editor ever looks like the following. We will cover Patches and programming in later projects.

### Hello Objects!

Now let's add an object to your world!

  	Do It Yourself!

Select the Objects tab in the Patches menu.

Select the objects "Objects: Basic" option, then select the "Box" option.

	Click "Box" in the "Objects: Basic" option on the Patches Menu to add a Box.

You should now see a box object in your scene. You can select any object by clicking on the object. You know you've selected an object when red, green, and blue lines appear by the object. Each line is an "axis" and can be used to change the object's position, size, and rotation.

#### Object Manipulation
The following videos show how you can manipulate objects. The "Move," "Scale," and "Rotate" buttons can be found on the rop right of the Vizor editor.

	Select the "Move" button then drag along the axes to move an object.

	Select the "Scale" button then drag along the axes to change an object's size.

	Select the "Rotate" button then drag along the axes to rotate an object.

  	Extra Tips

You can delete an object by selecting the object and pressing "Backspace" or "Delete" on your keyboard.

You can undo changes by pressing the "Ctrl" and "Z" button on your keyboard.

With an object selected, you can press "Alt" and move the object to create a copy.

### Building a World

Now you're all set to start building your first virtual world!

  	Before You Continue

Add at least 5 objects to your scene and modify the objects as much as you want. Try the many different options in the Objects menu!

Make a scene you would be happy to show your friends.

Once you are ready, go to the next section to view and publish your project.


text:
using System;
using System.Threading;
using System.Threading.Tasks;
using StockSharp.Logging;

namespace StockSharp.Messages;

/// <summary>
/// Message adapter with async processing support.
/// </summary>
public interface IAsyncMessageAdapter : ILogReceiver
{
	private static readonly TimeSpan DefaultDisconnectTimeout = TimeSpan.FromSeconds(5);
	private static readonly TimeSpan DefaultTransactionTimeout = TimeSpan.FromSeconds(10);

	/// <summary>
	/// </summary>
	TimeSpan DisconnectTimeout => DefaultDisconnectTimeout;

	/// <summary>
	/// </summary>
	TimeSpan TransactionTimeout => DefaultTransactionTimeout;

	/// <summary>
	/// </summary>
	ValueTask ConnectAsync(ConnectMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask DisconnectAsync(DisconnectMessage msg)
		=> ProcessMessageAsync(msg, CancellationToken.None);

	/// <summary>
	/// Reset adapter. Must NOT throw.
	/// </summary>
	ValueTask ResetAsync(ResetMessage msg)
		=> ProcessMessageAsync(msg, CancellationToken.None);

	/// <summary>
	/// </summary>
	ValueTask SecurityLookupAsync(SecurityLookupMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask PortfolioLookupAsync(PortfolioLookupMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask BoardLookupAsync(BoardLookupMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask OrderStatusAsync(OrderStatusMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask RegisterOrderAsync(OrderRegisterMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask ReplaceOrderAsync(OrderReplaceMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask ReplaceOrderPairAsync(OrderPairReplaceMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask CancelOrderAsync(OrderCancelMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	ValueTask CancelOrderGroupAsync(OrderGroupCancelMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token);

	/// <summary>
	/// </summary>
	Task RunSubscriptionAsync(MarketDataMessage msg, CancellationToken token)
		=> ProcessMessageAsync(msg, token).AsTask();

	/// <summary>
	/// </summary>
	ValueTask ProcessMessageAsync(Message msg, CancellationToken token) => default; // do nothing by default

	/// <summary>
	/// </summary>
	void HandleMessageException(Message msg, Exception err);
}


text:
using System;

// Problem 8. Square Root
// • Create a console application that calculates and prints the square root of the number 12345.
// • Find in Internet "how to calculate square root in C#".

public class SquareRootCalculation
{
    public static void Main()
    {
        double sqrtNumber = Math.Sqrt(12345);
        Console.WriteLine("The Square Root of 12345 is {0}.", sqrtNumber);
    }
}


text:
import { assert } from "chai"
import R from "ramda"
import sinon from "sinon"

import UserListCard from "./UserListCard"
import DropdownMenu from "./DropdownMenu"
import Dialog from "./Dialog"
import UserListFormDialog from "./UserListFormDialog"

import IntegrationTestHelper from "../util/integration_test_helper"
import { makeUserList } from "../factories/learning_resources"
import { readableLearningResources } from "../lib/constants"
import { topicApiURL, userListDetailApiURL } from "../lib/url"
import * as urlLib from "../lib/url"
import { queryListResponse } from "../lib/test_utils"

describe("UserListCard tests", () => {
  let userList, helper, renderUserListCard

  beforeEach(() => {
    userList = makeUserList()
    helper = new IntegrationTestHelper()
    helper.handleRequestStub
      .withArgs(topicApiURL)
      .returns(queryListResponse([]))
    renderUserListCard = helper.configureReduxQueryRenderer(UserListCard, {
      userList
    })
  })

  afterEach(() => {
    helper.cleanup()
  })

  const getDialog = R.curry((index, Component, wrapper) => {
    wrapper.find(".more_vert").simulate("click")
    wrapper.update()
    wrapper.find(DropdownMenu).find("div").at(index).simulate("click")
    return wrapper.find(Component)
  })

  const getDeleteDialog = getDialog(0, Dialog)
  const getEditDialog = getDialog(1, UserListFormDialog)

  it("should print the list type (learning path || list)", async () => {
    const { wrapper } = await renderUserListCard()
    assert.equal(
      wrapper.find(".platform").text(),
      readableLearningResources[userList.list_type]
    )
  })

  it("should put the title", async () => {
    const { wrapper } = await renderUserListCard()
    assert.equal(wrapper.find(".ul-title").at(0).text(), userList.title)
  })

  //
  ;[
    [0, "Items"],
    [1, "Item"],
    [2, "Items"],
    [10, "Items"]
  ].forEach(([itemCount, expectedText]) => {
    it(`should have a properly-formatted count of ${String(
      itemCount
    )} items`, async () => {
      userList.item_count = itemCount
      const { wrapper } = await renderUserListCard()
      const text = wrapper.find(".count").text()
      assert.include(text, expectedText)
    })
  })

  it("should render the image of the first list item", async () => {
    helper.sandbox.stub(urlLib, "embedlyThumbnail").returns("南瓜")
    const { wrapper } = await renderUserListCard()
    const { src } = wrapper.find("img").props()
    assert.equal(src, "南瓜")
  })

  it("should hide the dropdown menu if you pass the flag", async () => {
    const { wrapper } = await renderUserListCard({ hideUserListOptions: true })
    assert.isNotOk(wrapper.find(".more_vert").exists())
  })

  it("should have a button to open a delete menu, which should confirm", async () => {
    const { wrapper } = await renderUserListCard()
    const dialog = getDeleteDialog(wrapper)
    const { submitText, title, hideDialog } = dialog.props()
    assert.equal(submitText, "Delete")
    assert.equal(
      title,
      `Delete this ${readableLearningResources[userList.list_type]}?`
    )
    hideDialog()
    wrapper.update()
    assert.isNotOk(wrapper.find(Dialog).exists())
  })

  it("should issue a DELETE request if the user confirms", async () => {
    const { wrapper } = await renderUserListCard()
    const { onAccept } = getDeleteDialog(wrapper).props()
    await onAccept()

    sinon.assert.calledWith(
      helper.handleRequestStub,
      userListDetailApiURL.param({ userListId: userList.id }).toString(),
      "DELETE"
    )
  })

  it("should let you open a dialog to edit the UserList", async () => {
    const { wrapper } = await renderUserListCard()
    const dialog = getEditDialog(wrapper)
    assert.deepEqual(dialog.prop("userList"), userList)
    dialog.prop("hide")()
    wrapper.update()
    assert.isNotOk(wrapper.find(Dialog).exists())
  })
})


text:
package com.smallchill.core.toolbox.support;

import java.util.HashMap;
import java.util.Map;

import com.smallchill.core.toolbox.Func;
import com.smallchill.core.toolbox.kit.JsonKit;
import com.smallchill.core.toolbox.kit.StrKit;

/**
 * 定义常用的 sql关键字
 *
 */
public class SqlKeyword {
	private static final String EQUAL = "_equal";
	private static final String NOT_EQUAL = "_notequal";
	private static final String LIKE = "_like";
	private static final String NOT_LIKE = "_notlike";
	private static final String GT = "_gt";
	private static final String LT = "_lt";
	private static final String DATE_GT = "_dategt";
	private static final String DATE_LT = "_datelt";
	private static final String OR = "or_";
	private static final String AND = "and_";
	private static final String SECOND = "_2nd";
	private static final String IS_NULL = "_null";
	private static final String NOT_NULL = "_notnull";
	private static HashMap<String, String> keyWord = new HashMap<String, String>();
	static {
		keyWord.put(EQUAL, " = ? ");
		keyWord.put(NOT_EQUAL, " <> ? ");
		keyWord.put(LIKE, " like ? ");
		keyWord.put(NOT_LIKE, " not like ? ");
		keyWord.put(GT, " > ? ");
		keyWord.put(LT, " < ? ");
		keyWord.put(DATE_GT, " > ? ");
		keyWord.put(DATE_LT, " < ? ");
		keyWord.put(IS_NULL, " is null ");
		keyWord.put(NOT_NULL, " is not null ");
	}

	/**
	 * TODO 根据前台json格式转化成map进行遍历
	 *
	 * @param w
	 * @return String
	 */
	@SuppressWarnings("unchecked")
	public static String getWhere(String w) {
		try {
			StringBuilder where = new StringBuilder(" where 1=1 ");
			StringBuilder or = new StringBuilder();
			StringBuilder and = new StringBuilder();
			if (StrKit.notBlank(w)) {
				w = Func.decodeUrl(w);
				Map<String, String> mm = JsonKit.parse(w, HashMap.class);
				for (String m : mm.keySet()) {
					String col = clearKeyWord(m);
					String k = "";
					for (String key : keyWord.keySet()) {
						if (m.indexOf(key) >= 0) {
							k = key;
							break;
						}
					}
					if (StrKit.isBlank(k)) {
						k = EQUAL;
					}
					String filter = col + getKeyWord(k, m);
					if (m.indexOf(OR) == -1) {
						and.append(" and (" + filter + ")");
					} else {
						or.append(" or (" + filter + ")");
					}
				}
				where.append(and.toString()).append(or.toString());
			}
			return where.toString();
		} catch (Exception ex) {
			return " where 1=1 ";
		}
	}

	public static String clearKeyWord(String key) {
		for (String k : keyWord.keySet()) {
			key = key.replace(k, "");
		}
		key = key.replace(OR, "").replace(AND, "").replace(SECOND, "");
		return key;
	}

	public static String getKeyWord(String key, String value) {
		String _keyWord = keyWord.get(key);
		if (key.equals(DATE_GT) || key.equals(DATE_LT)) {
			// value = value.replace("T", " ") + ":00";
			if (Func.isOracle()) {
				value = "to_date(#{" + value + "},'yyyy-mm-dd hh24:mi:ss')" + (key.equals(DATE_LT) ? "-1" : "");
			} else if (Func.isMySql() && key.equals(DATE_GT)) {
				value = "date_sub(#{" + value + "},interval +1 day)";//"'" + value + "'";
			} else if (Func.isMySql() && key.equals(DATE_LT)) {
				value = "date_sub(#{" + value + "},interval -1 day)";
			}
			return _keyWord.replace("?", value);
		}
		if(key.indexOf("like") > 0){
			return _keyWord.replace("?", " CONCAT(CONCAT('%', #{" + value + "}),'%')  ");
		}
		return _keyWord.replace("?", "#{" + value + "}");
	}

}


text:
"""
Parse Unix Shell syntax.
"""

import sys

class UnbalancedQuotes(Exception):
    pass

def split_shell_cmdline(cmdline, leave_quotes=0):
    """Given a string representing a shell command-line,
    split arguments into a list. Special chars like single-
    and double-quotes are honored. Can raise UnbalancedQutoes."""

    STATE_NORMAL = 0
    STATE_QUOTE = 1
    STATE_ESCAPE = 4
    STATE_WHITESPACE = 5

    argv = []
    states = []
    state = STATE_NORMAL
    current_arg = None
    qchar = None

    for c in cmdline:

        # First check for the whitespace state because we may
        # want to change state and keep on processing, instead of
        # looping to the next character.
        if state == STATE_WHITESPACE:
            if c == " " or c == "\t" or c == "\n":
                continue
            else:
                # Don't push state; we replace current state.
                state = STATE_NORMAL
                # fall through to next if-block.

        # If we're in a normal state, look for special characters
        # and for the comment hash mark, which we will use as the
        # cut-off point.
        if state == STATE_NORMAL:
#            print "NORMAL c=(%s)" % (c,)
            if c == "'" or c == '"' or c == '`':
                states.append(state)
                state = STATE_QUOTE
                qchar = c

                if leave_quotes or c == '`':
                    if current_arg == None:
                        current_arg = c
                    else:
                        current_arg += c

            elif c == '\\':
                states.append(state)
                state = STATE_ESCAPE

            elif c == "#":
                if leave_quotes and current_arg == None:
                    current_arg = c
                break

            elif c == " " or c == "\t" or c == "\n":
                if current_arg != None:
                    argv.append(current_arg)
#                    print "APPEND ARG (%s)" % (current_arg,)
                    current_arg = None

                # Don't push state; we replace current state.
                state = STATE_WHITESPACE

            else:
                if current_arg == None:
                    current_arg = c
                else:
                    current_arg += c

        # Nothing is special inside single quotes excpet another single quote.
        elif state == STATE_QUOTE:
#            print "QUOTE c=(%s)" % (c,)
            if c == qchar:
                try:
                    state = states.pop()
                except IndexError:
                    return cmdline

                if leave_quotes or c == '`':
                    if current_arg == None:
                        current_arg = c
                    else:
                        current_arg += c

            elif c == '\\':
                states.append(state)
                state = STATE_ESCAPE

            else:
                if current_arg == None:
                    current_arg = c
                else:
                    current_arg += c

        # The escape state lasts for only one character.
        # Just pop the old state.
        elif state == STATE_ESCAPE:
#            print "ESC c=(%s)" % (c,)
            if c in [ "r", "n" ]:
                c = '\\' + c

            if current_arg == None:
                current_arg = c
            else:
                current_arg += c

            try:
                state = states.pop()
#                print "CURRENT_ARG: (%s) state=%s" % (current_arg, state)
            except IndexError:
                return cmdline

        else:
            sys.exit("Text.split_shell_cmdline:state %s not expected" % (state,))

    if current_arg != None:
        argv.append(current_arg)

    return argv

def remove_trailing_comment(cmdline):
    """Given a command-line, removes any trailing comment. Returns
    the new command-line, whether there was a trailing comment or not.
    Honors quotes, but doesn't raise UnbalancedQuote as it just cares
    about trailing comments."""

    STATE_NORMAL = 0
    STATE_SINGLE_QUOTE = 1
    STATE_DOUBLE_QUOTE = 2
    STATE_BACKTICK = 3
    STATE_ESCAPE = 4

    states = []
    state = STATE_NORMAL
    num_chars_to_copy = 0

    for c in cmdline:
        # If we're in a normal state, look for special characters
        # and for the comment hash mark, which we will use as the
        # cut-off point.
        if state == STATE_NORMAL:
            if c == "'":
                states.append(state)
                state = STATE_SINGLE_QUOTE
            elif c == '"':
                states.append(state)
                state = STATE_DOUBLE_QUOTE
            elif c == '`':
                states.append(state)
                state = STATE_BACKTICK
            elif c == '\\':
                states.append(state)
                state = STATE_ESCAPE
            elif c == "#":
                break

        # Nothing is special inside single quotes excpet another single quote.
        elif state == STATE_SINGLE_QUOTE:
            if c == "'":
                try:
                    state = states.pop()
                except IndexError:
                    return cmdline

        # Inside double quotes, honor some things.
        elif state == STATE_DOUBLE_QUOTE:
            if c == '"':
                try:
                    state = states.pop()
                except IndexError:
                    return cmdline
            elif c == '\\':
                states.append(state)
                state = STATE_ESCAPE
            elif c == '`':
                states.append(state)
                state = STATE_BACKTICK

        # Backtick's basically act like the NORMAL state
        elif state == STATE_BACKTICK:
            if c == "'":
                states.append(state)
                state = STATE_SINGLE_QUOTE
            elif c == '"':
                states.append(state)
                state = STATE_DOUBLE_QUOTE
            elif c == '`':
                try:
                    state = states.pop()
                except IndexError:
                    return cmdline
            elif c == '\\':
                states.append(state)
                state = STATE_ESCAPE

        # The escape state lasts for only one character.
        # Just pop the old state.
        elif state == STATE_ESCAPE:
                try:
                    state = states.pop()
                except IndexError:
                    return cmdline

        else:
            sys.exit("Text.remove_trailing_comment:state %s not expected" % (state,))

        num_chars_to_copy += 1

    if states:
        return cmdline
    else:
        return cmdline[:num_chars_to_copy]

def _test():

    def _ssc_test(text):
        print "CMDLINE:", text
        print "RESULT :", split_shell_cmdline(text)
        print

    _ssc_test("gcc -o x.o x.c")
    _ssc_test("gcc -o 'hello world.o' 'hello world.c'")
    _ssc_test("gcc -o x.o 'hello \" \" world.c'")
    _ssc_test("gcc -o x.o hello\\ world.c")
    _ssc_test("gcc -o x.o `run this`")

if __name__ == '__main__':
    _test()


text:
"use strict";

import EndOfMultiLineCommentToken from "../../../../../token/nonSignificant/comment/multiLine/endOf";

export default class CStyleEndOfMultiLineCommentToken extends EndOfMultiLineCommentToken {
  clone(startPosition, endPosition) { return super.clone(CStyleEndOfMultiLineCommentToken, startPosition, endPosition); }

  static regularExpression = /^\*\//;

  static match(content) { return EndOfMultiLineCommentToken.match(CStyleEndOfMultiLineCommentToken, content); }

  static fromContent(content) { return EndOfMultiLineCommentToken.fromContent(CStyleEndOfMultiLineCommentToken, content); }
}


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package kroki.app.state;

import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;

/**
 * Interfejs predstavlja stanje u kojem se aplikacija nalazi. Deo je implementacije IState dizajn sablona.
 * @author Vladan Marsenić (vladan.marsenic@gmail.com)
 */
public interface IState {

    public void mouseDragged(MouseEvent e);

    public void mouseMoved(MouseEvent e);

    public void mouseWheelMoved(MouseWheelEvent e);

    public void mouseClicked(MouseEvent e);

    public void mouseEntered(MouseEvent e);

    public void mouseExited(MouseEvent e);

    public void mousePressed(MouseEvent e);

    public void mouseReleased(MouseEvent e);

    public void keyPressed(KeyEvent e);

    public void keyReleased(KeyEvent e);

    public void keyTyped(KeyEvent e);
}


text:
package io.opensec.oval.model.definitions;

import io.opensec.oval.model.common.CheckEnumeration;
import io.opensec.oval.model.common.DatatypeEnumeration;
import io.opensec.oval.model.common.OperationEnumeration;

/**
 * The EntityObjectIPAddressType type is extended by the entities
 * of an individual OVAL Object.
 * This type provides uniformity to each object entity by including
 * the attributes found in the EntitySimpleBaseType.
 * This specific type describes any IPv4/IPv6 address or address prefix.
 *
 * @author  Akihito Nakamura, AIST
 * @see OVAL Language
 */
public class EntityObjectIPAddressType
    extends EntitySimpleBaseType
{

	//datatype
    //{required}

    /**
     * Constructor.
     */
    public EntityObjectIPAddressType()
    {
    }

    public EntityObjectIPAddressType(
                    final String content
                    )
    {
        super( content );
    }

    public EntityObjectIPAddressType(
                    final DatatypeEnumeration datatype,
                    final OperationEnumeration operation,
                    final Boolean mask,
                    final String var_ref,
                    final CheckEnumeration var_check,
                    final String content
                    )
    {
        super( datatype, operation, mask, var_ref, var_check, content );
    }

    public EntityObjectIPAddressType(
                    final String datatype,
                    final String operation,
                    final Boolean mask,
                    final String var_ref,
                    final String var_check,
                    final String content
                    )
    {
        super( datatype, operation, mask, var_ref, var_check, content );
    }

    //**************************************************************
    //  EntityBase
    //**************************************************************

    @Override
    public void setDatatype(
                    final DatatypeEnumeration datatype
                    )
    {
        if (datatype != null) {
            if (datatype == DatatypeEnumeration.IPV4_ADDRESS
                            ||  datatype == DatatypeEnumeration.IPV6_ADDRESS
                            ) {
                // xsd:restriction satisfied.
            } else {
                throw new IllegalArgumentException( "invalid datatype: " + datatype);
            }
        }

        super.setDatatype( datatype );
    }

    //**************************************************************
    //  java.lang.Object
    //**************************************************************

    @Override
    public int hashCode()
    {
        return super.hashCode();
    }

    @Override
    public boolean equals(
                    final Object obj
                    )
    {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof EntityObjectIPAddressType)) {
            return false;
        }

        return super.equals( obj );
    }

//    @Override
//    public String toString()
//    {
//        return "[" + super.toString() + "]";
//    }

}
//


text:
package com.google.cloud.datacatalog.v1beta1.samples;

// [START datacatalog_v1beta1_generated_DataCatalog_UpdateTag_async]
import com.google.api.core.ApiFuture;
import com.google.cloud.datacatalog.v1beta1.DataCatalogClient;
import com.google.cloud.datacatalog.v1beta1.Tag;
import com.google.cloud.datacatalog.v1beta1.UpdateTagRequest;
import com.google.protobuf.FieldMask;

public class AsyncUpdateTag {

  public static void main(String[] args) throws Exception {
    asyncUpdateTag();
  }

  public static void asyncUpdateTag() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataCatalogClient dataCatalogClient = DataCatalogClient.create()) {
      UpdateTagRequest request =
          UpdateTagRequest.newBuilder()
              .setTag(Tag.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .build();
      ApiFuture<Tag> future = dataCatalogClient.updateTagCallable().futureCall(request);
      // Do something.
      Tag response = future.get();
    }
  }
}
// [END datacatalog_v1beta1_generated_DataCatalog_UpdateTag_async]


text:
namespace g{namespace Fuse{namespace Triggers{namespace Actions{struct ReleaseFocus;}}}}
namespace g{namespace Fuse{struct Node;}}

namespace g{
namespace Fuse{
namespace Triggers{
namespace Actions{

// public sealed class ReleaseFocus :85
// {
::g::Fuse::Triggers::Actions::TriggerAction_type* ReleaseFocus_typeof();
void ReleaseFocus__Perform_fn(ReleaseFocus* __this, ::g::Fuse::Node* target);

struct ReleaseFocus : ::g::Fuse::Triggers::Actions::TriggerAction
{
};
// }

}}}} // ::g::Fuse::Triggers::Actions


text:
<!DOCTYPE frameset SYSTEM "frameset.dtd">
<frameset>
    <predicate lemma="reappear">
        <note>
            Frames file for 'reappear' based on sentences in brown.
        </note>

        <roleset id="reappear.01" vncls="-" name="come to be visible, again">
            <roles>
                <role n="1"  descr="thing becoming visible"/>
            </roles>

            <example name="with temporal">
                <inflection person="ns" tense="past" aspect="perfect" voice="active" form="participle"/>
                <text>
                    After it had reappeared the next two nights, Jenks went to higher
                    headquarters and said: ``For three days now a German reconnaissance
                    plane has been over the city taking pictures.
                </text>
                <arg n="1"        >it</arg>
                <rel              >reappeared</rel>
                <arg n="m" f="TMP">the next two nights</arg>
            </example>

            <example name="with locative">
                <inflection person="third" tense="present" aspect="ns" voice="active" form="full"/>
                <text>
                    According to the myth, Old Order then vanishes at stage left and
                    reappears at extreme stage right, but Director Shuz skillfully
                    sidesteps the rather gooshey problem of stage effects by simply
                    having Miss Arapacis walk across the stage.
                </text>
                <arg n="m" f="ADV">According to the myth</arg>
                <arg n="1"        >Old Order</arg>
                <arg n="m" f="DIS">then</arg>
                <rel              >reappears</rel>
                <arg n="m" f="LOC">at extreme stage right</arg>
            </example>

            <example name="all kinds of adjuncts">
                <inflection person="ns" tense="past" aspect="ns" voice="active" form="full"/>
                <text>
                    The tradition reached its apex, perhaps, in the works of Thomas
                    Nelson Page toward the end of the century, and reappeared [*-1]
                    undiminished as late as 1934 in the best-selling novel So Red The
                    Rose, by Stark Young.
                </text>
                <arg n="1"        >The tradition</arg>
                <rel              >reappeared</rel>
                <arg n="m" f="PRD">[*-1] undiminished</arg>
                <arg n="m" f="TMP">as late as 1934</arg>
                <arg n="m" f="LOC">in the best-selling novel So Red The Rose, by
                    Stark Young
                </arg>
            </example>

            <note>
            </note>

        </roleset>
    </predicate>
</frameset>


text:
package me.zsj.interessant.api;

import io.reactivex.Flowable;
import me.zsj.interessant.model.Related;
import retrofit2.http.GET;
import retrofit2.http.Path;

/**
 * @author zsj
 */

public interface RelatedApi {

    @GET("v3/video/{id}/detail/related")
    Flowable<Related> related(@Path("id") int id);

}


text:
using DotCommon.Utility;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using Xunit;

namespace DotCommon.Test.Utility
{
    public class EnumUtilTest
    {
        [Fact]
        public void GetEnumItemsTest()
        {
            var dict1 = EnumUtil.GetEnumDescriptions<TestEnum>(true);
            Assert.Equal("TE1", dict1["1"]);
            Assert.Equal("这是E2", dict1["2"]);
            Assert.Equal("E3Test", dict1["3"]);
            Assert.Equal("E4", dict1["6"]);
            Assert.Equal("TE5", dict1["7"]);

            var dict2 = EnumUtil.GetEnumDescriptions<TestEnum>(false);
            Assert.Equal("TE1", dict2["E1"]);
            Assert.Equal("这是E2", dict2["E2"]);
            Assert.Equal("E3Test", dict2["E3"]);
            Assert.Equal("E4", dict2["E4"]);
            Assert.Equal("TE5", dict2["E5"]);
        }

        [Fact]
        public void GetEnumDescription()
        {
            var e1 = EnumUtil.GetEnumDescription(TestEnum.E1);
            var e2 = EnumUtil.GetEnumDescription(TestEnum.E2);
            var e3 = EnumUtil.GetEnumDescription(TestEnum.E3);
            var e4 = EnumUtil.GetEnumDescription(TestEnum.E4);
            var e5 = EnumUtil.GetEnumDescription(TestEnum.E5);
            Assert.Equal("TE1", e1);
            Assert.Equal("这是E2", e2);
            Assert.Equal("E3Test", e3);
            Assert.Equal("E4", e4);
            Assert.Equal("TE5", e5);

            var e21 = EnumUtil.GetEnumDescription(TestEnum2.E21);
            var e22 = EnumUtil.GetEnumDescription(TestEnum2.E22);

            Assert.Equal("E21", e21);
            Assert.Equal("E22", e22);
        }

        [Fact]
        public void ToStr_FromStr_Test()
        {
            Assert.Equal("E1", EnumUtil.GetName(TestEnum.E1));
            Assert.Equal("E2", EnumUtil.GetName(TestEnum.E2));

            Assert.Equal(TestEnum.E3, EnumUtil.ParseToEnum<TestEnum>("E3"));
            Assert.Equal(TestEnum.E4, EnumUtil.ParseToEnum<TestEnum>("E4"));

            Assert.Equal(5, EnumUtil.GetEnumLength<TestEnum>());

            var array = EnumUtil.GetValues<TestEnum>();
            Assert.Equal(5, array.Length);

            Assert.True(EnumUtil.IsDefined<TestEnum>(1));

        }

    }

    public enum TestEnum
    {
        [Description("TE1")]
        E1 = 1,
        [Description("这是E2")]
        E2,
        [Description("E3Test")]
        E3,
        E4 = 6,
        [Description("TE5")]
        E5

    }

    public enum TestEnum2
    {
        E21,
        E22
    }
}