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