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