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