int  (lua_State *L) {  
  ...       
  status = lua_pcall(L, n, m, h);  /* calls Lua */  
  ...     /* code 2 */  
}  

int k (lua_State *L, int status, lua_KContext ctx) {  
     ...  /* code 2 */  
   }  
     
   int  (lua_State *L) {  
     ...       
     return k(L, lua_pcall(L, n, m, h), ctx);  
   }  

int  (lua_State *L) {  
       ...       
       return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);  
     }  

int main (int argc, char **argv) {  
  int status, result;  
  lua_State *L = luaL_newstate();  /* create state */  
  if (L == NULL) {  
    l_message(argv[0], "cannot create state: not enough memory");  
    return EXIT_FAILURE;  
  }  
  lua_pushcfunction(L, &pmain);  /* to call 'pmain' in protected mode */  
  lua_pushinteger(L, argc);  /* 1st argument */  
  lua_pushlightuserdata(L, argv); /* 2nd argument */  
  status = lua_pcall(L, 2, 1, 0);  /* do the call */  
  result = lua_toboolean(L, -1);  /* get result */  
  report(L, status);  
  lua_close(L);  
  return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;  
}  

LUALIB_API lua_State *luaL_newstate (void) {  
  lua_State *L = lua_newstate(l_alloc, NULL);  
  if (L) lua_atpanic(L, &panic);  
  return L;  
}  

LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {  
  int i;  
  lua_State *L;  
  global_State *g;  
  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));  
  if (l == NULL) return NULL;  
  L = &l->l.l;  
  g = &l->g;  
  L->tt = LUA_TTHREAD;  
  g->currentwhite = bitmask(WHITE0BIT);  
  L->marked = luaC_white(g);  
  preinit_thread(L, g);  
  g->allgc = obj2gco(L);  /* by now, only object is the main thread */  
  L->next = NULL;  
  g->frealloc = f;  
  g->ud = ud;  
  g->mainthread = L;  
  g->seed = makeseed(L);  
  g->gcrunning = 0;  /* no GC while building state */  
  g->strt.size = g->strt.nuse = 0;  
  g->strt.hash = NULL;  
  setnilvalue(&g->l_registry);  
  g->panic = NULL;  
  g->version = NULL;  
  g->gcstate = GCSpause;  
  g->gckind = KGC_INC;  
  g->finobj = g->tobefnz = g->fixedgc = NULL;  
  g->survival = g->old = g->reallyold = NULL;  
  g->finobjsur = g->finobjold = g->finobjrold = NULL;  
  g->sweepgc = NULL;  
  g->gray = g->grayagain = NULL;  
  g->weak = g->ephemeron = g->allweak = g->protogray = NULL;  
  g->twups = NULL;  
  g->totalbytes = sizeof(LG);  
  g->GCdebt = 0;  
  setgcparam(g->gcpause, LUAI_GCPAUSE);  
  setgcparam(g->gcstepmul, LUAI_GCMUL);  
  g->gcstepsize = LUAI_GCSTEPSIZE;  
  setgcparam(g->genmajormul, LUAI_GENMAJORMUL);  
  g->genminormul = LUAI_GENMINORMUL;  
  for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;  
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {  
    /* memory allocation error: free partial state */  
    close_state(L);  
    L = NULL;  
  }  
  return L;  
}  

typedef struct LG {  
  LX l;  
  global_State g;  
} LG;  

typedef struct LX {  
  lu_byte extra_[LUA_EXTRASPACE];  
  lua_State l;  
} LX;  

