Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. /*
  2. ** $Id: lapi.c,v 2.259.1.2 2017/12/06 18:35:12 roberto Exp $
  3. ** Lua API
  4. ** See Copyright Notice in lua.h
  5. */
  6.  
  7. #define lapi_c
  8. #define LUA_CORE
  9.  
  10. #include "lprefix.h"
  11.  
  12.  
  13. #include <stdarg.h>
  14. #include <string.h>
  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.   "$LuaVersion: " LUA_COPYRIGHT " $"
  36.   "$LuaAuthors: " LUA_AUTHORS " $";
  37.  
  38.  
  39. /* value at a non-valid index */
  40. #define NONVALIDVALUE           cast(TValue *, luaO_nilobject)
  41.  
  42. /* corresponding test */
  43. #define isvalid(o)      ((o) != luaO_nilobject)
  44.  
  45. /* test for pseudo index */
  46. #define ispseudo(i)             ((i) <= LUA_REGISTRYINDEX)
  47.  
  48. /* test for upvalue */
  49. #define isupvalue(i)            ((i) < LUA_REGISTRYINDEX)
  50.  
  51. /* test for valid but not pseudo index */
  52. #define isstackindex(i, o)      (isvalid(o) && !ispseudo(i))
  53.  
  54. #define api_checkvalidindex(l,o)  api_check(l, isvalid(o), "invalid index")
  55.  
  56. #define api_checkstackindex(l, i, o)  \
  57.         api_check(l, isstackindex(i, o), "index not in the stack")
  58.  
  59.  
  60. static TValue *index2addr (lua_State *L, int idx) {
  61.   CallInfo *ci = L->ci;
  62.   if (idx > 0) {
  63.     TValue *o = ci->func + idx;
  64.     api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
  65.     if (o >= L->top) return NONVALIDVALUE;
  66.     else return o;
  67.   }
  68.   else if (!ispseudo(idx)) {  /* negative index */
  69.     api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");
  70.     return L->top + idx;
  71.   }
  72.   else if (idx == LUA_REGISTRYINDEX)
  73.     return &G(L)->l_registry;
  74.   else {  /* upvalues */
  75.     idx = LUA_REGISTRYINDEX - idx;
  76.     api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");
  77.     if (ttislcf(ci->func))  /* light C function? */
  78.       return NONVALIDVALUE;  /* it has no upvalues */
  79.     else {
  80.       CClosure *func = clCvalue(ci->func);
  81.       return (idx <= func->nupvalues) ? &func->upvalue[idx-1] : NONVALIDVALUE;
  82.     }
  83.   }
  84. }
  85.  
  86.  
  87. /*
  88. ** to be called by 'lua_checkstack' in protected mode, to grow stack
  89. ** capturing memory errors
  90. */
  91. static void growstack (lua_State *L, void *ud) {
  92.   int size = *(int *)ud;
  93.   luaD_growstack(L, size);
  94. }
  95.  
  96.  
  97. LUA_API int lua_checkstack (lua_State *L, int n) {
  98.   int res;
  99.   CallInfo *ci = L->ci;
  100.   lua_lock(L);
  101.   api_check(L, n >= 0, "negative 'n'");
  102.   if (L->stack_last - L->top > n)  /* stack large enough? */
  103.     res = 1;  /* yes; check is OK */
  104.   else {  /* no; need to grow stack */
  105.     int inuse = cast_int(L->top - L->stack) + EXTRA_STACK;
  106.     if (inuse > LUAI_MAXSTACK - n)  /* can grow without overflow? */
  107.       res = 0;  /* no */
  108.     else  /* try to grow stack */
  109.       res = (luaD_rawrunprotected(L, &growstack, &n) == LUA_OK);
  110.   }
  111.   if (res && ci->top < L->top + n)
  112.     ci->top = L->top + n;  /* adjust frame top */
  113.   lua_unlock(L);
  114.   return res;
  115. }
  116.  
  117.  
  118. LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
  119.   int i;
  120.   if (from == to) return;
  121.   lua_lock(to);
  122.   api_checknelems(from, n);
  123.   api_check(from, G(from) == G(to), "moving among independent states");
  124.   api_check(from, to->ci->top - to->top >= n, "stack overflow");
  125.   from->top -= n;
  126.   for (i = 0; i < n; i++) {
  127.     setobj2s(to, to->top, from->top + i);
  128.     to->top++;  /* stack already checked by previous 'api_check' */
  129.   }
  130.   lua_unlock(to);
  131. }
  132.  
  133.  
  134. LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
  135.   lua_CFunction old;
  136.   lua_lock(L);
  137.   old = G(L)->panic;
  138.   G(L)->panic = panicf;
  139.   lua_unlock(L);
  140.   return old;
  141. }
  142.  
  143.  
  144. LUA_API const lua_Number *lua_version (lua_State *L) {
  145.   static const lua_Number version = LUA_VERSION_NUM;
  146.   if (L == NULL) return &version;
  147.   else return G(L)->version;
  148. }
  149.  
  150.  
  151.  
  152. /*
  153. ** basic stack manipulation
  154. */
  155.  
  156.  
  157. /*
  158. ** convert an acceptable stack index into an absolute index
  159. */
  160. LUA_API int lua_absindex (lua_State *L, int idx) {
  161.   return (idx > 0 || ispseudo(idx))
  162.          ? idx
  163.          : cast_int(L->top - L->ci->func) + idx;
  164. }
  165.  
  166.  
  167. LUA_API int lua_gettop (lua_State *L) {
  168.   return cast_int(L->top - (L->ci->func + 1));
  169. }
  170.  
  171.  
  172. LUA_API void lua_settop (lua_State *L, int idx) {
  173.   StkId func = L->ci->func;
  174.   lua_lock(L);
  175.   if (idx >= 0) {
  176.     api_check(L, idx <= L->stack_last - (func + 1), "new top too large");
  177.     while (L->top < (func + 1) + idx)
  178.       setnilvalue(L->top++);
  179.     L->top = (func + 1) + idx;
  180.   }
  181.   else {
  182.     api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");
  183.     L->top += idx+1;  /* 'subtract' index (index is negative) */
  184.   }
  185.   lua_unlock(L);
  186. }
  187.  
  188.  
  189. /*
  190. ** Reverse the stack segment from 'from' to 'to'
  191. ** (auxiliary to 'lua_rotate')
  192. */
  193. static void reverse (lua_State *L, StkId from, StkId to) {
  194.   for (; from < to; from++, to--) {
  195.     TValue temp;
  196.     setobj(L, &temp, from);
  197.     setobjs2s(L, from, to);
  198.     setobj2s(L, to, &temp);
  199.   }
  200. }
  201.  
  202.  
  203. /*
  204. ** Let x = AB, where A is a prefix of length 'n'. Then,
  205. ** rotate x n == BA. But BA == (A^r . B^r)^r.
  206. */
  207. LUA_API void lua_rotate (lua_State *L, int idx, int n) {
  208.   StkId p, t, m;
  209.   lua_lock(L);
  210.   t = L->top - 1;  /* end of stack segment being rotated */
  211.   p = index2addr(L, idx);  /* start of segment */
  212.   api_checkstackindex(L, idx, p);
  213.   api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
  214.   m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */
  215.   reverse(L, p, m);  /* reverse the prefix with length 'n' */
  216.   reverse(L, m + 1, t);  /* reverse the suffix */
  217.   reverse(L, p, t);  /* reverse the entire segment */
  218.   lua_unlock(L);
  219. }
  220.  
  221.  
  222. LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
  223.   TValue *fr, *to;
  224.   lua_lock(L);
  225.   fr = index2addr(L, fromidx);
  226.   to = index2addr(L, toidx);
  227.   api_checkvalidindex(L, to);
  228.   setobj(L, to, fr);
  229.   if (isupvalue(toidx))  /* function upvalue? */
  230.     luaC_barrier(L, clCvalue(L->ci->func), fr);
  231.   /* LUA_REGISTRYINDEX does not need gc barrier
  232.      (collector revisits it before finishing collection) */
  233.   lua_unlock(L);
  234. }
  235.  
  236.  
  237. LUA_API void lua_pushvalue (lua_State *L, int idx) {
  238.   lua_lock(L);
  239.   setobj2s(L, L->top, index2addr(L, idx));
  240.   api_incr_top(L);
  241.   lua_unlock(L);
  242. }
  243.  
  244.  
  245.  
  246. /*
  247. ** access functions (stack -> C)
  248. */
  249.  
  250.  
  251. LUA_API int lua_type (lua_State *L, int idx) {
  252.   StkId o = index2addr(L, idx);
  253.   return (isvalid(o) ? ttnov(o) : LUA_TNONE);
  254. }
  255.  
  256.  
  257. LUA_API const char *lua_typename (lua_State *L, int t) {
  258.   UNUSED(L);
  259.   api_check(L, LUA_TNONE <= t && t < LUA_NUMTAGS, "invalid tag");
  260.   return ttypename(t);
  261. }
  262.  
  263.  
  264. LUA_API int lua_iscfunction (lua_State *L, int idx) {
  265.   StkId o = index2addr(L, idx);
  266.   return (ttislcf(o) || (ttisCclosure(o)));
  267. }
  268.  
  269.  
  270. LUA_API int lua_isinteger (lua_State *L, int idx) {
  271.   StkId o = index2addr(L, idx);
  272.   return ttisinteger(o);
  273. }
  274.  
  275.  
  276. LUA_API int lua_isnumber (lua_State *L, int idx) {
  277.   lua_Number n;
  278.   const TValue *o = index2addr(L, idx);
  279.   return tonumber(o, &n);
  280. }
  281.  
  282.  
  283. LUA_API int lua_isstring (lua_State *L, int idx) {
  284.   const TValue *o = index2addr(L, idx);
  285.   return (ttisstring(o) || cvt2str(o));
  286. }
  287.  
  288.  
  289. LUA_API int lua_isuserdata (lua_State *L, int idx) {
  290.   const TValue *o = index2addr(L, idx);
  291.   return (ttisfulluserdata(o) || ttislightuserdata(o));
  292. }
  293.  
  294.  
  295. LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
  296.   StkId o1 = index2addr(L, index1);
  297.   StkId o2 = index2addr(L, index2);
  298.   return (isvalid(o1) && isvalid(o2)) ? luaV_rawequalobj(o1, o2) : 0;
  299. }
  300.  
  301.  
  302. LUA_API void lua_arith (lua_State *L, int op) {
  303.   lua_lock(L);
  304.   if (op != LUA_OPUNM && op != LUA_OPBNOT)
  305.     api_checknelems(L, 2);  /* all other operations expect two operands */
  306.   else {  /* for unary operations, add fake 2nd operand */
  307.     api_checknelems(L, 1);
  308.     setobjs2s(L, L->top, L->top - 1);
  309.     api_incr_top(L);
  310.   }
  311.   /* first operand at top - 2, second at top - 1; result go to top - 2 */
  312.   luaO_arith(L, op, L->top - 2, L->top - 1, L->top - 2);
  313.   L->top--;  /* remove second operand */
  314.   lua_unlock(L);
  315. }
  316.  
  317.  
  318. LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {
  319.   StkId o1, o2;
  320.   int i = 0;
  321.   lua_lock(L);  /* may call tag method */
  322.   o1 = index2addr(L, index1);
  323.   o2 = index2addr(L, index2);
  324.   if (isvalid(o1) && isvalid(o2)) {
  325.     switch (op) {
  326.       case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break;
  327.       case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
  328.       case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
  329.       default: api_check(L, 0, "invalid option");
  330.     }
  331.   }
  332.   lua_unlock(L);
  333.   return i;
  334. }
  335.  
  336.  
  337. LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) {
  338.   size_t sz = luaO_str2num(s, L->top);
  339.   if (sz != 0)
  340.     api_incr_top(L);
  341.   return sz;
  342. }
  343.  
  344.  
  345. LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {
  346.   lua_Number n;
  347.   const TValue *o = index2addr(L, idx);
  348.   int isnum = tonumber(o, &n);
  349.   if (!isnum)
  350.     n = 0;  /* call to 'tonumber' may change 'n' even if it fails */
  351.   if (pisnum) *pisnum = isnum;
  352.   return n;
  353. }
  354.  
  355.  
  356. LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {
  357.   lua_Integer res;
  358.   const TValue *o = index2addr(L, idx);
  359.   int isnum = tointeger(o, &res);
  360.   if (!isnum)
  361.     res = 0;  /* call to 'tointeger' may change 'n' even if it fails */
  362.   if (pisnum) *pisnum = isnum;
  363.   return res;
  364. }
  365.  
  366.  
  367. LUA_API int lua_toboolean (lua_State *L, int idx) {
  368.   const TValue *o = index2addr(L, idx);
  369.   return !l_isfalse(o);
  370. }
  371.  
  372.  
  373. LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
  374.   StkId o = index2addr(L, idx);
  375.   if (!ttisstring(o)) {
  376.     if (!cvt2str(o)) {  /* not convertible? */
  377.       if (len != NULL) *len = 0;
  378.       return NULL;
  379.     }
  380.     lua_lock(L);  /* 'luaO_tostring' may create a new string */
  381.     luaO_tostring(L, o);
  382.     luaC_checkGC(L);
  383.     o = index2addr(L, idx);  /* previous call may reallocate the stack */
  384.     lua_unlock(L);
  385.   }
  386.   if (len != NULL)
  387.     *len = vslen(o);
  388.   return svalue(o);
  389. }
  390.  
  391.  
  392. LUA_API size_t lua_rawlen (lua_State *L, int idx) {
  393.   StkId o = index2addr(L, idx);
  394.   switch (ttype(o)) {
  395.     case LUA_TSHRSTR: return tsvalue(o)->shrlen;
  396.     case LUA_TLNGSTR: return tsvalue(o)->u.lnglen;
  397.     case LUA_TUSERDATA: return uvalue(o)->len;
  398.     case LUA_TTABLE: return luaH_getn(hvalue(o));
  399.     default: return 0;
  400.   }
  401. }
  402.  
  403.  
  404. LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
  405.   StkId o = index2addr(L, idx);
  406.   if (ttislcf(o)) return fvalue(o);
  407.   else if (ttisCclosure(o))
  408.     return clCvalue(o)->f;
  409.   else return NULL;  /* not a C function */
  410. }
  411.  
  412.  
  413. LUA_API void *lua_touserdata (lua_State *L, int idx) {
  414.   StkId o = index2addr(L, idx);
  415.   switch (ttnov(o)) {
  416.     case LUA_TUSERDATA: return getudatamem(uvalue(o));
  417.     case LUA_TLIGHTUSERDATA: return pvalue(o);
  418.     default: return NULL;
  419.   }
  420. }
  421.  
  422.  
  423. LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
  424.   StkId o = index2addr(L, idx);
  425.   return (!ttisthread(o)) ? NULL : thvalue(o);
  426. }
  427.  
  428.  
  429. LUA_API const void *lua_topointer (lua_State *L, int idx) {
  430.   StkId o = index2addr(L, idx);
  431.   switch (ttype(o)) {
  432.     case LUA_TTABLE: return hvalue(o);
  433.     case LUA_TLCL: return clLvalue(o);
  434.     case LUA_TCCL: return clCvalue(o);
  435.     case LUA_TLCF: return cast(void *, cast(size_t, fvalue(o)));
  436.     case LUA_TTHREAD: return thvalue(o);
  437.     case LUA_TUSERDATA: return getudatamem(uvalue(o));
  438.     case LUA_TLIGHTUSERDATA: return pvalue(o);
  439.     default: return NULL;
  440.   }
  441. }
  442.  
  443.  
  444.  
  445. /*
  446. ** push functions (C -> stack)
  447. */
  448.  
  449.  
  450. LUA_API void lua_pushnil (lua_State *L) {
  451.   lua_lock(L);
  452.   setnilvalue(L->top);
  453.   api_incr_top(L);
  454.   lua_unlock(L);
  455. }
  456.  
  457.  
  458. LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
  459.   lua_lock(L);
  460.   setfltvalue(L->top, n);
  461.   api_incr_top(L);
  462.   lua_unlock(L);
  463. }
  464.  
  465.  
  466. LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
  467.   lua_lock(L);
  468.   setivalue(L->top, n);
  469.   api_incr_top(L);
  470.   lua_unlock(L);
  471. }
  472.  
  473.  
  474. /*
  475. ** Pushes on the stack a string with given length. Avoid using 's' when
  476. ** 'len' == 0 (as 's' can be NULL in that case), due to later use of
  477. ** 'memcmp' and 'memcpy'.
  478. */
  479. LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
  480.   TString *ts;
  481.   lua_lock(L);
  482.   ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);
  483.   setsvalue2s(L, L->top, ts);
  484.   api_incr_top(L);
  485.   luaC_checkGC(L);
  486.   lua_unlock(L);
  487.   return getstr(ts);
  488. }
  489.  
  490.  
  491. LUA_API const char *lua_pushstring (lua_State *L, const char *s) {
  492.   lua_lock(L);
  493.   if (s == NULL)
  494.     setnilvalue(L->top);
  495.   else {
  496.     TString *ts;
  497.     ts = luaS_new(L, s);
  498.     setsvalue2s(L, L->top, ts);
  499.     s = getstr(ts);  /* internal copy's address */
  500.   }
  501.   api_incr_top(L);
  502.   luaC_checkGC(L);
  503.   lua_unlock(L);
  504.   return s;
  505. }
  506.  
  507.  
  508. LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
  509.                                       va_list argp) {
  510.   const char *ret;
  511.   lua_lock(L);
  512.   ret = luaO_pushvfstring(L, fmt, argp);
  513.   luaC_checkGC(L);
  514.   lua_unlock(L);
  515.   return ret;
  516. }
  517.  
  518.  
  519. LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
  520.   const char *ret;
  521.   va_list argp;
  522.   lua_lock(L);
  523.   va_start(argp, fmt);
  524.   ret = luaO_pushvfstring(L, fmt, argp);
  525.   va_end(argp);
  526.   luaC_checkGC(L);
  527.   lua_unlock(L);
  528.   return ret;
  529. }
  530.  
  531.  
  532. LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
  533.   lua_lock(L);
  534.   if (n == 0) {
  535.     setfvalue(L->top, fn);
  536.     api_incr_top(L);
  537.   }
  538.   else {
  539.     CClosure *cl;
  540.     api_checknelems(L, n);
  541.     api_check(L, n <= MAXUPVAL, "upvalue index too large");
  542.     cl = luaF_newCclosure(L, n);
  543.     cl->f = fn;
  544.     L->top -= n;
  545.     while (n--) {
  546.       setobj2n(L, &cl->upvalue[n], L->top + n);
  547.       /* does not need barrier because closure is white */
  548.     }
  549.     setclCvalue(L, L->top, cl);
  550.     api_incr_top(L);
  551.     luaC_checkGC(L);
  552.   }
  553.   lua_unlock(L);
  554. }
  555.  
  556.  
  557. LUA_API void lua_pushboolean (lua_State *L, int b) {
  558.   lua_lock(L);
  559.   setbvalue(L->top, (b != 0));  /* ensure that true is 1 */
  560.   api_incr_top(L);
  561.   lua_unlock(L);
  562. }
  563.  
  564.  
  565. LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
  566.   lua_lock(L);
  567.   setpvalue(L->top, p);
  568.   api_incr_top(L);
  569.   lua_unlock(L);
  570. }
  571.  
  572.  
  573. LUA_API int lua_pushthread (lua_State *L) {
  574.   lua_lock(L);
  575.   setthvalue(L, L->top, L);
  576.   api_incr_top(L);
  577.   lua_unlock(L);
  578.   return (G(L)->mainthread == L);
  579. }
  580.  
  581.  
  582.  
  583. /*
  584. ** get functions (Lua -> stack)
  585. */
  586.  
  587.  
  588. static int auxgetstr (lua_State *L, const TValue *t, const char *k) {
  589.   const TValue *slot;
  590.   TString *str = luaS_new(L, k);
  591.   if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
  592.     setobj2s(L, L->top, slot);
  593.     api_incr_top(L);
  594.   }
  595.   else {
  596.     setsvalue2s(L, L->top, str);
  597.     api_incr_top(L);
  598.     luaV_finishget(L, t, L->top - 1, L->top - 1, slot);
  599.   }
  600.   lua_unlock(L);
  601.   return ttnov(L->top - 1);
  602. }
  603.  
  604.  
  605. LUA_API int lua_getglobal (lua_State *L, const char *name) {
  606.   Table *reg = hvalue(&G(L)->l_registry);
  607.   lua_lock(L);
  608.   return auxgetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
  609. }
  610.  
  611.  
  612. LUA_API int lua_gettable (lua_State *L, int idx) {
  613.   StkId t;
  614.   lua_lock(L);
  615.   t = index2addr(L, idx);
  616.   luaV_gettable(L, t, L->top - 1, L->top - 1);
  617.   lua_unlock(L);
  618.   return ttnov(L->top - 1);
  619. }
  620.  
  621.  
  622. LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
  623.   lua_lock(L);
  624.   return auxgetstr(L, index2addr(L, idx), k);
  625. }
  626.  
  627.  
  628. LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
  629.   StkId t;
  630.   const TValue *slot;
  631.   lua_lock(L);
  632.   t = index2addr(L, idx);
  633.   if (luaV_fastget(L, t, n, slot, luaH_getint)) {
  634.     setobj2s(L, L->top, slot);
  635.     api_incr_top(L);
  636.   }
  637.   else {
  638.     setivalue(L->top, n);
  639.     api_incr_top(L);
  640.     luaV_finishget(L, t, L->top - 1, L->top - 1, slot);
  641.   }
  642.   lua_unlock(L);
  643.   return ttnov(L->top - 1);
  644. }
  645.  
  646.  
  647. LUA_API int lua_rawget (lua_State *L, int idx) {
  648.   StkId t;
  649.   lua_lock(L);
  650.   t = index2addr(L, idx);
  651.   api_check(L, ttistable(t), "table expected");
  652.   setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
  653.   lua_unlock(L);
  654.   return ttnov(L->top - 1);
  655. }
  656.  
  657.  
  658. LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
  659.   StkId t;
  660.   lua_lock(L);
  661.   t = index2addr(L, idx);
  662.   api_check(L, ttistable(t), "table expected");
  663.   setobj2s(L, L->top, luaH_getint(hvalue(t), n));
  664.   api_incr_top(L);
  665.   lua_unlock(L);
  666.   return ttnov(L->top - 1);
  667. }
  668.  
  669.  
  670. LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
  671.   StkId t;
  672.   TValue k;
  673.   lua_lock(L);
  674.   t = index2addr(L, idx);
  675.   api_check(L, ttistable(t), "table expected");
  676.   setpvalue(&k, cast(void *, p));
  677.   setobj2s(L, L->top, luaH_get(hvalue(t), &k));
  678.   api_incr_top(L);
  679.   lua_unlock(L);
  680.   return ttnov(L->top - 1);
  681. }
  682.  
  683.  
  684. LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
  685.   Table *t;
  686.   lua_lock(L);
  687.   t = luaH_new(L);
  688.   sethvalue(L, L->top, t);
  689.   api_incr_top(L);
  690.   if (narray > 0 || nrec > 0)
  691.     luaH_resize(L, t, narray, nrec);
  692.   luaC_checkGC(L);
  693.   lua_unlock(L);
  694. }
  695.  
  696.  
  697. LUA_API int lua_getmetatable (lua_State *L, int objindex) {
  698.   const TValue *obj;
  699.   Table *mt;
  700.   int res = 0;
  701.   lua_lock(L);
  702.   obj = index2addr(L, objindex);
  703.   switch (ttnov(obj)) {
  704.     case LUA_TTABLE:
  705.       mt = hvalue(obj)->metatable;
  706.       break;
  707.     case LUA_TUSERDATA:
  708.       mt = uvalue(obj)->metatable;
  709.       break;
  710.     default:
  711.       mt = G(L)->mt[ttnov(obj)];
  712.       break;
  713.   }
  714.   if (mt != NULL) {
  715.     sethvalue(L, L->top, mt);
  716.     api_incr_top(L);
  717.     res = 1;
  718.   }
  719.   lua_unlock(L);
  720.   return res;
  721. }
  722.  
  723.  
  724. LUA_API int lua_getuservalue (lua_State *L, int idx) {
  725.   StkId o;
  726.   lua_lock(L);
  727.   o = index2addr(L, idx);
  728.   api_check(L, ttisfulluserdata(o), "full userdata expected");
  729.   getuservalue(L, uvalue(o), L->top);
  730.   api_incr_top(L);
  731.   lua_unlock(L);
  732.   return ttnov(L->top - 1);
  733. }
  734.  
  735.  
  736. /*
  737. ** set functions (stack -> Lua)
  738. */
  739.  
  740. /*
  741. ** t[k] = value at the top of the stack (where 'k' is a string)
  742. */
  743. static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
  744.   const TValue *slot;
  745.   TString *str = luaS_new(L, k);
  746.   api_checknelems(L, 1);
  747.   if (luaV_fastset(L, t, str, slot, luaH_getstr, L->top - 1))
  748.     L->top--;  /* pop value */
  749.   else {
  750.     setsvalue2s(L, L->top, str);  /* push 'str' (to make it a TValue) */
  751.     api_incr_top(L);
  752.     luaV_finishset(L, t, L->top - 1, L->top - 2, slot);
  753.     L->top -= 2;  /* pop value and key */
  754.   }
  755.   lua_unlock(L);  /* lock done by caller */
  756. }
  757.  
  758.  
  759. LUA_API void lua_setglobal (lua_State *L, const char *name) {
  760.   Table *reg = hvalue(&G(L)->l_registry);
  761.   lua_lock(L);  /* unlock done in 'auxsetstr' */
  762.   auxsetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
  763. }
  764.  
  765.  
  766. LUA_API void lua_settable (lua_State *L, int idx) {
  767.   StkId t;
  768.   lua_lock(L);
  769.   api_checknelems(L, 2);
  770.   t = index2addr(L, idx);
  771.   luaV_settable(L, t, L->top - 2, L->top - 1);
  772.   L->top -= 2;  /* pop index and value */
  773.   lua_unlock(L);
  774. }
  775.  
  776.  
  777. LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
  778.   lua_lock(L);  /* unlock done in 'auxsetstr' */
  779.   auxsetstr(L, index2addr(L, idx), k);
  780. }
  781.  
  782.  
  783. LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {
  784.   StkId t;
  785.   const TValue *slot;
  786.   lua_lock(L);
  787.   api_checknelems(L, 1);
  788.   t = index2addr(L, idx);
  789.   if (luaV_fastset(L, t, n, slot, luaH_getint, L->top - 1))
  790.     L->top--;  /* pop value */
  791.   else {
  792.     setivalue(L->top, n);
  793.     api_incr_top(L);
  794.     luaV_finishset(L, t, L->top - 1, L->top - 2, slot);
  795.     L->top -= 2;  /* pop value and key */
  796.   }
  797.   lua_unlock(L);
  798. }
  799.  
  800.  
  801. LUA_API void lua_rawset (lua_State *L, int idx) {
  802.   StkId o;
  803.   TValue *slot;
  804.   lua_lock(L);
  805.   api_checknelems(L, 2);
  806.   o = index2addr(L, idx);
  807.   api_check(L, ttistable(o), "table expected");
  808.   slot = luaH_set(L, hvalue(o), L->top - 2);
  809.   setobj2t(L, slot, L->top - 1);
  810.   invalidateTMcache(hvalue(o));
  811.   luaC_barrierback(L, hvalue(o), L->top-1);
  812.   L->top -= 2;
  813.   lua_unlock(L);
  814. }
  815.  
  816.  
  817. LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
  818.   StkId o;
  819.   lua_lock(L);
  820.   api_checknelems(L, 1);
  821.   o = index2addr(L, idx);
  822.   api_check(L, ttistable(o), "table expected");
  823.   luaH_setint(L, hvalue(o), n, L->top - 1);
  824.   luaC_barrierback(L, hvalue(o), L->top-1);
  825.   L->top--;
  826.   lua_unlock(L);
  827. }
  828.  
  829.  
  830. LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
  831.   StkId o;
  832.   TValue k, *slot;
  833.   lua_lock(L);
  834.   api_checknelems(L, 1);
  835.   o = index2addr(L, idx);
  836.   api_check(L, ttistable(o), "table expected");
  837.   setpvalue(&k, cast(void *, p));
  838.   slot = luaH_set(L, hvalue(o), &k);
  839.   setobj2t(L, slot, L->top - 1);
  840.   luaC_barrierback(L, hvalue(o), L->top - 1);
  841.   L->top--;
  842.   lua_unlock(L);
  843. }
  844.  
  845.  
  846. LUA_API int lua_setmetatable (lua_State *L, int objindex) {
  847.   TValue *obj;
  848.   Table *mt;
  849.   lua_lock(L);
  850.   api_checknelems(L, 1);
  851.   obj = index2addr(L, objindex);
  852.   if (ttisnil(L->top - 1))
  853.     mt = NULL;
  854.   else {
  855.     api_check(L, ttistable(L->top - 1), "table expected");
  856.     mt = hvalue(L->top - 1);
  857.   }
  858.   switch (ttnov(obj)) {
  859.     case LUA_TTABLE: {
  860.       hvalue(obj)->metatable = mt;
  861.       if (mt) {
  862.         luaC_objbarrier(L, gcvalue(obj), mt);
  863.         luaC_checkfinalizer(L, gcvalue(obj), mt);
  864.       }
  865.       break;
  866.     }
  867.     case LUA_TUSERDATA: {
  868.       uvalue(obj)->metatable = mt;
  869.       if (mt) {
  870.         luaC_objbarrier(L, uvalue(obj), mt);
  871.         luaC_checkfinalizer(L, gcvalue(obj), mt);
  872.       }
  873.       break;
  874.     }
  875.     default: {
  876.       G(L)->mt[ttnov(obj)] = mt;
  877.       break;
  878.     }
  879.   }
  880.   L->top--;
  881.   lua_unlock(L);
  882.   return 1;
  883. }
  884.  
  885.  
  886. LUA_API void lua_setuservalue (lua_State *L, int idx) {
  887.   StkId o;
  888.   lua_lock(L);
  889.   api_checknelems(L, 1);
  890.   o = index2addr(L, idx);
  891.   api_check(L, ttisfulluserdata(o), "full userdata expected");
  892.   setuservalue(L, uvalue(o), L->top - 1);
  893.   luaC_barrier(L, gcvalue(o), L->top - 1);
  894.   L->top--;
  895.   lua_unlock(L);
  896. }
  897.  
  898.  
  899. /*
  900. ** 'load' and 'call' functions (run Lua code)
  901. */
  902.  
  903.  
  904. #define checkresults(L,na,nr) \
  905.      api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
  906.         "results from function overflow current stack size")
  907.  
  908.  
  909. LUA_API void lua_callk (lua_State *L, int nargs, int nresults,
  910.                         lua_KContext ctx, lua_KFunction k) {
  911.   StkId func;
  912.   lua_lock(L);
  913.   api_check(L, k == NULL || !isLua(L->ci),
  914.     "cannot use continuations inside hooks");
  915.   api_checknelems(L, nargs+1);
  916.   api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
  917.   checkresults(L, nargs, nresults);
  918.   func = L->top - (nargs+1);
  919.   if (k != NULL && L->nny == 0) {  /* need to prepare continuation? */
  920.     L->ci->u.c.k = k;  /* save continuation */
  921.     L->ci->u.c.ctx = ctx;  /* save context */
  922.     luaD_call(L, func, nresults);  /* do the call */
  923.   }
  924.   else  /* no continuation or no yieldable */
  925.     luaD_callnoyield(L, func, nresults);  /* just do the call */
  926.   adjustresults(L, nresults);
  927.   lua_unlock(L);
  928. }
  929.  
  930.  
  931.  
  932. /*
  933. ** Execute a protected call.
  934. */
  935. struct CallS {  /* data to 'f_call' */
  936.   StkId func;
  937.   int nresults;
  938. };
  939.  
  940.  
  941. static void f_call (lua_State *L, void *ud) {
  942.   struct CallS *c = cast(struct CallS *, ud);
  943.   luaD_callnoyield(L, c->func, c->nresults);
  944. }
  945.  
  946.  
  947.  
  948. LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
  949.                         lua_KContext ctx, lua_KFunction k) {
  950.   struct CallS c;
  951.   int status;
  952.   ptrdiff_t func;
  953.   lua_lock(L);
  954.   api_check(L, k == NULL || !isLua(L->ci),
  955.     "cannot use continuations inside hooks");
  956.   api_checknelems(L, nargs+1);
  957.   api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
  958.   checkresults(L, nargs, nresults);
  959.   if (errfunc == 0)
  960.     func = 0;
  961.   else {
  962.     StkId o = index2addr(L, errfunc);
  963.     api_checkstackindex(L, errfunc, o);
  964.     func = savestack(L, o);
  965.   }
  966.   c.func = L->top - (nargs+1);  /* function to be called */
  967.   if (k == NULL || L->nny > 0) {  /* no continuation or no yieldable? */
  968.     c.nresults = nresults;  /* do a 'conventional' protected call */
  969.     status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
  970.   }
  971.   else {  /* prepare continuation (call is already protected by 'resume') */
  972.     CallInfo *ci = L->ci;
  973.     ci->u.c.k = k;  /* save continuation */
  974.     ci->u.c.ctx = ctx;  /* save context */
  975.     /* save information for error recovery */
  976.     ci->extra = savestack(L, c.func);
  977.     ci->u.c.old_errfunc = L->errfunc;
  978.     L->errfunc = func;
  979.     setoah(ci->callstatus, L->allowhook);  /* save value of 'allowhook' */
  980.     ci->callstatus |= CIST_YPCALL;  /* function can do error recovery */
  981.     luaD_call(L, c.func, nresults);  /* do the call */
  982.     ci->callstatus &= ~CIST_YPCALL;
  983.     L->errfunc = ci->u.c.old_errfunc;
  984.     status = LUA_OK;  /* if it is here, there were no errors */
  985.   }
  986.   adjustresults(L, nresults);
  987.   lua_unlock(L);
  988.   return status;
  989. }
  990.  
  991.  
  992. LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
  993.                       const char *chunkname, const char *mode) {
  994.   ZIO z;
  995.   int status;
  996.   lua_lock(L);
  997.   if (!chunkname) chunkname = "?";
  998.   luaZ_init(L, &z, reader, data);
  999.   status = luaD_protectedparser(L, &z, chunkname, mode);
  1000.   if (status == LUA_OK) {  /* no errors? */
  1001.     LClosure *f = clLvalue(L->top - 1);  /* get newly created function */
  1002.     if (f->nupvalues >= 1) {  /* does it have an upvalue? */
  1003.       /* get global table from registry */
  1004.       Table *reg = hvalue(&G(L)->l_registry);
  1005.       const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
  1006.       /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
  1007.       setobj(L, f->upvals[0]->v, gt);
  1008.       luaC_upvalbarrier(L, f->upvals[0]);
  1009.     }
  1010.   }
  1011.   lua_unlock(L);
  1012.   return status;
  1013. }
  1014.  
  1015.  
  1016. LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) {
  1017.   int status;
  1018.   TValue *o;
  1019.   lua_lock(L);
  1020.   api_checknelems(L, 1);
  1021.   o = L->top - 1;
  1022.   if (isLfunction(o))
  1023.     status = luaU_dump(L, getproto(o), writer, data, strip);
  1024.   else
  1025.     status = 1;
  1026.   lua_unlock(L);
  1027.   return status;
  1028. }
  1029.  
  1030.  
  1031. LUA_API int lua_status (lua_State *L) {
  1032.   return L->status;
  1033. }
  1034.  
  1035.  
  1036. /*
  1037. ** Garbage-collection function
  1038. */
  1039.  
  1040. LUA_API int lua_gc (lua_State *L, int what, int data) {
  1041.   int res = 0;
  1042.   global_State *g;
  1043.   lua_lock(L);
  1044.   g = G(L);
  1045.   switch (what) {
  1046.     case LUA_GCSTOP: {
  1047.       g->gcrunning = 0;
  1048.       break;
  1049.     }
  1050.     case LUA_GCRESTART: {
  1051.       luaE_setdebt(g, 0);
  1052.       g->gcrunning = 1;
  1053.       break;
  1054.     }
  1055.     case LUA_GCCOLLECT: {
  1056.       luaC_fullgc(L, 0);
  1057.       break;
  1058.     }
  1059.     case LUA_GCCOUNT: {
  1060.       /* GC values are expressed in Kbytes: #bytes/2^10 */
  1061.       res = cast_int(gettotalbytes(g) >> 10);
  1062.       break;
  1063.     }
  1064.     case LUA_GCCOUNTB: {
  1065.       res = cast_int(gettotalbytes(g) & 0x3ff);
  1066.       break;
  1067.     }
  1068.     case LUA_GCSTEP: {
  1069.       l_mem debt = 1;  /* =1 to signal that it did an actual step */
  1070.       lu_byte oldrunning = g->gcrunning;
  1071.       g->gcrunning = 1;  /* allow GC to run */
  1072.       if (data == 0) {
  1073.         luaE_setdebt(g, -GCSTEPSIZE);  /* to do a "small" step */
  1074.         luaC_step(L);
  1075.       }
  1076.       else {  /* add 'data' to total debt */
  1077.         debt = cast(l_mem, data) * 1024 + g->GCdebt;
  1078.         luaE_setdebt(g, debt);
  1079.         luaC_checkGC(L);
  1080.       }
  1081.       g->gcrunning = oldrunning;  /* restore previous state */
  1082.       if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */
  1083.         res = 1;  /* signal it */
  1084.       break;
  1085.     }
  1086.     case LUA_GCSETPAUSE: {
  1087.       res = g->gcpause;
  1088.       g->gcpause = data;
  1089.       break;
  1090.     }
  1091.     case LUA_GCSETSTEPMUL: {
  1092.       res = g->gcstepmul;
  1093.       if (data < 40) data = 40;  /* avoid ridiculous low values (and 0) */
  1094.       g->gcstepmul = data;
  1095.       break;
  1096.     }
  1097.     case LUA_GCISRUNNING: {
  1098.       res = g->gcrunning;
  1099.       break;
  1100.     }
  1101.     default: res = -1;  /* invalid option */
  1102.   }
  1103.   lua_unlock(L);
  1104.   return res;
  1105. }
  1106.  
  1107.  
  1108.  
  1109. /*
  1110. ** miscellaneous functions
  1111. */
  1112.  
  1113.  
  1114. LUA_API int lua_error (lua_State *L) {
  1115.   lua_lock(L);
  1116.   api_checknelems(L, 1);
  1117.   luaG_errormsg(L);
  1118.   /* code unreachable; will unlock when control actually leaves the kernel */
  1119.   return 0;  /* to avoid warnings */
  1120. }
  1121.  
  1122.  
  1123. LUA_API int lua_next (lua_State *L, int idx) {
  1124.   StkId t;
  1125.   int more;
  1126.   lua_lock(L);
  1127.   t = index2addr(L, idx);
  1128.   api_check(L, ttistable(t), "table expected");
  1129.   more = luaH_next(L, hvalue(t), L->top - 1);
  1130.   if (more) {
  1131.     api_incr_top(L);
  1132.   }
  1133.   else  /* no more elements */
  1134.     L->top -= 1;  /* remove key */
  1135.   lua_unlock(L);
  1136.   return more;
  1137. }
  1138.  
  1139.  
  1140. LUA_API void lua_concat (lua_State *L, int n) {
  1141.   lua_lock(L);
  1142.   api_checknelems(L, n);
  1143.   if (n >= 2) {
  1144.     luaV_concat(L, n);
  1145.   }
  1146.   else if (n == 0) {  /* push empty string */
  1147.     setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
  1148.     api_incr_top(L);
  1149.   }
  1150.   /* else n == 1; nothing to do */
  1151.   luaC_checkGC(L);
  1152.   lua_unlock(L);
  1153. }
  1154.  
  1155.  
  1156. LUA_API void lua_len (lua_State *L, int idx) {
  1157.   StkId t;
  1158.   lua_lock(L);
  1159.   t = index2addr(L, idx);
  1160.   luaV_objlen(L, L->top, t);
  1161.   api_incr_top(L);
  1162.   lua_unlock(L);
  1163. }
  1164.  
  1165.  
  1166. LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
  1167.   lua_Alloc f;
  1168.   lua_lock(L);
  1169.   if (ud) *ud = G(L)->ud;
  1170.   f = G(L)->frealloc;
  1171.   lua_unlock(L);
  1172.   return f;
  1173. }
  1174.  
  1175.  
  1176. LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
  1177.   lua_lock(L);
  1178.   G(L)->ud = ud;
  1179.   G(L)->frealloc = f;
  1180.   lua_unlock(L);
  1181. }
  1182.  
  1183.  
  1184. LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
  1185.   Udata *u;
  1186.   lua_lock(L);
  1187.   u = luaS_newudata(L, size);
  1188.   setuvalue(L, L->top, u);
  1189.   api_incr_top(L);
  1190.   luaC_checkGC(L);
  1191.   lua_unlock(L);
  1192.   return getudatamem(u);
  1193. }
  1194.  
  1195.  
  1196.  
  1197. static const char *aux_upvalue (StkId fi, int n, TValue **val,
  1198.                                 CClosure **owner, UpVal **uv) {
  1199.   switch (ttype(fi)) {
  1200.     case LUA_TCCL: {  /* C closure */
  1201.       CClosure *f = clCvalue(fi);
  1202.       if (!(1 <= n && n <= f->nupvalues)) return NULL;
  1203.       *val = &f->upvalue[n-1];
  1204.       if (owner) *owner = f;
  1205.       return "";
  1206.     }
  1207.     case LUA_TLCL: {  /* Lua closure */
  1208.       LClosure *f = clLvalue(fi);
  1209.       TString *name;
  1210.       Proto *p = f->p;
  1211.       if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
  1212.       *val = f->upvals[n-1]->v;
  1213.       if (uv) *uv = f->upvals[n - 1];
  1214.       name = p->upvalues[n-1].name;
  1215.       return (name == NULL) ? "(*no name)" : getstr(name);
  1216.     }
  1217.     default: return NULL;  /* not a closure */
  1218.   }
  1219. }
  1220.  
  1221.  
  1222. LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
  1223.   const char *name;
  1224.   TValue *val = NULL;  /* to avoid warnings */
  1225.   lua_lock(L);
  1226.   name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL, NULL);
  1227.   if (name) {
  1228.     setobj2s(L, L->top, val);
  1229.     api_incr_top(L);
  1230.   }
  1231.   lua_unlock(L);
  1232.   return name;
  1233. }
  1234.  
  1235.  
  1236. LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
  1237.   const char *name;
  1238.   TValue *val = NULL;  /* to avoid warnings */
  1239.   CClosure *owner = NULL;
  1240.   UpVal *uv = NULL;
  1241.   StkId fi;
  1242.   lua_lock(L);
  1243.   fi = index2addr(L, funcindex);
  1244.   api_checknelems(L, 1);
  1245.   name = aux_upvalue(fi, n, &val, &owner, &uv);
  1246.   if (name) {
  1247.     L->top--;
  1248.     setobj(L, val, L->top);
  1249.     if (owner) { luaC_barrier(L, owner, L->top); }
  1250.     else if (uv) { luaC_upvalbarrier(L, uv); }
  1251.   }
  1252.   lua_unlock(L);
  1253.   return name;
  1254. }
  1255.  
  1256.  
  1257. static UpVal **getupvalref (lua_State *L, int fidx, int n) {
  1258.   LClosure *f;
  1259.   StkId fi = index2addr(L, fidx);
  1260.   api_check(L, ttisLclosure(fi), "Lua function expected");
  1261.   f = clLvalue(fi);
  1262.   api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
  1263.   return &f->upvals[n - 1];  /* get its upvalue pointer */
  1264. }
  1265.  
  1266.  
  1267. LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) {
  1268.   StkId fi = index2addr(L, fidx);
  1269.   switch (ttype(fi)) {
  1270.     case LUA_TLCL: {  /* lua closure */
  1271.       return *getupvalref(L, fidx, n);
  1272.     }
  1273.     case LUA_TCCL: {  /* C closure */
  1274.       CClosure *f = clCvalue(fi);
  1275.       api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index");
  1276.       return &f->upvalue[n - 1];
  1277.     }
  1278.     default: {
  1279.       api_check(L, 0, "closure expected");
  1280.       return NULL;
  1281.     }
  1282.   }
  1283. }
  1284.  
  1285.  
  1286. LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1,
  1287.                                             int fidx2, int n2) {
  1288.   UpVal **up1 = getupvalref(L, fidx1, n1);
  1289.   UpVal **up2 = getupvalref(L, fidx2, n2);
  1290.   if (*up1 == *up2)
  1291.     return;
  1292.   luaC_upvdeccount(L, *up1);
  1293.   *up1 = *up2;
  1294.   (*up1)->refcount++;
  1295.   if (upisopen(*up1)) (*up1)->u.open.touched = 1;
  1296.   luaC_upvalbarrier(L, *up1);
  1297. }
  1298.  
  1299.  
  1300.