diff options
author | Maurus Cuelenaere <mcuelenaere@gmail.com> | 2009-05-21 19:01:41 +0000 |
---|---|---|
committer | Maurus Cuelenaere <mcuelenaere@gmail.com> | 2009-05-21 19:01:41 +0000 |
commit | cf87597226f5d6b269f1f2c4d6f402aa1eccb852 (patch) | |
tree | 4ba1f3ae53b3bd9cae0e2c6c4dd57836b43a5ece /apps/plugins/lua/lapi.c | |
parent | c483efadc63eaed35b5fb5e4e02c2282daf32470 (diff) | |
download | rockbox-cf87597226f5d6b269f1f2c4d6f402aa1eccb852.tar.gz rockbox-cf87597226f5d6b269f1f2c4d6f402aa1eccb852.zip |
Commit FS#9174: Lua scripting language by Dan Everton
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@21020 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/plugins/lua/lapi.c')
-rw-r--r-- | apps/plugins/lua/lapi.c | 1087 |
1 files changed, 1087 insertions, 0 deletions
diff --git a/apps/plugins/lua/lapi.c b/apps/plugins/lua/lapi.c new file mode 100644 index 0000000000..487d6b173a --- /dev/null +++ b/apps/plugins/lua/lapi.c | |||
@@ -0,0 +1,1087 @@ | |||
1 | /* | ||
2 | ** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $ | ||
3 | ** Lua API | ||
4 | ** See Copyright Notice in lua.h | ||
5 | */ | ||
6 | |||
7 | |||
8 | /* #include <assert.h> */ | ||
9 | #include <math.h> | ||
10 | #include <stdarg.h> | ||
11 | #include <string.h> | ||
12 | |||
13 | #define lapi_c | ||
14 | #define LUA_CORE | ||
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 "lmem.h" | ||
24 | #include "lobject.h" | ||
25 | #include "lstate.h" | ||
26 | #include "lstring.h" | ||
27 | #include "ltable.h" | ||
28 | #include "ltm.h" | ||
29 | #include "lundump.h" | ||
30 | #include "lvm.h" | ||
31 | |||
32 | |||
33 | |||
34 | const char lua_ident[] = | ||
35 | "$Lua: " LUA_RELEASE " " LUA_COPYRIGHT " $\n" | ||
36 | "$Authors: " LUA_AUTHORS " $\n" | ||
37 | "$URL: www.lua.org $\n"; | ||
38 | |||
39 | |||
40 | |||
41 | #define api_checknelems(L, n) api_check(L, (n) <= (L->top - L->base)) | ||
42 | |||
43 | #define api_checkvalidindex(L, i) api_check(L, (i) != luaO_nilobject) | ||
44 | |||
45 | #define api_incr_top(L) {api_check(L, L->top < L->ci->top); L->top++;} | ||
46 | |||
47 | |||
48 | |||
49 | static TValue *index2adr (lua_State *L, int idx) { | ||
50 | if (idx > 0) { | ||
51 | TValue *o = L->base + (idx - 1); | ||
52 | api_check(L, idx <= L->ci->top - L->base); | ||
53 | if (o >= L->top) return cast(TValue *, luaO_nilobject); | ||
54 | else return o; | ||
55 | } | ||
56 | else if (idx > LUA_REGISTRYINDEX) { | ||
57 | api_check(L, idx != 0 && -idx <= L->top - L->base); | ||
58 | return L->top + idx; | ||
59 | } | ||
60 | else switch (idx) { /* pseudo-indices */ | ||
61 | case LUA_REGISTRYINDEX: return registry(L); | ||
62 | case LUA_ENVIRONINDEX: { | ||
63 | Closure *func = curr_func(L); | ||
64 | sethvalue(L, &L->env, func->c.env); | ||
65 | return &L->env; | ||
66 | } | ||
67 | case LUA_GLOBALSINDEX: return gt(L); | ||
68 | default: { | ||
69 | Closure *func = curr_func(L); | ||
70 | idx = LUA_GLOBALSINDEX - idx; | ||
71 | return (idx <= func->c.nupvalues) | ||
72 | ? &func->c.upvalue[idx-1] | ||
73 | : cast(TValue *, luaO_nilobject); | ||
74 | } | ||
75 | } | ||
76 | } | ||
77 | |||
78 | |||
79 | static Table *getcurrenv (lua_State *L) { | ||
80 | if (L->ci == L->base_ci) /* no enclosing function? */ | ||
81 | return hvalue(gt(L)); /* use global table as environment */ | ||
82 | else { | ||
83 | Closure *func = curr_func(L); | ||
84 | return func->c.env; | ||
85 | } | ||
86 | } | ||
87 | |||
88 | |||
89 | void luaA_pushobject (lua_State *L, const TValue *o) { | ||
90 | setobj2s(L, L->top, o); | ||
91 | api_incr_top(L); | ||
92 | } | ||
93 | |||
94 | |||
95 | LUA_API int lua_checkstack (lua_State *L, int size) { | ||
96 | int res = 1; | ||
97 | lua_lock(L); | ||
98 | if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK) | ||
99 | res = 0; /* stack overflow */ | ||
100 | else if (size > 0) { | ||
101 | luaD_checkstack(L, size); | ||
102 | if (L->ci->top < L->top + size) | ||
103 | L->ci->top = L->top + size; | ||
104 | } | ||
105 | lua_unlock(L); | ||
106 | return res; | ||
107 | } | ||
108 | |||
109 | |||
110 | LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) { | ||
111 | int i; | ||
112 | if (from == to) return; | ||
113 | lua_lock(to); | ||
114 | api_checknelems(from, n); | ||
115 | api_check(from, G(from) == G(to)); | ||
116 | api_check(from, to->ci->top - to->top >= n); | ||
117 | from->top -= n; | ||
118 | for (i = 0; i < n; i++) { | ||
119 | setobj2s(to, to->top++, from->top + i); | ||
120 | } | ||
121 | lua_unlock(to); | ||
122 | } | ||
123 | |||
124 | |||
125 | LUA_API void lua_setlevel (lua_State *from, lua_State *to) { | ||
126 | to->nCcalls = from->nCcalls; | ||
127 | } | ||
128 | |||
129 | |||
130 | LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { | ||
131 | lua_CFunction old; | ||
132 | lua_lock(L); | ||
133 | old = G(L)->panic; | ||
134 | G(L)->panic = panicf; | ||
135 | lua_unlock(L); | ||
136 | return old; | ||
137 | } | ||
138 | |||
139 | |||
140 | LUA_API lua_State *lua_newthread (lua_State *L) { | ||
141 | lua_State *L1; | ||
142 | lua_lock(L); | ||
143 | luaC_checkGC(L); | ||
144 | L1 = luaE_newthread(L); | ||
145 | setthvalue(L, L->top, L1); | ||
146 | api_incr_top(L); | ||
147 | lua_unlock(L); | ||
148 | luai_userstatethread(L, L1); | ||
149 | return L1; | ||
150 | } | ||
151 | |||
152 | |||
153 | |||
154 | /* | ||
155 | ** basic stack manipulation | ||
156 | */ | ||
157 | |||
158 | |||
159 | LUA_API int lua_gettop (lua_State *L) { | ||
160 | return cast_int(L->top - L->base); | ||
161 | } | ||
162 | |||
163 | |||
164 | LUA_API void lua_settop (lua_State *L, int idx) { | ||
165 | lua_lock(L); | ||
166 | if (idx >= 0) { | ||
167 | api_check(L, idx <= L->stack_last - L->base); | ||
168 | while (L->top < L->base + idx) | ||
169 | setnilvalue(L->top++); | ||
170 | L->top = L->base + idx; | ||
171 | } | ||
172 | else { | ||
173 | api_check(L, -(idx+1) <= (L->top - L->base)); | ||
174 | L->top += idx+1; /* `subtract' index (index is negative) */ | ||
175 | } | ||
176 | lua_unlock(L); | ||
177 | } | ||
178 | |||
179 | |||
180 | LUA_API void lua_remove (lua_State *L, int idx) { | ||
181 | StkId p; | ||
182 | lua_lock(L); | ||
183 | p = index2adr(L, idx); | ||
184 | api_checkvalidindex(L, p); | ||
185 | while (++p < L->top) setobjs2s(L, p-1, p); | ||
186 | L->top--; | ||
187 | lua_unlock(L); | ||
188 | } | ||
189 | |||
190 | |||
191 | LUA_API void lua_insert (lua_State *L, int idx) { | ||
192 | StkId p; | ||
193 | StkId q; | ||
194 | lua_lock(L); | ||
195 | p = index2adr(L, idx); | ||
196 | api_checkvalidindex(L, p); | ||
197 | for (q = L->top; q>p; q--) setobjs2s(L, q, q-1); | ||
198 | setobjs2s(L, p, L->top); | ||
199 | lua_unlock(L); | ||
200 | } | ||
201 | |||
202 | |||
203 | LUA_API void lua_replace (lua_State *L, int idx) { | ||
204 | StkId o; | ||
205 | lua_lock(L); | ||
206 | /* explicit test for incompatible code */ | ||
207 | if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci) | ||
208 | luaG_runerror(L, "no calling environment"); | ||
209 | api_checknelems(L, 1); | ||
210 | o = index2adr(L, idx); | ||
211 | api_checkvalidindex(L, o); | ||
212 | if (idx == LUA_ENVIRONINDEX) { | ||
213 | Closure *func = curr_func(L); | ||
214 | api_check(L, ttistable(L->top - 1)); | ||
215 | func->c.env = hvalue(L->top - 1); | ||
216 | luaC_barrier(L, func, L->top - 1); | ||
217 | } | ||
218 | else { | ||
219 | setobj(L, o, L->top - 1); | ||
220 | if (idx < LUA_GLOBALSINDEX) /* function upvalue? */ | ||
221 | luaC_barrier(L, curr_func(L), L->top - 1); | ||
222 | } | ||
223 | L->top--; | ||
224 | lua_unlock(L); | ||
225 | } | ||
226 | |||
227 | |||
228 | LUA_API void lua_pushvalue (lua_State *L, int idx) { | ||
229 | lua_lock(L); | ||
230 | setobj2s(L, L->top, index2adr(L, idx)); | ||
231 | api_incr_top(L); | ||
232 | lua_unlock(L); | ||
233 | } | ||
234 | |||
235 | |||
236 | |||
237 | /* | ||
238 | ** access functions (stack -> C) | ||
239 | */ | ||
240 | |||
241 | |||
242 | LUA_API int lua_type (lua_State *L, int idx) { | ||
243 | StkId o = index2adr(L, idx); | ||
244 | return (o == luaO_nilobject) ? LUA_TNONE : ttype(o); | ||
245 | } | ||
246 | |||
247 | |||
248 | LUA_API const char *lua_typename (lua_State *L, int t) { | ||
249 | UNUSED(L); | ||
250 | return (t == LUA_TNONE) ? "no value" : luaT_typenames[t]; | ||
251 | } | ||
252 | |||
253 | |||
254 | LUA_API int lua_iscfunction (lua_State *L, int idx) { | ||
255 | StkId o = index2adr(L, idx); | ||
256 | return iscfunction(o); | ||
257 | } | ||
258 | |||
259 | |||
260 | LUA_API int lua_isnumber (lua_State *L, int idx) { | ||
261 | TValue n; | ||
262 | const TValue *o = index2adr(L, idx); | ||
263 | return tonumber(o, &n); | ||
264 | } | ||
265 | |||
266 | |||
267 | LUA_API int lua_isstring (lua_State *L, int idx) { | ||
268 | int t = lua_type(L, idx); | ||
269 | return (t == LUA_TSTRING || t == LUA_TNUMBER); | ||
270 | } | ||
271 | |||
272 | |||
273 | LUA_API int lua_isuserdata (lua_State *L, int idx) { | ||
274 | const TValue *o = index2adr(L, idx); | ||
275 | return (ttisuserdata(o) || ttislightuserdata(o)); | ||
276 | } | ||
277 | |||
278 | |||
279 | LUA_API int lua_rawequal (lua_State *L, int index1, int index2) { | ||
280 | StkId o1 = index2adr(L, index1); | ||
281 | StkId o2 = index2adr(L, index2); | ||
282 | return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 | ||
283 | : luaO_rawequalObj(o1, o2); | ||
284 | } | ||
285 | |||
286 | |||
287 | LUA_API int lua_equal (lua_State *L, int index1, int index2) { | ||
288 | StkId o1, o2; | ||
289 | int i; | ||
290 | lua_lock(L); /* may call tag method */ | ||
291 | o1 = index2adr(L, index1); | ||
292 | o2 = index2adr(L, index2); | ||
293 | i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2); | ||
294 | lua_unlock(L); | ||
295 | return i; | ||
296 | } | ||
297 | |||
298 | |||
299 | LUA_API int lua_lessthan (lua_State *L, int index1, int index2) { | ||
300 | StkId o1, o2; | ||
301 | int i; | ||
302 | lua_lock(L); /* may call tag method */ | ||
303 | o1 = index2adr(L, index1); | ||
304 | o2 = index2adr(L, index2); | ||
305 | i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 | ||
306 | : luaV_lessthan(L, o1, o2); | ||
307 | lua_unlock(L); | ||
308 | return i; | ||
309 | } | ||
310 | |||
311 | |||
312 | |||
313 | LUA_API lua_Number lua_tonumber (lua_State *L, int idx) { | ||
314 | TValue n; | ||
315 | const TValue *o = index2adr(L, idx); | ||
316 | if (tonumber(o, &n)) | ||
317 | return nvalue(o); | ||
318 | else | ||
319 | return 0; | ||
320 | } | ||
321 | |||
322 | |||
323 | LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) { | ||
324 | TValue n; | ||
325 | const TValue *o = index2adr(L, idx); | ||
326 | if (tonumber(o, &n)) { | ||
327 | lua_Integer res; | ||
328 | lua_Number num = nvalue(o); | ||
329 | lua_number2integer(res, num); | ||
330 | return res; | ||
331 | } | ||
332 | else | ||
333 | return 0; | ||
334 | } | ||
335 | |||
336 | |||
337 | LUA_API int lua_toboolean (lua_State *L, int idx) { | ||
338 | const TValue *o = index2adr(L, idx); | ||
339 | return !l_isfalse(o); | ||
340 | } | ||
341 | |||
342 | |||
343 | LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { | ||
344 | StkId o = index2adr(L, idx); | ||
345 | if (!ttisstring(o)) { | ||
346 | lua_lock(L); /* `luaV_tostring' may create a new string */ | ||
347 | if (!luaV_tostring(L, o)) { /* conversion failed? */ | ||
348 | if (len != NULL) *len = 0; | ||
349 | lua_unlock(L); | ||
350 | return NULL; | ||
351 | } | ||
352 | luaC_checkGC(L); | ||
353 | o = index2adr(L, idx); /* previous call may reallocate the stack */ | ||
354 | lua_unlock(L); | ||
355 | } | ||
356 | if (len != NULL) *len = tsvalue(o)->len; | ||
357 | return svalue(o); | ||
358 | } | ||
359 | |||
360 | |||
361 | LUA_API size_t lua_objlen (lua_State *L, int idx) { | ||
362 | StkId o = index2adr(L, idx); | ||
363 | switch (ttype(o)) { | ||
364 | case LUA_TSTRING: return tsvalue(o)->len; | ||
365 | case LUA_TUSERDATA: return uvalue(o)->len; | ||
366 | case LUA_TTABLE: return luaH_getn(hvalue(o)); | ||
367 | case LUA_TNUMBER: { | ||
368 | size_t l; | ||
369 | lua_lock(L); /* `luaV_tostring' may create a new string */ | ||
370 | l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0); | ||
371 | lua_unlock(L); | ||
372 | return l; | ||
373 | } | ||
374 | default: return 0; | ||
375 | } | ||
376 | } | ||
377 | |||
378 | |||
379 | LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) { | ||
380 | StkId o = index2adr(L, idx); | ||
381 | return (!iscfunction(o)) ? NULL : clvalue(o)->c.f; | ||
382 | } | ||
383 | |||
384 | |||
385 | LUA_API void *lua_touserdata (lua_State *L, int idx) { | ||
386 | StkId o = index2adr(L, idx); | ||
387 | switch (ttype(o)) { | ||
388 | case LUA_TUSERDATA: return (rawuvalue(o) + 1); | ||
389 | case LUA_TLIGHTUSERDATA: return pvalue(o); | ||
390 | default: return NULL; | ||
391 | } | ||
392 | } | ||
393 | |||
394 | |||
395 | LUA_API lua_State *lua_tothread (lua_State *L, int idx) { | ||
396 | StkId o = index2adr(L, idx); | ||
397 | return (!ttisthread(o)) ? NULL : thvalue(o); | ||
398 | } | ||
399 | |||
400 | |||
401 | LUA_API const void *lua_topointer (lua_State *L, int idx) { | ||
402 | StkId o = index2adr(L, idx); | ||
403 | switch (ttype(o)) { | ||
404 | case LUA_TTABLE: return hvalue(o); | ||
405 | case LUA_TFUNCTION: return clvalue(o); | ||
406 | case LUA_TTHREAD: return thvalue(o); | ||
407 | case LUA_TUSERDATA: | ||
408 | case LUA_TLIGHTUSERDATA: | ||
409 | return lua_touserdata(L, idx); | ||
410 | default: return NULL; | ||
411 | } | ||
412 | } | ||
413 | |||
414 | |||
415 | |||
416 | /* | ||
417 | ** push functions (C -> stack) | ||
418 | */ | ||
419 | |||
420 | |||
421 | LUA_API void lua_pushnil (lua_State *L) { | ||
422 | lua_lock(L); | ||
423 | setnilvalue(L->top); | ||
424 | api_incr_top(L); | ||
425 | lua_unlock(L); | ||
426 | } | ||
427 | |||
428 | |||
429 | LUA_API void lua_pushnumber (lua_State *L, lua_Number n) { | ||
430 | lua_lock(L); | ||
431 | setnvalue(L->top, n); | ||
432 | api_incr_top(L); | ||
433 | lua_unlock(L); | ||
434 | } | ||
435 | |||
436 | |||
437 | LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) { | ||
438 | lua_lock(L); | ||
439 | setnvalue(L->top, cast_num(n)); | ||
440 | api_incr_top(L); | ||
441 | lua_unlock(L); | ||
442 | } | ||
443 | |||
444 | |||
445 | LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) { | ||
446 | lua_lock(L); | ||
447 | luaC_checkGC(L); | ||
448 | setsvalue2s(L, L->top, luaS_newlstr(L, s, len)); | ||
449 | api_incr_top(L); | ||
450 | lua_unlock(L); | ||
451 | } | ||
452 | |||
453 | |||
454 | LUA_API void lua_pushstring (lua_State *L, const char *s) { | ||
455 | if (s == NULL) | ||
456 | lua_pushnil(L); | ||
457 | else | ||
458 | lua_pushlstring(L, s, strlen(s)); | ||
459 | } | ||
460 | |||
461 | |||
462 | LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt, | ||
463 | va_list argp) { | ||
464 | const char *ret; | ||
465 | lua_lock(L); | ||
466 | luaC_checkGC(L); | ||
467 | ret = luaO_pushvfstring(L, fmt, argp); | ||
468 | lua_unlock(L); | ||
469 | return ret; | ||
470 | } | ||
471 | |||
472 | |||
473 | LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { | ||
474 | const char *ret; | ||
475 | va_list argp; | ||
476 | lua_lock(L); | ||
477 | luaC_checkGC(L); | ||
478 | va_start(argp, fmt); | ||
479 | ret = luaO_pushvfstring(L, fmt, argp); | ||
480 | va_end(argp); | ||
481 | lua_unlock(L); | ||
482 | return ret; | ||
483 | } | ||
484 | |||
485 | |||
486 | LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { | ||
487 | Closure *cl; | ||
488 | lua_lock(L); | ||
489 | luaC_checkGC(L); | ||
490 | api_checknelems(L, n); | ||
491 | cl = luaF_newCclosure(L, n, getcurrenv(L)); | ||
492 | cl->c.f = fn; | ||
493 | L->top -= n; | ||
494 | while (n--) | ||
495 | setobj2n(L, &cl->c.upvalue[n], L->top+n); | ||
496 | setclvalue(L, L->top, cl); | ||
497 | lua_assert(iswhite(obj2gco(cl))); | ||
498 | api_incr_top(L); | ||
499 | lua_unlock(L); | ||
500 | } | ||
501 | |||
502 | |||
503 | LUA_API void lua_pushboolean (lua_State *L, int b) { | ||
504 | lua_lock(L); | ||
505 | setbvalue(L->top, (b != 0)); /* ensure that true is 1 */ | ||
506 | api_incr_top(L); | ||
507 | lua_unlock(L); | ||
508 | } | ||
509 | |||
510 | |||
511 | LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { | ||
512 | lua_lock(L); | ||
513 | setpvalue(L->top, p); | ||
514 | api_incr_top(L); | ||
515 | lua_unlock(L); | ||
516 | } | ||
517 | |||
518 | |||
519 | LUA_API int lua_pushthread (lua_State *L) { | ||
520 | lua_lock(L); | ||
521 | setthvalue(L, L->top, L); | ||
522 | api_incr_top(L); | ||
523 | lua_unlock(L); | ||
524 | return (G(L)->mainthread == L); | ||
525 | } | ||
526 | |||
527 | |||
528 | |||
529 | /* | ||
530 | ** get functions (Lua -> stack) | ||
531 | */ | ||
532 | |||
533 | |||
534 | LUA_API void lua_gettable (lua_State *L, int idx) { | ||
535 | StkId t; | ||
536 | lua_lock(L); | ||
537 | t = index2adr(L, idx); | ||
538 | api_checkvalidindex(L, t); | ||
539 | luaV_gettable(L, t, L->top - 1, L->top - 1); | ||
540 | lua_unlock(L); | ||
541 | } | ||
542 | |||
543 | |||
544 | LUA_API void lua_getfield (lua_State *L, int idx, const char *k) { | ||
545 | StkId t; | ||
546 | TValue key; | ||
547 | lua_lock(L); | ||
548 | t = index2adr(L, idx); | ||
549 | api_checkvalidindex(L, t); | ||
550 | setsvalue(L, &key, luaS_new(L, k)); | ||
551 | luaV_gettable(L, t, &key, L->top); | ||
552 | api_incr_top(L); | ||
553 | lua_unlock(L); | ||
554 | } | ||
555 | |||
556 | |||
557 | LUA_API void lua_rawget (lua_State *L, int idx) { | ||
558 | StkId t; | ||
559 | lua_lock(L); | ||
560 | t = index2adr(L, idx); | ||
561 | api_check(L, ttistable(t)); | ||
562 | setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1)); | ||
563 | lua_unlock(L); | ||
564 | } | ||
565 | |||
566 | |||
567 | LUA_API void lua_rawgeti (lua_State *L, int idx, int n) { | ||
568 | StkId o; | ||
569 | lua_lock(L); | ||
570 | o = index2adr(L, idx); | ||
571 | api_check(L, ttistable(o)); | ||
572 | setobj2s(L, L->top, luaH_getnum(hvalue(o), n)); | ||
573 | api_incr_top(L); | ||
574 | lua_unlock(L); | ||
575 | } | ||
576 | |||
577 | |||
578 | LUA_API void lua_createtable (lua_State *L, int narray, int nrec) { | ||
579 | lua_lock(L); | ||
580 | luaC_checkGC(L); | ||
581 | sethvalue(L, L->top, luaH_new(L, narray, nrec)); | ||
582 | api_incr_top(L); | ||
583 | lua_unlock(L); | ||
584 | } | ||
585 | |||
586 | |||
587 | LUA_API int lua_getmetatable (lua_State *L, int objindex) { | ||
588 | const TValue *obj; | ||
589 | Table *mt = NULL; | ||
590 | int res; | ||
591 | lua_lock(L); | ||
592 | obj = index2adr(L, objindex); | ||
593 | switch (ttype(obj)) { | ||
594 | case LUA_TTABLE: | ||
595 | mt = hvalue(obj)->metatable; | ||
596 | break; | ||
597 | case LUA_TUSERDATA: | ||
598 | mt = uvalue(obj)->metatable; | ||
599 | break; | ||
600 | default: | ||
601 | mt = G(L)->mt[ttype(obj)]; | ||
602 | break; | ||
603 | } | ||
604 | if (mt == NULL) | ||
605 | res = 0; | ||
606 | else { | ||
607 | sethvalue(L, L->top, mt); | ||
608 | api_incr_top(L); | ||
609 | res = 1; | ||
610 | } | ||
611 | lua_unlock(L); | ||
612 | return res; | ||
613 | } | ||
614 | |||
615 | |||
616 | LUA_API void lua_getfenv (lua_State *L, int idx) { | ||
617 | StkId o; | ||
618 | lua_lock(L); | ||
619 | o = index2adr(L, idx); | ||
620 | api_checkvalidindex(L, o); | ||
621 | switch (ttype(o)) { | ||
622 | case LUA_TFUNCTION: | ||
623 | sethvalue(L, L->top, clvalue(o)->c.env); | ||
624 | break; | ||
625 | case LUA_TUSERDATA: | ||
626 | sethvalue(L, L->top, uvalue(o)->env); | ||
627 | break; | ||
628 | case LUA_TTHREAD: | ||
629 | setobj2s(L, L->top, gt(thvalue(o))); | ||
630 | break; | ||
631 | default: | ||
632 | setnilvalue(L->top); | ||
633 | break; | ||
634 | } | ||
635 | api_incr_top(L); | ||
636 | lua_unlock(L); | ||
637 | } | ||
638 | |||
639 | |||
640 | /* | ||
641 | ** set functions (stack -> Lua) | ||
642 | */ | ||
643 | |||
644 | |||
645 | LUA_API void lua_settable (lua_State *L, int idx) { | ||
646 | StkId t; | ||
647 | lua_lock(L); | ||
648 | api_checknelems(L, 2); | ||
649 | t = index2adr(L, idx); | ||
650 | api_checkvalidindex(L, t); | ||
651 | luaV_settable(L, t, L->top - 2, L->top - 1); | ||
652 | L->top -= 2; /* pop index and value */ | ||
653 | lua_unlock(L); | ||
654 | } | ||
655 | |||
656 | |||
657 | LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { | ||
658 | StkId t; | ||
659 | TValue key; | ||
660 | lua_lock(L); | ||
661 | api_checknelems(L, 1); | ||
662 | t = index2adr(L, idx); | ||
663 | api_checkvalidindex(L, t); | ||
664 | setsvalue(L, &key, luaS_new(L, k)); | ||
665 | luaV_settable(L, t, &key, L->top - 1); | ||
666 | L->top--; /* pop value */ | ||
667 | lua_unlock(L); | ||
668 | } | ||
669 | |||
670 | |||
671 | LUA_API void lua_rawset (lua_State *L, int idx) { | ||
672 | StkId t; | ||
673 | lua_lock(L); | ||
674 | api_checknelems(L, 2); | ||
675 | t = index2adr(L, idx); | ||
676 | api_check(L, ttistable(t)); | ||
677 | setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1); | ||
678 | luaC_barriert(L, hvalue(t), L->top-1); | ||
679 | L->top -= 2; | ||
680 | lua_unlock(L); | ||
681 | } | ||
682 | |||
683 | |||
684 | LUA_API void lua_rawseti (lua_State *L, int idx, int n) { | ||
685 | StkId o; | ||
686 | lua_lock(L); | ||
687 | api_checknelems(L, 1); | ||
688 | o = index2adr(L, idx); | ||
689 | api_check(L, ttistable(o)); | ||
690 | setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1); | ||
691 | luaC_barriert(L, hvalue(o), L->top-1); | ||
692 | L->top--; | ||
693 | lua_unlock(L); | ||
694 | } | ||
695 | |||
696 | |||
697 | LUA_API int lua_setmetatable (lua_State *L, int objindex) { | ||
698 | TValue *obj; | ||
699 | Table *mt; | ||
700 | lua_lock(L); | ||
701 | api_checknelems(L, 1); | ||
702 | obj = index2adr(L, objindex); | ||
703 | api_checkvalidindex(L, obj); | ||
704 | if (ttisnil(L->top - 1)) | ||
705 | mt = NULL; | ||
706 | else { | ||
707 | api_check(L, ttistable(L->top - 1)); | ||
708 | mt = hvalue(L->top - 1); | ||
709 | } | ||
710 | switch (ttype(obj)) { | ||
711 | case LUA_TTABLE: { | ||
712 | hvalue(obj)->metatable = mt; | ||
713 | if (mt) | ||
714 | luaC_objbarriert(L, hvalue(obj), mt); | ||
715 | break; | ||
716 | } | ||
717 | case LUA_TUSERDATA: { | ||
718 | uvalue(obj)->metatable = mt; | ||
719 | if (mt) | ||
720 | luaC_objbarrier(L, rawuvalue(obj), mt); | ||
721 | break; | ||
722 | } | ||
723 | default: { | ||
724 | G(L)->mt[ttype(obj)] = mt; | ||
725 | break; | ||
726 | } | ||
727 | } | ||
728 | L->top--; | ||
729 | lua_unlock(L); | ||
730 | return 1; | ||
731 | } | ||
732 | |||
733 | |||
734 | LUA_API int lua_setfenv (lua_State *L, int idx) { | ||
735 | StkId o; | ||
736 | int res = 1; | ||
737 | lua_lock(L); | ||
738 | api_checknelems(L, 1); | ||
739 | o = index2adr(L, idx); | ||
740 | api_checkvalidindex(L, o); | ||
741 | api_check(L, ttistable(L->top - 1)); | ||
742 | switch (ttype(o)) { | ||
743 | case LUA_TFUNCTION: | ||
744 | clvalue(o)->c.env = hvalue(L->top - 1); | ||
745 | break; | ||
746 | case LUA_TUSERDATA: | ||
747 | uvalue(o)->env = hvalue(L->top - 1); | ||
748 | break; | ||
749 | case LUA_TTHREAD: | ||
750 | sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1)); | ||
751 | break; | ||
752 | default: | ||
753 | res = 0; | ||
754 | break; | ||
755 | } | ||
756 | if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1)); | ||
757 | L->top--; | ||
758 | lua_unlock(L); | ||
759 | return res; | ||
760 | } | ||
761 | |||
762 | |||
763 | /* | ||
764 | ** `load' and `call' functions (run Lua code) | ||
765 | */ | ||
766 | |||
767 | |||
768 | #define adjustresults(L,nres) \ | ||
769 | { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; } | ||
770 | |||
771 | |||
772 | #define checkresults(L,na,nr) \ | ||
773 | api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na))) | ||
774 | |||
775 | |||
776 | LUA_API void lua_call (lua_State *L, int nargs, int nresults) { | ||
777 | StkId func; | ||
778 | lua_lock(L); | ||
779 | api_checknelems(L, nargs+1); | ||
780 | checkresults(L, nargs, nresults); | ||
781 | func = L->top - (nargs+1); | ||
782 | luaD_call(L, func, nresults); | ||
783 | adjustresults(L, nresults); | ||
784 | lua_unlock(L); | ||
785 | } | ||
786 | |||
787 | |||
788 | |||
789 | /* | ||
790 | ** Execute a protected call. | ||
791 | */ | ||
792 | struct CallS { /* data to `f_call' */ | ||
793 | StkId func; | ||
794 | int nresults; | ||
795 | }; | ||
796 | |||
797 | |||
798 | static void f_call (lua_State *L, void *ud) { | ||
799 | struct CallS *c = cast(struct CallS *, ud); | ||
800 | luaD_call(L, c->func, c->nresults); | ||
801 | } | ||
802 | |||
803 | |||
804 | |||
805 | LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) { | ||
806 | struct CallS c; | ||
807 | int status; | ||
808 | ptrdiff_t func; | ||
809 | lua_lock(L); | ||
810 | api_checknelems(L, nargs+1); | ||
811 | checkresults(L, nargs, nresults); | ||
812 | if (errfunc == 0) | ||
813 | func = 0; | ||
814 | else { | ||
815 | StkId o = index2adr(L, errfunc); | ||
816 | api_checkvalidindex(L, o); | ||
817 | func = savestack(L, o); | ||
818 | } | ||
819 | c.func = L->top - (nargs+1); /* function to be called */ | ||
820 | c.nresults = nresults; | ||
821 | status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); | ||
822 | adjustresults(L, nresults); | ||
823 | lua_unlock(L); | ||
824 | return status; | ||
825 | } | ||
826 | |||
827 | |||
828 | /* | ||
829 | ** Execute a protected C call. | ||
830 | */ | ||
831 | struct CCallS { /* data to `f_Ccall' */ | ||
832 | lua_CFunction func; | ||
833 | void *ud; | ||
834 | }; | ||
835 | |||
836 | |||
837 | static void f_Ccall (lua_State *L, void *ud) { | ||
838 | struct CCallS *c = cast(struct CCallS *, ud); | ||
839 | Closure *cl; | ||
840 | cl = luaF_newCclosure(L, 0, getcurrenv(L)); | ||
841 | cl->c.f = c->func; | ||
842 | setclvalue(L, L->top, cl); /* push function */ | ||
843 | api_incr_top(L); | ||
844 | setpvalue(L->top, c->ud); /* push only argument */ | ||
845 | api_incr_top(L); | ||
846 | luaD_call(L, L->top - 2, 0); | ||
847 | } | ||
848 | |||
849 | |||
850 | LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) { | ||
851 | struct CCallS c; | ||
852 | int status; | ||
853 | lua_lock(L); | ||
854 | c.func = func; | ||
855 | c.ud = ud; | ||
856 | status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0); | ||
857 | lua_unlock(L); | ||
858 | return status; | ||
859 | } | ||
860 | |||
861 | |||
862 | LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data, | ||
863 | const char *chunkname) { | ||
864 | ZIO z; | ||
865 | int status; | ||
866 | lua_lock(L); | ||
867 | if (!chunkname) chunkname = "?"; | ||
868 | luaZ_init(L, &z, reader, data); | ||
869 | status = luaD_protectedparser(L, &z, chunkname); | ||
870 | lua_unlock(L); | ||
871 | return status; | ||
872 | } | ||
873 | |||
874 | |||
875 | LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) { | ||
876 | int status; | ||
877 | TValue *o; | ||
878 | lua_lock(L); | ||
879 | api_checknelems(L, 1); | ||
880 | o = L->top - 1; | ||
881 | if (isLfunction(o)) | ||
882 | status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0); | ||
883 | else | ||
884 | status = 1; | ||
885 | lua_unlock(L); | ||
886 | return status; | ||
887 | } | ||
888 | |||
889 | |||
890 | LUA_API int lua_status (lua_State *L) { | ||
891 | return L->status; | ||
892 | } | ||
893 | |||
894 | |||
895 | /* | ||
896 | ** Garbage-collection function | ||
897 | */ | ||
898 | |||
899 | LUA_API int lua_gc (lua_State *L, int what, int data) { | ||
900 | int res = 0; | ||
901 | global_State *g; | ||
902 | lua_lock(L); | ||
903 | g = G(L); | ||
904 | switch (what) { | ||
905 | case LUA_GCSTOP: { | ||
906 | g->GCthreshold = MAX_LUMEM; | ||
907 | break; | ||
908 | } | ||
909 | case LUA_GCRESTART: { | ||
910 | g->GCthreshold = g->totalbytes; | ||
911 | break; | ||
912 | } | ||
913 | case LUA_GCCOLLECT: { | ||
914 | luaC_fullgc(L); | ||
915 | break; | ||
916 | } | ||
917 | case LUA_GCCOUNT: { | ||
918 | /* GC values are expressed in Kbytes: #bytes/2^10 */ | ||
919 | res = cast_int(g->totalbytes >> 10); | ||
920 | break; | ||
921 | } | ||
922 | case LUA_GCCOUNTB: { | ||
923 | res = cast_int(g->totalbytes & 0x3ff); | ||
924 | break; | ||
925 | } | ||
926 | case LUA_GCSTEP: { | ||
927 | lu_mem a = (cast(lu_mem, data) << 10); | ||
928 | if (a <= g->totalbytes) | ||
929 | g->GCthreshold = g->totalbytes - a; | ||
930 | else | ||
931 | g->GCthreshold = 0; | ||
932 | while (g->GCthreshold <= g->totalbytes) { | ||
933 | luaC_step(L); | ||
934 | if (g->gcstate == GCSpause) { /* end of cycle? */ | ||
935 | res = 1; /* signal it */ | ||
936 | break; | ||
937 | } | ||
938 | } | ||
939 | break; | ||
940 | } | ||
941 | case LUA_GCSETPAUSE: { | ||
942 | res = g->gcpause; | ||
943 | g->gcpause = data; | ||
944 | break; | ||
945 | } | ||
946 | case LUA_GCSETSTEPMUL: { | ||
947 | res = g->gcstepmul; | ||
948 | g->gcstepmul = data; | ||
949 | break; | ||
950 | } | ||
951 | default: res = -1; /* invalid option */ | ||
952 | } | ||
953 | lua_unlock(L); | ||
954 | return res; | ||
955 | } | ||
956 | |||
957 | |||
958 | |||
959 | /* | ||
960 | ** miscellaneous functions | ||
961 | */ | ||
962 | |||
963 | |||
964 | LUA_API int lua_error (lua_State *L) { | ||
965 | lua_lock(L); | ||
966 | api_checknelems(L, 1); | ||
967 | luaG_errormsg(L); | ||
968 | lua_unlock(L); | ||
969 | return 0; /* to avoid warnings */ | ||
970 | } | ||
971 | |||
972 | |||
973 | LUA_API int lua_next (lua_State *L, int idx) { | ||
974 | StkId t; | ||
975 | int more; | ||
976 | lua_lock(L); | ||
977 | t = index2adr(L, idx); | ||
978 | api_check(L, ttistable(t)); | ||
979 | more = luaH_next(L, hvalue(t), L->top - 1); | ||
980 | if (more) { | ||
981 | api_incr_top(L); | ||
982 | } | ||
983 | else /* no more elements */ | ||
984 | L->top -= 1; /* remove key */ | ||
985 | lua_unlock(L); | ||
986 | return more; | ||
987 | } | ||
988 | |||
989 | |||
990 | LUA_API void lua_concat (lua_State *L, int n) { | ||
991 | lua_lock(L); | ||
992 | api_checknelems(L, n); | ||
993 | if (n >= 2) { | ||
994 | luaC_checkGC(L); | ||
995 | luaV_concat(L, n, cast_int(L->top - L->base) - 1); | ||
996 | L->top -= (n-1); | ||
997 | } | ||
998 | else if (n == 0) { /* push empty string */ | ||
999 | setsvalue2s(L, L->top, luaS_newlstr(L, "", 0)); | ||
1000 | api_incr_top(L); | ||
1001 | } | ||
1002 | /* else n == 1; nothing to do */ | ||
1003 | lua_unlock(L); | ||
1004 | } | ||
1005 | |||
1006 | |||
1007 | LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) { | ||
1008 | lua_Alloc f; | ||
1009 | lua_lock(L); | ||
1010 | if (ud) *ud = G(L)->ud; | ||
1011 | f = G(L)->frealloc; | ||
1012 | lua_unlock(L); | ||
1013 | return f; | ||
1014 | } | ||
1015 | |||
1016 | |||
1017 | LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) { | ||
1018 | lua_lock(L); | ||
1019 | G(L)->ud = ud; | ||
1020 | G(L)->frealloc = f; | ||
1021 | lua_unlock(L); | ||
1022 | } | ||
1023 | |||
1024 | |||
1025 | LUA_API void *lua_newuserdata (lua_State *L, size_t size) { | ||
1026 | Udata *u; | ||
1027 | lua_lock(L); | ||
1028 | luaC_checkGC(L); | ||
1029 | u = luaS_newudata(L, size, getcurrenv(L)); | ||
1030 | setuvalue(L, L->top, u); | ||
1031 | api_incr_top(L); | ||
1032 | lua_unlock(L); | ||
1033 | return u + 1; | ||
1034 | } | ||
1035 | |||
1036 | |||
1037 | |||
1038 | |||
1039 | static const char *aux_upvalue (StkId fi, int n, TValue **val) { | ||
1040 | Closure *f; | ||
1041 | if (!ttisfunction(fi)) return NULL; | ||
1042 | f = clvalue(fi); | ||
1043 | if (f->c.isC) { | ||
1044 | if (!(1 <= n && n <= f->c.nupvalues)) return NULL; | ||
1045 | *val = &f->c.upvalue[n-1]; | ||
1046 | return ""; | ||
1047 | } | ||
1048 | else { | ||
1049 | Proto *p = f->l.p; | ||
1050 | if (!(1 <= n && n <= p->sizeupvalues)) return NULL; | ||
1051 | *val = f->l.upvals[n-1]->v; | ||
1052 | return getstr(p->upvalues[n-1]); | ||
1053 | } | ||
1054 | } | ||
1055 | |||
1056 | |||
1057 | LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) { | ||
1058 | const char *name; | ||
1059 | TValue *val; | ||
1060 | lua_lock(L); | ||
1061 | name = aux_upvalue(index2adr(L, funcindex), n, &val); | ||
1062 | if (name) { | ||
1063 | setobj2s(L, L->top, val); | ||
1064 | api_incr_top(L); | ||
1065 | } | ||
1066 | lua_unlock(L); | ||
1067 | return name; | ||
1068 | } | ||
1069 | |||
1070 | |||
1071 | LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) { | ||
1072 | const char *name; | ||
1073 | TValue *val; | ||
1074 | StkId fi; | ||
1075 | lua_lock(L); | ||
1076 | fi = index2adr(L, funcindex); | ||
1077 | api_checknelems(L, 1); | ||
1078 | name = aux_upvalue(fi, n, &val); | ||
1079 | if (name) { | ||
1080 | L->top--; | ||
1081 | setobj(L, val, L->top); | ||
1082 | luaC_barrier(L, clvalue(fi), L->top); | ||
1083 | } | ||
1084 | lua_unlock(L); | ||
1085 | return name; | ||
1086 | } | ||
1087 | |||