lua

A copy of the Lua development repository
Log | Files | Refs | README

lstate.c (11041B)

      1 /*
      2 ** $Id: lstate.c $
      3 ** Global State
      4 ** See Copyright Notice in lua.h
      5 */
      6 
      7 #define lstate_c
      8 #define LUA_CORE
      9 
     10 #include "lprefix.h"
     11 
     12 
     13 #include <stddef.h>
     14 #include <string.h>
     15 
     16 #include "lua.h"
     17 
     18 #include "lapi.h"
     19 #include "ldebug.h"
     20 #include "ldo.h"
     21 #include "lfunc.h"
     22 #include "lgc.h"
     23 #include "llex.h"
     24 #include "lmem.h"
     25 #include "lstate.h"
     26 #include "lstring.h"
     27 #include "ltable.h"
     28 #include "ltm.h"
     29 
     30 
     31 
     32 #define fromstate(L)	(cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
     33 
     34 
     35 /*
     36 ** these macros allow user-specific actions when a thread is
     37 ** created/deleted
     38 */
     39 #if !defined(luai_userstateopen)
     40 #define luai_userstateopen(L)		((void)L)
     41 #endif
     42 
     43 #if !defined(luai_userstateclose)
     44 #define luai_userstateclose(L)		((void)L)
     45 #endif
     46 
     47 #if !defined(luai_userstatethread)
     48 #define luai_userstatethread(L,L1)	((void)L)
     49 #endif
     50 
     51 #if !defined(luai_userstatefree)
     52 #define luai_userstatefree(L,L1)	((void)L)
     53 #endif
     54 
     55 
     56 /*
     57 ** set GCdebt to a new value keeping the real number of allocated
     58 ** objects (GCtotalobjs - GCdebt) invariant and avoiding overflows in
     59 ** 'GCtotalobjs'.
     60 */
     61 void luaE_setdebt (global_State *g, l_mem debt) {
     62   l_mem tb = gettotalbytes(g);
     63   lua_assert(tb > 0);
     64   if (debt > MAX_LMEM - tb)
     65     debt = MAX_LMEM - tb;  /* will make GCtotalbytes == MAX_LMEM */
     66   g->GCtotalbytes = tb + debt;
     67   g->GCdebt = debt;
     68 }
     69 
     70 
     71 CallInfo *luaE_extendCI (lua_State *L) {
     72   CallInfo *ci;
     73   lua_assert(L->ci->next == NULL);
     74   ci = luaM_new(L, CallInfo);
     75   lua_assert(L->ci->next == NULL);
     76   L->ci->next = ci;
     77   ci->previous = L->ci;
     78   ci->next = NULL;
     79   ci->u.l.trap = 0;
     80   L->nci++;
     81   return ci;
     82 }
     83 
     84 
     85 /*
     86 ** free all CallInfo structures not in use by a thread
     87 */
     88 static void freeCI (lua_State *L) {
     89   CallInfo *ci = L->ci;
     90   CallInfo *next = ci->next;
     91   ci->next = NULL;
     92   while ((ci = next) != NULL) {
     93     next = ci->next;
     94     luaM_free(L, ci);
     95     L->nci--;
     96   }
     97 }
     98 
     99 
    100 /*
    101 ** free half of the CallInfo structures not in use by a thread,
    102 ** keeping the first one.
    103 */
    104 void luaE_shrinkCI (lua_State *L) {
    105   CallInfo *ci = L->ci->next;  /* first free CallInfo */
    106   CallInfo *next;
    107   if (ci == NULL)
    108     return;  /* no extra elements */
    109   while ((next = ci->next) != NULL) {  /* two extra elements? */
    110     CallInfo *next2 = next->next;  /* next's next */
    111     ci->next = next2;  /* remove next from the list */
    112     L->nci--;
    113     luaM_free(L, next);  /* free next */
    114     if (next2 == NULL)
    115       break;  /* no more elements */
    116     else {
    117       next2->previous = ci;
    118       ci = next2;  /* continue */
    119     }
    120   }
    121 }
    122 
    123 
    124 /*
    125 ** Called when 'getCcalls(L)' larger or equal to LUAI_MAXCCALLS.
    126 ** If equal, raises an overflow error. If value is larger than
    127 ** LUAI_MAXCCALLS (which means it is handling an overflow) but
    128 ** not much larger, does not report an error (to allow overflow
    129 ** handling to work).
    130 */
    131 void luaE_checkcstack (lua_State *L) {
    132   if (getCcalls(L) == LUAI_MAXCCALLS)
    133     luaG_runerror(L, "C stack overflow");
    134   else if (getCcalls(L) >= (LUAI_MAXCCALLS / 10 * 11))
    135     luaD_throw(L, LUA_ERRERR);  /* error while handling stack error */
    136 }
    137 
    138 
    139 LUAI_FUNC void luaE_incCstack (lua_State *L) {
    140   L->nCcalls++;
    141   if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS))
    142     luaE_checkcstack(L);
    143 }
    144 
    145 
    146 static void stack_init (lua_State *L1, lua_State *L) {
    147   int i; CallInfo *ci;
    148   /* initialize stack array */
    149   L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue);
    150   L1->tbclist.p = L1->stack.p;
    151   for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++)
    152     setnilvalue(s2v(L1->stack.p + i));  /* erase new stack */
    153   L1->top.p = L1->stack.p;
    154   L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE;
    155   /* initialize first ci */
    156   ci = &L1->base_ci;
    157   ci->next = ci->previous = NULL;
    158   ci->callstatus = CIST_C;
    159   ci->func.p = L1->top.p;
    160   ci->u.c.k = NULL;
    161   setnilvalue(s2v(L1->top.p));  /* 'function' entry for this 'ci' */
    162   L1->top.p++;
    163   ci->top.p = L1->top.p + LUA_MINSTACK;
    164   L1->ci = ci;
    165 }
    166 
    167 
    168 static void freestack (lua_State *L) {
    169   if (L->stack.p == NULL)
    170     return;  /* stack not completely built yet */
    171   L->ci = &L->base_ci;  /* free the entire 'ci' list */
    172   freeCI(L);
    173   lua_assert(L->nci == 0);
    174   /* free stack */
    175   luaM_freearray(L, L->stack.p, cast_sizet(stacksize(L) + EXTRA_STACK));
    176 }
    177 
    178 
    179 /*
    180 ** Create registry table and its predefined values
    181 */
    182 static void init_registry (lua_State *L, global_State *g) {
    183   /* create registry */
    184   TValue aux;
    185   Table *registry = luaH_new(L);
    186   sethvalue(L, &g->l_registry, registry);
    187   luaH_resize(L, registry, LUA_RIDX_LAST, 0);
    188   /* registry[1] = false */
    189   setbfvalue(&aux);
    190   luaH_setint(L, registry, 1, &aux);
    191   /* registry[LUA_RIDX_MAINTHREAD] = L */
    192   setthvalue(L, &aux, L);
    193   luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &aux);
    194   /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */
    195   sethvalue(L, &aux, luaH_new(L));
    196   luaH_setint(L, registry, LUA_RIDX_GLOBALS, &aux);
    197 }
    198 
    199 
    200 /*
    201 ** open parts of the state that may cause memory-allocation errors.
    202 */
    203 static void f_luaopen (lua_State *L, void *ud) {
    204   global_State *g = G(L);
    205   UNUSED(ud);
    206   stack_init(L, L);  /* init stack */
    207   init_registry(L, g);
    208   luaS_init(L);
    209   luaT_init(L);
    210   luaX_init(L);
    211   g->gcstp = 0;  /* allow gc */
    212   setnilvalue(&g->nilvalue);  /* now state is complete */
    213   luai_userstateopen(L);
    214 }
    215 
    216 
    217 /*
    218 ** preinitialize a thread with consistent values without allocating
    219 ** any memory (to avoid errors)
    220 */
    221 static void preinit_thread (lua_State *L, global_State *g) {
    222   G(L) = g;
    223   L->stack.p = NULL;
    224   L->ci = NULL;
    225   L->nci = 0;
    226   L->twups = L;  /* thread has no upvalues */
    227   L->nCcalls = 0;
    228   L->errorJmp = NULL;
    229   L->hook = NULL;
    230   L->hookmask = 0;
    231   L->basehookcount = 0;
    232   L->allowhook = 1;
    233   resethookcount(L);
    234   L->openupval = NULL;
    235   L->status = LUA_OK;
    236   L->errfunc = 0;
    237   L->oldpc = 0;
    238 }
    239 
    240 
    241 lu_mem luaE_threadsize (lua_State *L) {
    242   lu_mem sz = cast(lu_mem, sizeof(LX))
    243             + cast_uint(L->nci) * sizeof(CallInfo);
    244   if (L->stack.p != NULL)
    245     sz += cast_uint(stacksize(L) + EXTRA_STACK) * sizeof(StackValue);
    246   return sz;
    247 }
    248 
    249 
    250 static void close_state (lua_State *L) {
    251   global_State *g = G(L);
    252   if (!completestate(g))  /* closing a partially built state? */
    253     luaC_freeallobjects(L);  /* just collect its objects */
    254   else {  /* closing a fully built state */
    255     L->ci = &L->base_ci;  /* unwind CallInfo list */
    256     luaD_closeprotected(L, 1, LUA_OK);  /* close all upvalues */
    257     luaC_freeallobjects(L);  /* collect all objects */
    258     luai_userstateclose(L);
    259   }
    260   luaM_freearray(L, G(L)->strt.hash, cast_sizet(G(L)->strt.size));
    261   freestack(L);
    262   lua_assert(gettotalbytes(g) == sizeof(global_State));
    263   (*g->frealloc)(g->ud, g, sizeof(global_State), 0);  /* free main block */
    264 }
    265 
    266 
    267 LUA_API lua_State *lua_newthread (lua_State *L) {
    268   global_State *g = G(L);
    269   GCObject *o;
    270   lua_State *L1;
    271   lua_lock(L);
    272   luaC_checkGC(L);
    273   /* create new thread */
    274   o = luaC_newobjdt(L, LUA_TTHREAD, sizeof(LX), offsetof(LX, l));
    275   L1 = gco2th(o);
    276   /* anchor it on L stack */
    277   setthvalue2s(L, L->top.p, L1);
    278   api_incr_top(L);
    279   preinit_thread(L1, g);
    280   L1->hookmask = L->hookmask;
    281   L1->basehookcount = L->basehookcount;
    282   L1->hook = L->hook;
    283   resethookcount(L1);
    284   /* initialize L1 extra space */
    285   memcpy(lua_getextraspace(L1), lua_getextraspace(mainthread(g)),
    286          LUA_EXTRASPACE);
    287   luai_userstatethread(L, L1);
    288   stack_init(L1, L);  /* init stack */
    289   lua_unlock(L);
    290   return L1;
    291 }
    292 
    293 
    294 void luaE_freethread (lua_State *L, lua_State *L1) {
    295   LX *l = fromstate(L1);
    296   luaF_closeupval(L1, L1->stack.p);  /* close all upvalues */
    297   lua_assert(L1->openupval == NULL);
    298   luai_userstatefree(L, L1);
    299   freestack(L1);
    300   luaM_free(L, l);
    301 }
    302 
    303 
    304 TStatus luaE_resetthread (lua_State *L, TStatus status) {
    305   CallInfo *ci = L->ci = &L->base_ci;  /* unwind CallInfo list */
    306   setnilvalue(s2v(L->stack.p));  /* 'function' entry for basic 'ci' */
    307   ci->func.p = L->stack.p;
    308   ci->callstatus = CIST_C;
    309   if (status == LUA_YIELD)
    310     status = LUA_OK;
    311   L->status = LUA_OK;  /* so it can run __close metamethods */
    312   status = luaD_closeprotected(L, 1, status);
    313   if (status != LUA_OK)  /* errors? */
    314     luaD_seterrorobj(L, status, L->stack.p + 1);
    315   else
    316     L->top.p = L->stack.p + 1;
    317   ci->top.p = L->top.p + LUA_MINSTACK;
    318   luaD_reallocstack(L, cast_int(ci->top.p - L->stack.p), 0);
    319   return status;
    320 }
    321 
    322 
    323 LUA_API int lua_closethread (lua_State *L, lua_State *from) {
    324   TStatus status;
    325   lua_lock(L);
    326   L->nCcalls = (from) ? getCcalls(from) : 0;
    327   status = luaE_resetthread(L, L->status);
    328   lua_unlock(L);
    329   return APIstatus(status);
    330 }
    331 
    332 
    333 LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud, unsigned seed) {
    334   int i;
    335   lua_State *L;
    336   global_State *g = cast(global_State*,
    337                        (*f)(ud, NULL, LUA_TTHREAD, sizeof(global_State)));
    338   if (g == NULL) return NULL;
    339   L = &g->mainth.l;
    340   L->tt = LUA_VTHREAD;
    341   g->currentwhite = bitmask(WHITE0BIT);
    342   L->marked = luaC_white(g);
    343   preinit_thread(L, g);
    344   g->allgc = obj2gco(L);  /* by now, only object is the main thread */
    345   L->next = NULL;
    346   incnny(L);  /* main thread is always non yieldable */
    347   g->frealloc = f;
    348   g->ud = ud;
    349   g->warnf = NULL;
    350   g->ud_warn = NULL;
    351   g->seed = seed;
    352   g->gcstp = GCSTPGC;  /* no GC while building state */
    353   g->strt.size = g->strt.nuse = 0;
    354   g->strt.hash = NULL;
    355   setnilvalue(&g->l_registry);
    356   g->panic = NULL;
    357   g->gcstate = GCSpause;
    358   g->gckind = KGC_INC;
    359   g->gcstopem = 0;
    360   g->gcemergency = 0;
    361   g->finobj = g->tobefnz = g->fixedgc = NULL;
    362   g->firstold1 = g->survival = g->old1 = g->reallyold = NULL;
    363   g->finobjsur = g->finobjold1 = g->finobjrold = NULL;
    364   g->sweepgc = NULL;
    365   g->gray = g->grayagain = NULL;
    366   g->weak = g->ephemeron = g->allweak = NULL;
    367   g->twups = NULL;
    368   g->GCtotalbytes = sizeof(global_State);
    369   g->GCmarked = 0;
    370   g->GCdebt = 0;
    371   setivalue(&g->nilvalue, 0);  /* to signal that state is not yet built */
    372   setgcparam(g, PAUSE, LUAI_GCPAUSE);
    373   setgcparam(g, STEPMUL, LUAI_GCMUL);
    374   setgcparam(g, STEPSIZE, LUAI_GCSTEPSIZE);
    375   setgcparam(g, MINORMUL, LUAI_GENMINORMUL);
    376   setgcparam(g, MINORMAJOR, LUAI_MINORMAJOR);
    377   setgcparam(g, MAJORMINOR, LUAI_MAJORMINOR);
    378   for (i=0; i < LUA_NUMTYPES; i++) g->mt[i] = NULL;
    379   if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
    380     /* memory allocation error: free partial state */
    381     close_state(L);
    382     L = NULL;
    383   }
    384   return L;
    385 }
    386 
    387 
    388 LUA_API void lua_close (lua_State *L) {
    389   lua_lock(L);
    390   L = mainthread(G(L));  /* only the main thread can be closed */
    391   close_state(L);
    392 }
    393 
    394 
    395 void luaE_warning (lua_State *L, const char *msg, int tocont) {
    396   lua_WarnFunction wf = G(L)->warnf;
    397   if (wf != NULL)
    398     wf(G(L)->ud_warn, msg, tocont);
    399 }
    400 
    401 
    402 /*
    403 ** Generate a warning from an error message
    404 */
    405 void luaE_warnerror (lua_State *L, const char *where) {
    406   TValue *errobj = s2v(L->top.p - 1);  /* error object */
    407   const char *msg = (ttisstring(errobj))
    408                   ? getstr(tsvalue(errobj))
    409                   : "error object is not a string";
    410   /* produce warning "error in %s (%s)" (where, msg) */
    411   luaE_warning(L, "error in ", 1);
    412   luaE_warning(L, where, 1);
    413   luaE_warning(L, " (", 1);
    414   luaE_warning(L, msg, 1);
    415   luaE_warning(L, ")", 0);
    416 }
    417