开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
lapi.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：24k
源码类别：

其他游戏

开发平台：

Visual C++

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