diff options
Diffstat (limited to 'apps/plugins/lua/lstate.c')
-rw-r--r-- | apps/plugins/lua/lstate.c | 273 |
1 files changed, 191 insertions, 82 deletions
diff --git a/apps/plugins/lua/lstate.c b/apps/plugins/lua/lstate.c index 4313b83a0c..c7f2672be7 100644 --- a/apps/plugins/lua/lstate.c +++ b/apps/plugins/lua/lstate.c | |||
@@ -1,17 +1,19 @@ | |||
1 | /* | 1 | /* |
2 | ** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $ | 2 | ** $Id: lstate.c,v 2.99.1.2 2013/11/08 17:45:31 roberto Exp $ |
3 | ** Global State | 3 | ** Global State |
4 | ** See Copyright Notice in lua.h | 4 | ** See Copyright Notice in lua.h |
5 | */ | 5 | */ |
6 | 6 | ||
7 | 7 | ||
8 | #include <stddef.h> | 8 | #include <stddef.h> |
9 | #include <string.h> | ||
9 | 10 | ||
10 | #define lstate_c | 11 | #define lstate_c |
11 | #define LUA_CORE | 12 | #define LUA_CORE |
12 | 13 | ||
13 | #include "lua.h" | 14 | #include "lua.h" |
14 | 15 | ||
16 | #include "lapi.h" | ||
15 | #include "ldebug.h" | 17 | #include "ldebug.h" |
16 | #include "ldo.h" | 18 | #include "ldo.h" |
17 | #include "lfunc.h" | 19 | #include "lfunc.h" |
@@ -24,119 +26,240 @@ | |||
24 | #include "ltm.h" | 26 | #include "ltm.h" |
25 | 27 | ||
26 | 28 | ||
27 | #define state_size(x) (sizeof(x) + LUAI_EXTRASPACE) | 29 | #if !defined(LUAI_GCPAUSE) |
28 | #define fromstate(l) (cast(lu_byte *, (l)) - LUAI_EXTRASPACE) | 30 | #define LUAI_GCPAUSE 200 /* 200% */ |
29 | #define tostate(l) (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE)) | 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; | ||
30 | 65 | ||
31 | 66 | ||
32 | /* | 67 | /* |
33 | ** Main thread combines a thread state and the global state | 68 | ** Main thread combines a thread state and the global state |
34 | */ | 69 | */ |
35 | typedef struct LG { | 70 | typedef struct LG { |
36 | lua_State l; | 71 | LX l; |
37 | global_State g; | 72 | global_State g; |
38 | } LG; | 73 | } LG; |
39 | 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 | } | ||
40 | 131 | ||
41 | 132 | ||
42 | static void stack_init (lua_State *L1, lua_State *L) { | 133 | static void stack_init (lua_State *L1, lua_State *L) { |
43 | /* initialize CallInfo array */ | 134 | int i; CallInfo *ci; |
44 | L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo); | ||
45 | L1->ci = L1->base_ci; | ||
46 | L1->size_ci = BASIC_CI_SIZE; | ||
47 | L1->end_ci = L1->base_ci + L1->size_ci - 1; | ||
48 | /* initialize stack array */ | 135 | /* initialize stack array */ |
49 | L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue); | 136 | L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue); |
50 | L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK; | 137 | L1->stacksize = BASIC_STACK_SIZE; |
138 | for (i = 0; i < BASIC_STACK_SIZE; i++) | ||
139 | setnilvalue(L1->stack + i); /* erase new stack */ | ||
51 | L1->top = L1->stack; | 140 | L1->top = L1->stack; |
52 | L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1; | 141 | L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK; |
53 | /* initialize first ci */ | 142 | /* initialize first ci */ |
54 | L1->ci->func = L1->top; | 143 | ci = &L1->base_ci; |
55 | setnilvalue(L1->top++); /* `function' entry for this `ci' */ | 144 | ci->next = ci->previous = NULL; |
56 | L1->base = L1->ci->base = L1->top; | 145 | ci->callstatus = 0; |
57 | L1->ci->top = L1->top + LUA_MINSTACK; | 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 */ | ||
58 | } | 159 | } |
59 | 160 | ||
60 | 161 | ||
61 | static void freestack (lua_State *L, lua_State *L1) { | 162 | /* |
62 | luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo); | 163 | ** Create registry table and its predefined values |
63 | luaM_freearray(L, L1->stack, L1->stacksize, TValue); | 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); | ||
64 | } | 177 | } |
65 | 178 | ||
66 | 179 | ||
67 | /* | 180 | /* |
68 | ** open parts that may cause memory-allocation errors | 181 | ** open parts of the state that may cause memory-allocation errors |
69 | */ | 182 | */ |
70 | static void f_luaopen (lua_State *L, void *ud) { | 183 | static void f_luaopen (lua_State *L, void *ud) { |
71 | global_State *g = G(L); | 184 | global_State *g = G(L); |
72 | UNUSED(ud); | 185 | UNUSED(ud); |
73 | stack_init(L, L); /* init stack */ | 186 | stack_init(L, L); /* init stack */ |
74 | sethvalue(L, gt(L), luaH_new(L, 0, 2)); /* table of globals */ | 187 | init_registry(L, g); |
75 | sethvalue(L, registry(L), luaH_new(L, 0, 2)); /* registry */ | ||
76 | luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ | 188 | luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ |
77 | luaT_init(L); | 189 | luaT_init(L); |
78 | luaX_init(L); | 190 | luaX_init(L); |
79 | luaS_fix(luaS_newliteral(L, MEMERRMSG)); | 191 | /* pre-create memory-error message */ |
80 | g->GCthreshold = 4*g->totalbytes; | 192 | g->memerrmsg = luaS_newliteral(L, MEMERRMSG); |
193 | luaS_fix(g->memerrmsg); /* it should never be collected */ | ||
194 | g->gcrunning = 1; /* allow gc */ | ||
195 | g->version = lua_version(NULL); | ||
196 | luai_userstateopen(L); | ||
81 | } | 197 | } |
82 | 198 | ||
83 | 199 | ||
200 | /* | ||
201 | ** preinitialize a state with consistent values without allocating | ||
202 | ** any memory (to avoid errors) | ||
203 | */ | ||
84 | static void preinit_state (lua_State *L, global_State *g) { | 204 | static void preinit_state (lua_State *L, global_State *g) { |
85 | G(L) = g; | 205 | G(L) = g; |
86 | L->stack = NULL; | 206 | L->stack = NULL; |
207 | L->ci = NULL; | ||
87 | L->stacksize = 0; | 208 | L->stacksize = 0; |
88 | L->errorJmp = NULL; | 209 | L->errorJmp = NULL; |
210 | L->nCcalls = 0; | ||
89 | L->hook = NULL; | 211 | L->hook = NULL; |
90 | L->hookmask = 0; | 212 | L->hookmask = 0; |
91 | L->basehookcount = 0; | 213 | L->basehookcount = 0; |
92 | L->allowhook = 1; | 214 | L->allowhook = 1; |
93 | resethookcount(L); | 215 | resethookcount(L); |
94 | L->openupval = NULL; | 216 | L->openupval = NULL; |
95 | L->size_ci = 0; | 217 | L->nny = 1; |
96 | L->nCcalls = L->baseCcalls = 0; | 218 | L->status = LUA_OK; |
97 | L->status = 0; | ||
98 | L->base_ci = L->ci = NULL; | ||
99 | L->savedpc = NULL; | ||
100 | L->errfunc = 0; | 219 | L->errfunc = 0; |
101 | setnilvalue(gt(L)); | ||
102 | } | 220 | } |
103 | 221 | ||
104 | 222 | ||
105 | static void close_state (lua_State *L) { | 223 | static void close_state (lua_State *L) { |
106 | global_State *g = G(L); | 224 | global_State *g = G(L); |
107 | luaF_close(L, L->stack); /* close all upvalues for this thread */ | 225 | luaF_close(L, L->stack); /* close all upvalues for this thread */ |
108 | luaC_freeall(L); /* collect all objects */ | 226 | luaC_freeallobjects(L); /* collect all objects */ |
109 | lua_assert(g->rootgc == obj2gco(L)); | 227 | if (g->version) /* closing a fully built state? */ |
110 | lua_assert(g->strt.nuse == 0); | 228 | luai_userstateclose(L); |
111 | luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *); | 229 | luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); |
112 | luaZ_freebuffer(L, &g->buff); | 230 | luaZ_freebuffer(L, &g->buff); |
113 | freestack(L, L); | 231 | freestack(L); |
114 | lua_assert(g->totalbytes == sizeof(LG)); | 232 | lua_assert(gettotalbytes(g) == sizeof(LG)); |
115 | (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0); | 233 | (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ |
116 | } | 234 | } |
117 | 235 | ||
118 | 236 | ||
119 | lua_State *luaE_newthread (lua_State *L) { | 237 | LUA_API lua_State *lua_newthread (lua_State *L) { |
120 | lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State))); | 238 | lua_State *L1; |
121 | luaC_link(L, obj2gco(L1), LUA_TTHREAD); | 239 | lua_lock(L); |
240 | luaC_checkGC(L); | ||
241 | L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th; | ||
242 | setthvalue(L, L->top, L1); | ||
243 | api_incr_top(L); | ||
122 | preinit_state(L1, G(L)); | 244 | preinit_state(L1, G(L)); |
123 | stack_init(L1, L); /* init stack */ | ||
124 | setobj2n(L, gt(L1), gt(L)); /* share table of globals */ | ||
125 | L1->hookmask = L->hookmask; | 245 | L1->hookmask = L->hookmask; |
126 | L1->basehookcount = L->basehookcount; | 246 | L1->basehookcount = L->basehookcount; |
127 | L1->hook = L->hook; | 247 | L1->hook = L->hook; |
128 | resethookcount(L1); | 248 | resethookcount(L1); |
129 | lua_assert(iswhite(obj2gco(L1))); | 249 | luai_userstatethread(L, L1); |
250 | stack_init(L1, L); /* init stack */ | ||
251 | lua_unlock(L); | ||
130 | return L1; | 252 | return L1; |
131 | } | 253 | } |
132 | 254 | ||
133 | 255 | ||
134 | void luaE_freethread (lua_State *L, lua_State *L1) { | 256 | void luaE_freethread (lua_State *L, lua_State *L1) { |
257 | LX *l = fromstate(L1); | ||
135 | luaF_close(L1, L1->stack); /* close all upvalues for this thread */ | 258 | luaF_close(L1, L1->stack); /* close all upvalues for this thread */ |
136 | lua_assert(L1->openupval == NULL); | 259 | lua_assert(L1->openupval == NULL); |
137 | luai_userstatefree(L1); | 260 | luai_userstatefree(L, L1); |
138 | freestack(L, L1); | 261 | freestack(L1); |
139 | luaM_freemem(L, fromstate(L1), state_size(lua_State)); | 262 | luaM_free(L, l); |
140 | } | 263 | } |
141 | 264 | ||
142 | 265 | ||
@@ -144,71 +267,57 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { | |||
144 | int i; | 267 | int i; |
145 | lua_State *L; | 268 | lua_State *L; |
146 | global_State *g; | 269 | global_State *g; |
147 | void *l = (*f)(ud, NULL, 0, state_size(LG)); | 270 | LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); |
148 | if (l == NULL) return NULL; | 271 | if (l == NULL) return NULL; |
149 | L = tostate(l); | 272 | L = &l->l.l; |
150 | g = &((LG *)L)->g; | 273 | g = &l->g; |
151 | L->next = NULL; | 274 | L->next = NULL; |
152 | L->tt = LUA_TTHREAD; | 275 | L->tt = LUA_TTHREAD; |
153 | g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT); | 276 | g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT); |
154 | L->marked = luaC_white(g); | 277 | L->marked = luaC_white(g); |
155 | set2bits(L->marked, FIXEDBIT, SFIXEDBIT); | 278 | g->gckind = KGC_NORMAL; |
156 | preinit_state(L, g); | 279 | preinit_state(L, g); |
157 | g->frealloc = f; | 280 | g->frealloc = f; |
158 | g->ud = ud; | 281 | g->ud = ud; |
159 | g->mainthread = L; | 282 | g->mainthread = L; |
283 | g->seed = makeseed(L); | ||
160 | g->uvhead.u.l.prev = &g->uvhead; | 284 | g->uvhead.u.l.prev = &g->uvhead; |
161 | g->uvhead.u.l.next = &g->uvhead; | 285 | g->uvhead.u.l.next = &g->uvhead; |
162 | g->GCthreshold = 0; /* mark it as unfinished state */ | 286 | g->gcrunning = 0; /* no GC while building state */ |
287 | g->GCestimate = 0; | ||
163 | g->strt.size = 0; | 288 | g->strt.size = 0; |
164 | g->strt.nuse = 0; | 289 | g->strt.nuse = 0; |
165 | g->strt.hash = NULL; | 290 | g->strt.hash = NULL; |
166 | setnilvalue(registry(L)); | 291 | setnilvalue(&g->l_registry); |
167 | luaZ_initbuffer(L, &g->buff); | 292 | luaZ_initbuffer(L, &g->buff); |
168 | g->panic = NULL; | 293 | g->panic = NULL; |
294 | g->version = NULL; | ||
169 | g->gcstate = GCSpause; | 295 | g->gcstate = GCSpause; |
170 | g->rootgc = obj2gco(L); | 296 | g->allgc = NULL; |
171 | g->sweepstrgc = 0; | 297 | g->finobj = NULL; |
172 | g->sweepgc = &g->rootgc; | 298 | g->tobefnz = NULL; |
173 | g->gray = NULL; | 299 | g->sweepgc = g->sweepfin = NULL; |
174 | g->grayagain = NULL; | 300 | g->gray = g->grayagain = NULL; |
175 | g->weak = NULL; | 301 | g->weak = g->ephemeron = g->allweak = NULL; |
176 | g->tmudata = NULL; | ||
177 | g->totalbytes = sizeof(LG); | 302 | g->totalbytes = sizeof(LG); |
303 | g->GCdebt = 0; | ||
178 | g->gcpause = LUAI_GCPAUSE; | 304 | g->gcpause = LUAI_GCPAUSE; |
305 | g->gcmajorinc = LUAI_GCMAJOR; | ||
179 | g->gcstepmul = LUAI_GCMUL; | 306 | g->gcstepmul = LUAI_GCMUL; |
180 | g->gcdept = 0; | 307 | for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; |
181 | for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL; | 308 | if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { |
182 | if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) { | ||
183 | /* memory allocation error: free partial state */ | 309 | /* memory allocation error: free partial state */ |
184 | close_state(L); | 310 | close_state(L); |
185 | L = NULL; | 311 | L = NULL; |
186 | } | 312 | } |
187 | else | ||
188 | luai_userstateopen(L); | ||
189 | return L; | 313 | return L; |
190 | } | 314 | } |
191 | 315 | ||
192 | 316 | ||
193 | static void callallgcTM (lua_State *L, void *ud) { | ||
194 | UNUSED(ud); | ||
195 | luaC_callGCTM(L); /* call GC metamethods for all udata */ | ||
196 | } | ||
197 | |||
198 | |||
199 | LUA_API void lua_close (lua_State *L) { | 317 | LUA_API void lua_close (lua_State *L) { |
200 | L = G(L)->mainthread; /* only the main thread can be closed */ | 318 | L = G(L)->mainthread; /* only the main thread can be closed */ |
201 | lua_lock(L); | 319 | lua_lock(L); |
202 | luaF_close(L, L->stack); /* close all upvalues for this thread */ | ||
203 | luaC_separateudata(L, 1); /* separate udata that have GC metamethods */ | ||
204 | L->errfunc = 0; /* no error function during GC metamethods */ | ||
205 | do { /* repeat until no more errors */ | ||
206 | L->ci = L->base_ci; | ||
207 | L->base = L->top = L->ci->base; | ||
208 | L->nCcalls = L->baseCcalls = 0; | ||
209 | } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0); | ||
210 | lua_assert(G(L)->tmudata == NULL); | ||
211 | luai_userstateclose(L); | ||
212 | close_state(L); | 320 | close_state(L); |
213 | } | 321 | } |
214 | 322 | ||
323 | |||