typedef struct global_State {  
  lua_Alloc frealloc;  /* function to reallocate memory */  
  void *ud;         /* auxiliary data to 'frealloc' */  
  l_mem totalbytes;  /* number of bytes currently allocated - GCdebt */  
  l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */  
  lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */  
  stringtable strt;  /* hash table for strings */  
  TValue l_registry;  
  unsigned int seed;  /* randomized seed for hashes */  
  lu_byte currentwhite;  
  lu_byte gcstate;  /* state of garbage collector */  
  lu_byte gckind;  /* kind of GC running */  
  lu_byte genminormul;  /* control for minor generational collections */  
  lu_byte genmajormul;  /* control for major generational collections */  
  lu_byte gcrunning;  /* true if GC is running */  
  lu_byte gcemergency;  /* true if this is an emergency collection */  
  lu_byte gcpause;  /* size of pause between successive GCs */  
  lu_byte gcstepmul;  /* GC "speed" */  
  lu_byte gcstepsize;  /* (log2 of) GC granularity */  
  GCObject *allgc;  /* list of all collectable objects */  
  GCObject **sweepgc;  /* current position of sweep in list */  
  GCObject *finobj;  /* list of collectable objects with finalizers */  
  GCObject *gray;  /* list of gray objects */  
  GCObject *grayagain;  /* list of objects to be traversed atomically */  
  GCObject *weak;  /* list of tables with weak values */  
  GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */  
  GCObject *allweak;  /* list of all-weak tables */  
  GCObject *protogray;  /* list of prototypes with "new" caches */  
  GCObject *tobefnz;  /* list of userdata to be GC */  
  GCObject *fixedgc;  /* list of objects not to be collected */  
  /* fields for generational collector */  
  GCObject *survival;  /* start of objects that survived one GC cycle */  
  GCObject *old;  /* start of old objects */  
  GCObject *reallyold;  /* old objects with more than one cycle */  
  GCObject *finobjsur;  /* list of survival objects with finalizers */  
  GCObject *finobjold;  /* list of old objects with finalizers */  
  GCObject *finobjrold;  /* list of really old objects with finalizers */  
  struct lua_State *twups;  /* list of threads with open upvalues */  
  lua_CFunction panic;  /* to be called in unprotected errors */  
  struct lua_State *mainthread;  
  const lua_Number *version;  /* pointer to version number */  
  TString *nfield;  /* string "n" (key in vararg tables) */  
  TString *tmname[TM_N];  /* array with tag-method names */  
  struct Table *mt[LUA_NUMTAGS];  /* metatables for basic types */  
  TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */  
} global_State;  
  
struct lua_State {  
  CommonHeader;  
  unsigned short nci;  /* number of items in 'ci' list */  
  lu_byte status;  
  StkId top;  /* first free slot in the stack */  
  global_State *l_G;  
  CallInfo *ci;  /* call info for current function */  
  const Instruction *oldpc;  /* last pc traced */  
  StkId stack_last;  /* last free slot in the stack */  
  StkId stack;  /* stack base */  
  UpVal *openupval;  /* list of open upvalues in this stack */  
  GCObject *gclist;  
  struct lua_State *twups;  /* list of threads with open upvalues */  
  struct lua_longjmp *errorJmp;  /* current error recover point */  
  CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */  
  volatile lua_Hook hook;  
  ptrdiff_t errfunc;  /* current error handling function (stack index) */  
  int stacksize;  
  int basehookcount;  
  int hookcount;  
  unsigned short nny;  /* number of non-yieldable calls in stack */  
  unsigned short nCcalls;  /* number of nested C calls */  
  l_signalT hookmask;  
  lu_byte allowhook;  
};  

/*  
** open parts of the state that may cause memory-allocation errors.  
** ('g->version' != NULL flags that the state was completely build)  
*/  
static void f_luaopen (lua_State *L, void *ud) {  
  global_State *g = G(L);  
  UNUSED(ud);  
  stack_init(L, L);  /* init stack */  
  init_registry(L, g);  
  luaS_init(L);  
  luaT_init(L);  
  luaX_init(L);  
  g->gcrunning = 1;  /* allow gc */  
  g->gcemergency = 0;  
  g->version = lua_version(NULL);  
  luai_userstateopen(L);  
}  

 static void stack_init (lua_State *L1, lua_State *L) {  
  int i; CallInfo *ci;  
  /* initialize stack array */  
  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, StackValue);  
  L1->stacksize = BASIC_STACK_SIZE;  
  for (i = 0; i < BASIC_STACK_SIZE; i++)  
    setnilvalue(s2v(L1->stack + i));  /* erase new stack */  
  L1->top = L1->stack;  
  L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;  
  /* initialize first ci */  
  ci = &L1->base_ci;  
  ci->next = ci->previous = NULL;  
  ci->callstatus = CIST_C;  
  ci->func = L1->top;  
  setnilvalue(s2v(L1->top));  /* 'function' entry for this 'ci' */  
  L1->top++;  
  ci->top = L1->top + LUA_MINSTACK;  
  L1->ci = ci;  
}  

lmem.h:  

L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, StackValue);  

lua_newstate(l_alloc, NULL);  

static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {  
  (void)ud; (void)osize;  /* not used */  
  if (nsize == 0) {  
    free(ptr);  
    return NULL;  
  }  
  else  
    return realloc(ptr, nsize);  
}  

void luaS_init (lua_State *L) {  
  global_State *g = G(L);  
  int i, j;  
  TString *memerrmsg;  
  stringtable *tb = &G(L)