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