OLD | NEW |
(Empty) | |
| 1 /* |
| 2 ** $Id: lstate.c,v 2.99 2012/10/02 17:40:53 roberto Exp $ |
| 3 ** Global State |
| 4 ** See Copyright Notice in lua.h |
| 5 */ |
| 6 |
| 7 |
| 8 #include <stddef.h> |
| 9 #include <string.h> |
| 10 |
| 11 #define lstate_c |
| 12 #define LUA_CORE |
| 13 |
| 14 #include "lua.h" |
| 15 |
| 16 #include "lapi.h" |
| 17 #include "ldebug.h" |
| 18 #include "ldo.h" |
| 19 #include "lfunc.h" |
| 20 #include "lgc.h" |
| 21 #include "llex.h" |
| 22 #include "lmem.h" |
| 23 #include "lstate.h" |
| 24 #include "lstring.h" |
| 25 #include "ltable.h" |
| 26 #include "ltm.h" |
| 27 |
| 28 |
| 29 #if !defined(LUAI_GCPAUSE) |
| 30 #define LUAI_GCPAUSE 200 /* 200% */ |
| 31 #endif |
| 32 |
| 33 #if !defined(LUAI_GCMAJOR) |
| 34 #define LUAI_GCMAJOR 200 /* 200% */ |
| 35 #endif |
| 36 |
| 37 #if !defined(LUAI_GCMUL) |
| 38 #define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ |
| 39 #endif |
| 40 |
| 41 |
| 42 #define MEMERRMSG "not enough memory" |
| 43 |
| 44 |
| 45 /* |
| 46 ** a macro to help the creation of a unique random seed when a state is |
| 47 ** created; the seed is used to randomize hashes. |
| 48 */ |
| 49 #if !defined(luai_makeseed) |
| 50 #include <time.h> |
| 51 #define luai_makeseed() cast(unsigned int, time(NULL)) |
| 52 #endif |
| 53 |
| 54 |
| 55 |
| 56 /* |
| 57 ** thread state + extra space |
| 58 */ |
| 59 typedef struct LX { |
| 60 #if defined(LUAI_EXTRASPACE) |
| 61 char buff[LUAI_EXTRASPACE]; |
| 62 #endif |
| 63 lua_State l; |
| 64 } LX; |
| 65 |
| 66 |
| 67 /* |
| 68 ** Main thread combines a thread state and the global state |
| 69 */ |
| 70 typedef struct LG { |
| 71 LX l; |
| 72 global_State g; |
| 73 } LG; |
| 74 |
| 75 |
| 76 |
| 77 #define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) |
| 78 |
| 79 |
| 80 /* |
| 81 ** Compute an initial seed as random as possible. In ANSI, rely on |
| 82 ** Address Space Layout Randomization (if present) to increase |
| 83 ** randomness.. |
| 84 */ |
| 85 #define addbuff(b,p,e) \ |
| 86 { size_t t = cast(size_t, e); \ |
| 87 memcpy(buff + p, &t, sizeof(t)); p += sizeof(t); } |
| 88 |
| 89 static unsigned int makeseed (lua_State *L) { |
| 90 char buff[4 * sizeof(size_t)]; |
| 91 unsigned int h = luai_makeseed(); |
| 92 int p = 0; |
| 93 addbuff(buff, p, L); /* heap variable */ |
| 94 addbuff(buff, p, &h); /* local variable */ |
| 95 addbuff(buff, p, luaO_nilobject); /* global variable */ |
| 96 addbuff(buff, p, &lua_newstate); /* public function */ |
| 97 lua_assert(p == sizeof(buff)); |
| 98 return luaS_hash(buff, p, h); |
| 99 } |
| 100 |
| 101 |
| 102 /* |
| 103 ** set GCdebt to a new value keeping the value (totalbytes + GCdebt) |
| 104 ** invariant |
| 105 */ |
| 106 void luaE_setdebt (global_State *g, l_mem debt) { |
| 107 g->totalbytes -= (debt - g->GCdebt); |
| 108 g->GCdebt = debt; |
| 109 } |
| 110 |
| 111 |
| 112 CallInfo *luaE_extendCI (lua_State *L) { |
| 113 CallInfo *ci = luaM_new(L, CallInfo); |
| 114 lua_assert(L->ci->next == NULL); |
| 115 L->ci->next = ci; |
| 116 ci->previous = L->ci; |
| 117 ci->next = NULL; |
| 118 return ci; |
| 119 } |
| 120 |
| 121 |
| 122 void luaE_freeCI (lua_State *L) { |
| 123 CallInfo *ci = L->ci; |
| 124 CallInfo *next = ci->next; |
| 125 ci->next = NULL; |
| 126 while ((ci = next) != NULL) { |
| 127 next = ci->next; |
| 128 luaM_free(L, ci); |
| 129 } |
| 130 } |
| 131 |
| 132 |
| 133 static void stack_init (lua_State *L1, lua_State *L) { |
| 134 int i; CallInfo *ci; |
| 135 /* initialize stack array */ |
| 136 L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue); |
| 137 L1->stacksize = BASIC_STACK_SIZE; |
| 138 for (i = 0; i < BASIC_STACK_SIZE; i++) |
| 139 setnilvalue(L1->stack + i); /* erase new stack */ |
| 140 L1->top = L1->stack; |
| 141 L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK; |
| 142 /* initialize first ci */ |
| 143 ci = &L1->base_ci; |
| 144 ci->next = ci->previous = NULL; |
| 145 ci->callstatus = 0; |
| 146 ci->func = L1->top; |
| 147 setnilvalue(L1->top++); /* 'function' entry for this 'ci' */ |
| 148 ci->top = L1->top + LUA_MINSTACK; |
| 149 L1->ci = ci; |
| 150 } |
| 151 |
| 152 |
| 153 static void freestack (lua_State *L) { |
| 154 if (L->stack == NULL) |
| 155 return; /* stack not completely built yet */ |
| 156 L->ci = &L->base_ci; /* free the entire 'ci' list */ |
| 157 luaE_freeCI(L); |
| 158 luaM_freearray(L, L->stack, L->stacksize); /* free stack array */ |
| 159 } |
| 160 |
| 161 |
| 162 /* |
| 163 ** Create registry table and its predefined values |
| 164 */ |
| 165 static void init_registry (lua_State *L, global_State *g) { |
| 166 TValue mt; |
| 167 /* create registry */ |
| 168 Table *registry = luaH_new(L); |
| 169 sethvalue(L, &g->l_registry, registry); |
| 170 luaH_resize(L, registry, LUA_RIDX_LAST, 0); |
| 171 /* registry[LUA_RIDX_MAINTHREAD] = L */ |
| 172 setthvalue(L, &mt, L); |
| 173 luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt); |
| 174 /* registry[LUA_RIDX_GLOBALS] = table of globals */ |
| 175 sethvalue(L, &mt, luaH_new(L)); |
| 176 luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt); |
| 177 } |
| 178 |
| 179 |
| 180 /* |
| 181 ** open parts of the state that may cause memory-allocation errors |
| 182 */ |
| 183 static void f_luaopen (lua_State *L, void *ud) { |
| 184 global_State *g = G(L); |
| 185 UNUSED(ud); |
| 186 stack_init(L, L); /* init stack */ |
| 187 init_registry(L, g); |
| 188 luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ |
| 189 luaT_init(L); |
| 190 luaX_init(L); |
| 191 /* pre-create memory-error message */ |
| 192 g->memerrmsg = luaS_newliteral(L, MEMERRMSG); |
| 193 luaS_fix(g->memerrmsg); /* it should never be collected */ |
| 194 g->gcrunning = 1; /* allow gc */ |
| 195 } |
| 196 |
| 197 |
| 198 /* |
| 199 ** preinitialize a state with consistent values without allocating |
| 200 ** any memory (to avoid errors) |
| 201 */ |
| 202 static void preinit_state (lua_State *L, global_State *g) { |
| 203 G(L) = g; |
| 204 L->stack = NULL; |
| 205 L->ci = NULL; |
| 206 L->stacksize = 0; |
| 207 L->errorJmp = NULL; |
| 208 L->nCcalls = 0; |
| 209 L->hook = NULL; |
| 210 L->hookmask = 0; |
| 211 L->basehookcount = 0; |
| 212 L->allowhook = 1; |
| 213 resethookcount(L); |
| 214 L->openupval = NULL; |
| 215 L->nny = 1; |
| 216 L->status = LUA_OK; |
| 217 L->errfunc = 0; |
| 218 } |
| 219 |
| 220 |
| 221 static void close_state (lua_State *L) { |
| 222 global_State *g = G(L); |
| 223 luaF_close(L, L->stack); /* close all upvalues for this thread */ |
| 224 luaC_freeallobjects(L); /* collect all objects */ |
| 225 luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); |
| 226 luaZ_freebuffer(L, &g->buff); |
| 227 freestack(L); |
| 228 lua_assert(gettotalbytes(g) == sizeof(LG)); |
| 229 (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ |
| 230 } |
| 231 |
| 232 |
| 233 LUA_API lua_State *lua_newthread (lua_State *L) { |
| 234 lua_State *L1; |
| 235 lua_lock(L); |
| 236 luaC_checkGC(L); |
| 237 L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th; |
| 238 setthvalue(L, L->top, L1); |
| 239 api_incr_top(L); |
| 240 preinit_state(L1, G(L)); |
| 241 L1->hookmask = L->hookmask; |
| 242 L1->basehookcount = L->basehookcount; |
| 243 L1->hook = L->hook; |
| 244 resethookcount(L1); |
| 245 luai_userstatethread(L, L1); |
| 246 stack_init(L1, L); /* init stack */ |
| 247 lua_unlock(L); |
| 248 return L1; |
| 249 } |
| 250 |
| 251 |
| 252 void luaE_freethread (lua_State *L, lua_State *L1) { |
| 253 LX *l = fromstate(L1); |
| 254 luaF_close(L1, L1->stack); /* close all upvalues for this thread */ |
| 255 lua_assert(L1->openupval == NULL); |
| 256 luai_userstatefree(L, L1); |
| 257 freestack(L1); |
| 258 luaM_free(L, l); |
| 259 } |
| 260 |
| 261 |
| 262 LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { |
| 263 int i; |
| 264 lua_State *L; |
| 265 global_State *g; |
| 266 LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); |
| 267 if (l == NULL) return NULL; |
| 268 L = &l->l.l; |
| 269 g = &l->g; |
| 270 L->next = NULL; |
| 271 L->tt = LUA_TTHREAD; |
| 272 g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT); |
| 273 L->marked = luaC_white(g); |
| 274 g->gckind = KGC_NORMAL; |
| 275 preinit_state(L, g); |
| 276 g->frealloc = f; |
| 277 g->ud = ud; |
| 278 g->mainthread = L; |
| 279 g->seed = makeseed(L); |
| 280 g->uvhead.u.l.prev = &g->uvhead; |
| 281 g->uvhead.u.l.next = &g->uvhead; |
| 282 g->gcrunning = 0; /* no GC while building state */ |
| 283 g->GCestimate = 0; |
| 284 g->strt.size = 0; |
| 285 g->strt.nuse = 0; |
| 286 g->strt.hash = NULL; |
| 287 setnilvalue(&g->l_registry); |
| 288 luaZ_initbuffer(L, &g->buff); |
| 289 g->panic = NULL; |
| 290 g->version = lua_version(NULL); |
| 291 g->gcstate = GCSpause; |
| 292 g->allgc = NULL; |
| 293 g->finobj = NULL; |
| 294 g->tobefnz = NULL; |
| 295 g->sweepgc = g->sweepfin = NULL; |
| 296 g->gray = g->grayagain = NULL; |
| 297 g->weak = g->ephemeron = g->allweak = NULL; |
| 298 g->totalbytes = sizeof(LG); |
| 299 g->GCdebt = 0; |
| 300 g->gcpause = LUAI_GCPAUSE; |
| 301 g->gcmajorinc = LUAI_GCMAJOR; |
| 302 g->gcstepmul = LUAI_GCMUL; |
| 303 for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; |
| 304 if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { |
| 305 /* memory allocation error: free partial state */ |
| 306 close_state(L); |
| 307 L = NULL; |
| 308 } |
| 309 else |
| 310 luai_userstateopen(L); |
| 311 return L; |
| 312 } |
| 313 |
| 314 |
| 315 LUA_API void lua_close (lua_State *L) { |
| 316 L = G(L)->mainthread; /* only the main thread can be closed */ |
| 317 lua_lock(L); |
| 318 luai_userstateclose(L); |
| 319 close_state(L); |
| 320 } |
| 321 |
| 322 |
OLD | NEW |