Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  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.  
  1088.