source/libs/luajit/LuaJIT-src/src/lib_base.c

   1 /*
   2 ** Base and coroutine library.
   3 ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
   4 **
   5 ** Major portions taken verbatim or adapted from the Lua interpreter.
   6 ** Copyright (C) 1994-2011 Lua.org, PUC-Rio. See Copyright Notice in lua.h
   7 */
   8
   9 #include <stdio.h>
  10
  11 #define lib_base_c
  12 #define LUA_LIB
  13
  14 #include "lua.h"
  15 #include "lauxlib.h"
  16 #include "lualib.h"
  17
  18 #include "lj_obj.h"
  19 #include "lj_gc.h"
  20 #include "lj_err.h"
  21 #include "lj_debug.h"
  22 #include "lj_str.h"
  23 #include "lj_tab.h"
  24 #include "lj_meta.h"
  25 #include "lj_state.h"
  26 #if LJ_HASFFI
  27 #include "lj_ctype.h"
  28 #include "lj_cconv.h"
  29 #endif
  30 #include "lj_bc.h"
  31 #include "lj_ff.h"
  32 #include "lj_dispatch.h"
  33 #include "lj_char.h"
  34 #include "lj_strscan.h"
  35 #include "lj_strfmt.h"
  36 #include "lj_lib.h"
  37
  38 /* -- Base library: checks ------------------------------------------------ */
  39
  40 #define LJLIB_MODULE_base
  41
  42 LJLIB_ASM(assert)               LJLIB_REC(.)
  43 {
  44   GCstr *s;
  45   lj_lib_checkany(L, 1);
  46   s = lj_lib_optstr(L, 2);
  47   if (s)
  48     lj_err_callermsg(L, strdata(s));
  49   else
  50     lj_err_caller(L, LJ_ERR_ASSERT);
  51   return FFH_UNREACHABLE;
  52 }
  53
  54 /* ORDER LJ_T */
  55 LJLIB_PUSH("nil")
  56 LJLIB_PUSH("boolean")
  57 LJLIB_PUSH(top-1)  /* boolean */
  58 LJLIB_PUSH("userdata")
  59 LJLIB_PUSH("string")
  60 LJLIB_PUSH("upval")
  61 LJLIB_PUSH("thread")
  62 LJLIB_PUSH("proto")
  63 LJLIB_PUSH("function")
  64 LJLIB_PUSH("trace")
  65 LJLIB_PUSH("cdata")
  66 LJLIB_PUSH("table")
  67 LJLIB_PUSH(top-9)  /* userdata */
  68 LJLIB_PUSH("number")
  69 LJLIB_ASM_(type)                LJLIB_REC(.)
  70 /* Recycle the lj_lib_checkany(L, 1) from assert. */
  71
  72 /* -- Base library: iterators --------------------------------------------- */
  73
  74 /* This solves a circular dependency problem -- change FF_next_N as needed. */
  75 LJ_STATIC_ASSERT((int)FF_next == FF_next_N);
  76
  77 LJLIB_ASM(next)
  78 {
  79   lj_lib_checktab(L, 1);
  80   return FFH_UNREACHABLE;
  81 }
  82
  83 #if LJ_52 || LJ_HASFFI
  84 static int ffh_pairs(lua_State *L, MMS mm)
  85 {
  86   TValue *o = lj_lib_checkany(L, 1);
  87   cTValue *mo = lj_meta_lookup(L, o, mm);
  88   if ((LJ_52 || tviscdata(o)) && !tvisnil(mo)) {
  89     L->top = o+1;  /* Only keep one argument. */
  90     copyTV(L, L->base-1-LJ_FR2, mo);  /* Replace callable. */
  91     return FFH_TAILCALL;
  92   } else {
  93     if (!tvistab(o)) lj_err_argt(L, 1, LUA_TTABLE);
  94     if (LJ_FR2) { copyTV(L, o-1, o); o--; }
  95     setfuncV(L, o-1, funcV(lj_lib_upvalue(L, 1)));
  96     if (mm == MM_pairs) setnilV(o+1); else setintV(o+1, 0);
  97     return FFH_RES(3);
  98   }
  99 }
 100 #else
 101 #define ffh_pairs(L, mm)        (lj_lib_checktab(L, 1), FFH_UNREACHABLE)
 102 #endif
 103
 104 LJLIB_PUSH(lastcl)
 105 LJLIB_ASM(pairs)                LJLIB_REC(xpairs 0)
 106 {
 107   return ffh_pairs(L, MM_pairs);
 108 }
 109
 110 LJLIB_NOREGUV LJLIB_ASM(ipairs_aux)     LJLIB_REC(.)
 111 {
 112   lj_lib_checktab(L, 1);
 113   lj_lib_checkint(L, 2);
 114   return FFH_UNREACHABLE;
 115 }
 116
 117 LJLIB_PUSH(lastcl)
 118 LJLIB_ASM(ipairs)               LJLIB_REC(xpairs 1)
 119 {
 120   return ffh_pairs(L, MM_ipairs);
 121 }
 122
 123 /* -- Base library: getters and setters ----------------------------------- */
 124
 125 LJLIB_ASM_(getmetatable)        LJLIB_REC(.)
 126 /* Recycle the lj_lib_checkany(L, 1) from assert. */
 127
 128 LJLIB_ASM(setmetatable)         LJLIB_REC(.)
 129 {
 130   GCtab *t = lj_lib_checktab(L, 1);
 131   GCtab *mt = lj_lib_checktabornil(L, 2);
 132   if (!tvisnil(lj_meta_lookup(L, L->base, MM_metatable)))
 133     lj_err_caller(L, LJ_ERR_PROTMT);
 134   setgcref(t->metatable, obj2gco(mt));
 135   if (mt) { lj_gc_objbarriert(L, t, mt); }
 136   settabV(L, L->base-1-LJ_FR2, t);
 137   return FFH_RES(1);
 138 }
 139
 140 LJLIB_CF(getfenv)               LJLIB_REC(.)
 141 {
 142   GCfunc *fn;
 143   cTValue *o = L->base;
 144   if (!(o < L->top && tvisfunc(o))) {
 145     int level = lj_lib_optint(L, 1, 1);
 146     o = lj_debug_frame(L, level, &level);
 147     if (o == NULL)
 148       lj_err_arg(L, 1, LJ_ERR_INVLVL);
 149     if (LJ_FR2) o--;
 150   }
 151   fn = &gcval(o)->fn;
 152   settabV(L, L->top++, isluafunc(fn) ? tabref(fn->l.env) : tabref(L->env));
 153   return 1;
 154 }
 155
 156 LJLIB_CF(setfenv)
 157 {
 158   GCfunc *fn;
 159   GCtab *t = lj_lib_checktab(L, 2);
 160   cTValue *o = L->base;
 161   if (!(o < L->top && tvisfunc(o))) {
 162     int level = lj_lib_checkint(L, 1);
 163     if (level == 0) {
 164       /* NOBARRIER: A thread (i.e. L) is never black. */
 165       setgcref(L->env, obj2gco(t));
 166       return 0;
 167     }
 168     o = lj_debug_frame(L, level, &level);
 169     if (o == NULL)
 170       lj_err_arg(L, 1, LJ_ERR_INVLVL);
 171     if (LJ_FR2) o--;
 172   }
 173   fn = &gcval(o)->fn;
 174   if (!isluafunc(fn))
 175     lj_err_caller(L, LJ_ERR_SETFENV);
 176   setgcref(fn->l.env, obj2gco(t));
 177   lj_gc_objbarrier(L, obj2gco(fn), t);
 178   setfuncV(L, L->top++, fn);
 179   return 1;
 180 }
 181
 182 LJLIB_ASM(rawget)               LJLIB_REC(.)
 183 {
 184   lj_lib_checktab(L, 1);
 185   lj_lib_checkany(L, 2);
 186   return FFH_UNREACHABLE;
 187 }
 188
 189 LJLIB_CF(rawset)                LJLIB_REC(.)
 190 {
 191   lj_lib_checktab(L, 1);
 192   lj_lib_checkany(L, 2);
 193   L->top = 1+lj_lib_checkany(L, 3);
 194   lua_rawset(L, 1);
 195   return 1;
 196 }
 197
 198 LJLIB_CF(rawequal)              LJLIB_REC(.)
 199 {
 200   cTValue *o1 = lj_lib_checkany(L, 1);
 201   cTValue *o2 = lj_lib_checkany(L, 2);
 202   setboolV(L->top-1, lj_obj_equal(o1, o2));
 203   return 1;
 204 }
 205
 206 #if LJ_52
 207 LJLIB_CF(rawlen)                LJLIB_REC(.)
 208 {
 209   cTValue *o = L->base;
 210   int32_t len;
 211   if (L->top > o && tvisstr(o))
 212     len = (int32_t)strV(o)->len;
 213   else
 214     len = (int32_t)lj_tab_len(lj_lib_checktab(L, 1));
 215   setintV(L->top-1, len);
 216   return 1;
 217 }
 218 #endif
 219
 220 LJLIB_CF(unpack)
 221 {
 222   GCtab *t = lj_lib_checktab(L, 1);
 223   int32_t n, i = lj_lib_optint(L, 2, 1);
 224   int32_t e = (L->base+3-1 < L->top && !tvisnil(L->base+3-1)) ?
 225               lj_lib_checkint(L, 3) : (int32_t)lj_tab_len(t);
 226   if (i > e) return 0;
 227   n = e - i + 1;
 228   if (n <= 0 || !lua_checkstack(L, n))
 229     lj_err_caller(L, LJ_ERR_UNPACK);
 230   do {
 231     cTValue *tv = lj_tab_getint(t, i);
 232     if (tv) {
 233       copyTV(L, L->top++, tv);
 234     } else {
 235       setnilV(L->top++);
 236     }
 237   } while (i++ < e);
 238   return n;
 239 }
 240
 241 LJLIB_CF(select)                LJLIB_REC(.)
 242 {
 243   int32_t n = (int32_t)(L->top - L->base);
 244   if (n >= 1 && tvisstr(L->base) && *strVdata(L->base) == '#') {
 245     setintV(L->top-1, n-1);
 246     return 1;
 247   } else {
 248     int32_t i = lj_lib_checkint(L, 1);
 249     if (i < 0) i = n + i; else if (i > n) i = n;
 250     if (i < 1)
 251       lj_err_arg(L, 1, LJ_ERR_IDXRNG);
 252     return n - i;
 253   }
 254 }
 255
 256 /* -- Base library: conversions ------------------------------------------- */
 257
 258 LJLIB_ASM(tonumber)             LJLIB_REC(.)
 259 {
 260   int32_t base = lj_lib_optint(L, 2, 10);
 261   if (base == 10) {
 262     TValue *o = lj_lib_checkany(L, 1);
 263     if (lj_strscan_numberobj(o)) {
 264       copyTV(L, L->base-1-LJ_FR2, o);
 265       return FFH_RES(1);
 266     }
 267 #if LJ_HASFFI
 268     if (tviscdata(o)) {
 269       CTState *cts = ctype_cts(L);
 270       CType *ct = lj_ctype_rawref(cts, cdataV(o)->ctypeid);
 271       if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
 272       if (ctype_isnum(ct->info) || ctype_iscomplex(ct->info)) {
 273         if (LJ_DUALNUM && ctype_isinteger_or_bool(ct->info) &&
 274             ct->size <= 4 && !(ct->size == 4 && (ct->info & CTF_UNSIGNED))) {
 275           int32_t i;
 276           lj_cconv_ct_tv(cts, ctype_get(cts, CTID_INT32), (uint8_t *)&i, o, 0);
 277           setintV(L->base-1-LJ_FR2, i);
 278           return FFH_RES(1);
 279         }
 280         lj_cconv_ct_tv(cts, ctype_get(cts, CTID_DOUBLE),
 281                        (uint8_t *)&(L->base-1-LJ_FR2)->n, o, 0);
 282         return FFH_RES(1);
 283       }
 284     }
 285 #endif
 286   } else {
 287     const char *p = strdata(lj_lib_checkstr(L, 1));
 288     char *ep;
 289     unsigned long ul;
 290     if (base < 2 || base > 36)
 291       lj_err_arg(L, 2, LJ_ERR_BASERNG);
 292     ul = strtoul(p, &ep, base);
 293     if (p != ep) {
 294       while (lj_char_isspace((unsigned char)(*ep))) ep++;
 295       if (*ep == '\0') {
 296         if (LJ_DUALNUM && LJ_LIKELY(ul < 0x80000000u))
 297           setintV(L->base-1-LJ_FR2, (int32_t)ul);
 298         else
 299           setnumV(L->base-1-LJ_FR2, (lua_Number)ul);
 300         return FFH_RES(1);
 301       }
 302     }
 303   }
 304   setnilV(L->base-1-LJ_FR2);
 305   return FFH_RES(1);
 306 }
 307
 308 LJLIB_ASM(tostring)             LJLIB_REC(.)
 309 {
 310   TValue *o = lj_lib_checkany(L, 1);
 311   cTValue *mo;
 312   L->top = o+1;  /* Only keep one argument. */
 313   if (!tvisnil(mo = lj_meta_lookup(L, o, MM_tostring))) {
 314     copyTV(L, L->base-1-LJ_FR2, mo);  /* Replace callable. */
 315     return FFH_TAILCALL;
 316   }
 317   lj_gc_check(L);
 318   setstrV(L, L->base-1-LJ_FR2, lj_strfmt_obj(L, L->base));
 319   return FFH_RES(1);
 320 }
 321
 322 /* -- Base library: throw and catch errors -------------------------------- */
 323
 324 LJLIB_CF(error)
 325 {
 326   int32_t level = lj_lib_optint(L, 2, 1);
 327   lua_settop(L, 1);
 328   if (lua_isstring(L, 1) && level > 0) {
 329     luaL_where(L, level);
 330     lua_pushvalue(L, 1);
 331     lua_concat(L, 2);
 332   }
 333   return lua_error(L);
 334 }
 335
 336 LJLIB_ASM(pcall)                LJLIB_REC(.)
 337 {
 338   lj_lib_checkany(L, 1);
 339   lj_lib_checkfunc(L, 2);  /* For xpcall only. */
 340   return FFH_UNREACHABLE;
 341 }
 342 LJLIB_ASM_(xpcall)              LJLIB_REC(.)
 343
 344 /* -- Base library: load Lua code ----------------------------------------- */
 345
 346 static int load_aux(lua_State *L, int status, int envarg)
 347 {
 348   if (status == 0) {
 349     if (tvistab(L->base+envarg-1)) {
 350       GCfunc *fn = funcV(L->top-1);
 351       GCtab *t = tabV(L->base+envarg-1);
 352       setgcref(fn->c.env, obj2gco(t));
 353       lj_gc_objbarrier(L, fn, t);
 354     }
 355     return 1;
 356   } else {
 357     setnilV(L->top-2);
 358     return 2;
 359   }
 360 }
 361
 362 LJLIB_CF(loadfile)
 363 {
 364   GCstr *fname = lj_lib_optstr(L, 1);
 365   GCstr *mode = lj_lib_optstr(L, 2);
 366   int status;
 367   lua_settop(L, 3);  /* Ensure env arg exists. */
 368   status = luaL_loadfilex(L, fname ? strdata(fname) : NULL,
 369                           mode ? strdata(mode) : NULL);
 370   return load_aux(L, status, 3);
 371 }
 372
 373 static const char *reader_func(lua_State *L, void *ud, size_t *size)
 374 {
 375   UNUSED(ud);
 376   luaL_checkstack(L, 2, "too many nested functions");
 377   copyTV(L, L->top++, L->base);
 378   lua_call(L, 0, 1);  /* Call user-supplied function. */
 379   L->top--;
 380   if (tvisnil(L->top)) {
 381     *size = 0;
 382     return NULL;
 383   } else if (tvisstr(L->top) || tvisnumber(L->top)) {
 384     copyTV(L, L->base+4, L->top);  /* Anchor string in reserved stack slot. */
 385     return lua_tolstring(L, 5, size);
 386   } else {
 387     lj_err_caller(L, LJ_ERR_RDRSTR);
 388     return NULL;
 389   }
 390 }
 391
 392 LJLIB_CF(load)
 393 {
 394   GCstr *name = lj_lib_optstr(L, 2);
 395   GCstr *mode = lj_lib_optstr(L, 3);
 396   int status;
 397   if (L->base < L->top && (tvisstr(L->base) || tvisnumber(L->base))) {
 398     GCstr *s = lj_lib_checkstr(L, 1);
 399     lua_settop(L, 4);  /* Ensure env arg exists. */
 400     status = luaL_loadbufferx(L, strdata(s), s->len, strdata(name ? name : s),
 401                               mode ? strdata(mode) : NULL);
 402   } else {
 403     lj_lib_checkfunc(L, 1);
 404     lua_settop(L, 5);  /* Reserve a slot for the string from the reader. */
 405     status = lua_loadx(L, reader_func, NULL, name ? strdata(name) : "=(load)",
 406                        mode ? strdata(mode) : NULL);
 407   }
 408   return load_aux(L, status, 4);
 409 }
 410
 411 LJLIB_CF(loadstring)
 412 {
 413   return lj_cf_load(L);
 414 }
 415
 416 LJLIB_CF(dofile)
 417 {
 418   GCstr *fname = lj_lib_optstr(L, 1);
 419   setnilV(L->top);
 420   L->top = L->base+1;
 421   if (luaL_loadfile(L, fname ? strdata(fname) : NULL) != 0)
 422     lua_error(L);
 423   lua_call(L, 0, LUA_MULTRET);
 424   return (int)(L->top - L->base) - 1;
 425 }
 426
 427 /* -- Base library: GC control -------------------------------------------- */
 428
 429 LJLIB_CF(gcinfo)
 430 {
 431   setintV(L->top++, (int32_t)(G(L)->gc.total >> 10));
 432   return 1;
 433 }
 434
 435 LJLIB_CF(collectgarbage)
 436 {
 437   int opt = lj_lib_checkopt(L, 1, LUA_GCCOLLECT,  /* ORDER LUA_GC* */
 438     "\4stop\7restart\7collect\5count\1\377\4step\10setpause\12setstepmul");
 439   int32_t data = lj_lib_optint(L, 2, 0);
 440   if (opt == LUA_GCCOUNT) {
 441     setnumV(L->top, (lua_Number)G(L)->gc.total/1024.0);
 442   } else {
 443     int res = lua_gc(L, opt, data);
 444     if (opt == LUA_GCSTEP)
 445       setboolV(L->top, res);
 446     else
 447       setintV(L->top, res);
 448   }
 449   L->top++;
 450   return 1;
 451 }
 452
 453 /* -- Base library: miscellaneous functions ------------------------------- */
 454
 455 LJLIB_PUSH(top-2)  /* Upvalue holds weak table. */
 456 LJLIB_CF(newproxy)
 457 {
 458   lua_settop(L, 1);
 459   lua_newuserdata(L, 0);
 460   if (lua_toboolean(L, 1) == 0) {  /* newproxy(): without metatable. */
 461     return 1;
 462   } else if (lua_isboolean(L, 1)) {  /* newproxy(true): with metatable. */
 463     lua_newtable(L);
 464     lua_pushvalue(L, -1);
 465     lua_pushboolean(L, 1);
 466     lua_rawset(L, lua_upvalueindex(1));  /* Remember mt in weak table. */
 467   } else {  /* newproxy(proxy): inherit metatable. */
 468     int validproxy = 0;
 469     if (lua_getmetatable(L, 1)) {
 470       lua_rawget(L, lua_upvalueindex(1));
 471       validproxy = lua_toboolean(L, -1);
 472       lua_pop(L, 1);
 473     }
 474     if (!validproxy)
 475       lj_err_arg(L, 1, LJ_ERR_NOPROXY);
 476     lua_getmetatable(L, 1);
 477   }
 478   lua_setmetatable(L, 2);
 479   return 1;
 480 }
 481
 482 LJLIB_PUSH("tostring")
 483 LJLIB_CF(print)
 484 {
 485   ptrdiff_t i, nargs = L->top - L->base;
 486   cTValue *tv = lj_tab_getstr(tabref(L->env), strV(lj_lib_upvalue(L, 1)));
 487   int shortcut;
 488   if (tv && !tvisnil(tv)) {
 489     copyTV(L, L->top++, tv);
 490   } else {
 491     setstrV(L, L->top++, strV(lj_lib_upvalue(L, 1)));
 492     lua_gettable(L, LUA_GLOBALSINDEX);
 493     tv = L->top-1;
 494   }
 495   shortcut = (tvisfunc(tv) && funcV(tv)->c.ffid == FF_tostring);
 496   for (i = 0; i < nargs; i++) {
 497     cTValue *o = &L->base[i];
 498     char buf[STRFMT_MAXBUF_NUM];
 499     const char *str;
 500     size_t size;
 501     MSize len;
 502     if (shortcut && (str = lj_strfmt_wstrnum(buf, o, &len)) != NULL) {
 503       size = len;
 504     } else {
 505       copyTV(L, L->top+1, o);
 506       copyTV(L, L->top, L->top-1);
 507       L->top += 2;
 508       lua_call(L, 1, 1);
 509       str = lua_tolstring(L, -1, &size);
 510       if (!str)
 511         lj_err_caller(L, LJ_ERR_PRTOSTR);
 512       L->top--;
 513     }
 514     if (i)
 515       putchar('\t');
 516     fwrite(str, 1, size, stdout);
 517   }
 518   putchar('\n');
 519   return 0;
 520 }
 521
 522 LJLIB_PUSH(top-3)
 523 LJLIB_SET(_VERSION)
 524
 525 #include "lj_libdef.h"
 526
 527 /* -- Coroutine library --------------------------------------------------- */
 528
 529 #define LJLIB_MODULE_coroutine
 530
 531 LJLIB_CF(coroutine_status)
 532 {
 533   const char *s;
 534   lua_State *co;
 535   if (!(L->top > L->base && tvisthread(L->base)))
 536     lj_err_arg(L, 1, LJ_ERR_NOCORO);
 537   co = threadV(L->base);
 538   if (co == L) s = "running";
 539   else if (co->status == LUA_YIELD) s = "suspended";
 540   else if (co->status != 0) s = "dead";
 541   else if (co->base > tvref(co->stack)+1+LJ_FR2) s = "normal";
 542   else if (co->top == co->base) s = "dead";
 543   else s = "suspended";
 544   lua_pushstring(L, s);
 545   return 1;
 546 }
 547
 548 LJLIB_CF(coroutine_running)
 549 {
 550 #if LJ_52
 551   int ismain = lua_pushthread(L);
 552   setboolV(L->top++, ismain);
 553   return 2;
 554 #else
 555   if (lua_pushthread(L))
 556     setnilV(L->top++);
 557   return 1;
 558 #endif
 559 }
 560
 561 LJLIB_CF(coroutine_create)
 562 {
 563   lua_State *L1;
 564   if (!(L->base < L->top && tvisfunc(L->base)))
 565     lj_err_argt(L, 1, LUA_TFUNCTION);
 566   L1 = lua_newthread(L);
 567   setfuncV(L, L1->top++, funcV(L->base));
 568   return 1;
 569 }
 570
 571 LJLIB_ASM(coroutine_yield)
 572 {
 573   lj_err_caller(L, LJ_ERR_CYIELD);
 574   return FFH_UNREACHABLE;
 575 }
 576
 577 static int ffh_resume(lua_State *L, lua_State *co, int wrap)
 578 {
 579   if (co->cframe != NULL || co->status > LUA_YIELD ||
 580       (co->status == 0 && co->top == co->base)) {
 581     ErrMsg em = co->cframe ? LJ_ERR_CORUN : LJ_ERR_CODEAD;
 582     if (wrap) lj_err_caller(L, em);
 583     setboolV(L->base-1-LJ_FR2, 0);
 584     setstrV(L, L->base-LJ_FR2, lj_err_str(L, em));
 585     return FFH_RES(2);
 586   }
 587   lj_state_growstack(co, (MSize)(L->top - L->base));
 588   return FFH_RETRY;
 589 }
 590
 591 LJLIB_ASM(coroutine_resume)
 592 {
 593   if (!(L->top > L->base && tvisthread(L->base)))
 594     lj_err_arg(L, 1, LJ_ERR_NOCORO);
 595   return ffh_resume(L, threadV(L->base), 0);
 596 }
 597
 598 LJLIB_NOREG LJLIB_ASM(coroutine_wrap_aux)
 599 {
 600   return ffh_resume(L, threadV(lj_lib_upvalue(L, 1)), 1);
 601 }
 602
 603 /* Inline declarations. */
 604 LJ_ASMF void lj_ff_coroutine_wrap_aux(void);
 605 #if !(LJ_TARGET_MIPS && defined(ljamalg_c))
 606 LJ_FUNCA_NORET void LJ_FASTCALL lj_ffh_coroutine_wrap_err(lua_State *L,
 607                                                           lua_State *co);
 608 #endif
 609
 610 /* Error handler, called from assembler VM. */
 611 void LJ_FASTCALL lj_ffh_coroutine_wrap_err(lua_State *L, lua_State *co)
 612 {
 613   co->top--; copyTV(L, L->top, co->top); L->top++;
 614   if (tvisstr(L->top-1))
 615     lj_err_callermsg(L, strVdata(L->top-1));
 616   else
 617     lj_err_run(L);
 618 }
 619
 620 /* Forward declaration. */
 621 static void setpc_wrap_aux(lua_State *L, GCfunc *fn);
 622
 623 LJLIB_CF(coroutine_wrap)
 624 {
 625   GCfunc *fn;
 626   lj_cf_coroutine_create(L);
 627   fn = lj_lib_pushcc(L, lj_ffh_coroutine_wrap_aux, FF_coroutine_wrap_aux, 1);
 628   setpc_wrap_aux(L, fn);
 629   return 1;
 630 }
 631
 632 #include "lj_libdef.h"
 633
 634 /* Fix the PC of wrap_aux. Really ugly workaround. */
 635 static void setpc_wrap_aux(lua_State *L, GCfunc *fn)
 636 {
 637   setmref(fn->c.pc, &L2GG(L)->bcff[lj_lib_init_coroutine[1]+2]);
 638 }
 639
 640 /* ------------------------------------------------------------------------ */
 641
 642 static void newproxy_weaktable(lua_State *L)
 643 {
 644   /* NOBARRIER: The table is new (marked white). */
 645   GCtab *t = lj_tab_new(L, 0, 1);
 646   settabV(L, L->top++, t);
 647   setgcref(t->metatable, obj2gco(t));
 648   setstrV(L, lj_tab_setstr(L, t, lj_str_newlit(L, "__mode")),
 649             lj_str_newlit(L, "kv"));
 650   t->nomm = (uint8_t)(~(1u<<MM_mode));
 651 }
 652
 653 LUALIB_API int luaopen_base(lua_State *L)
 654 {
 655   /* NOBARRIER: Table and value are the same. */
 656   GCtab *env = tabref(L->env);
 657   settabV(L, lj_tab_setstr(L, env, lj_str_newlit(L, "_G")), env);
 658   lua_pushliteral(L, LUA_VERSION);  /* top-3. */
 659   newproxy_weaktable(L);  /* top-2. */
 660   LJ_LIB_REG(L, "_G", base);
 661   LJ_LIB_REG(L, LUA_COLIBNAME, coroutine);
 662   return 2;
 663 }
 664