1 /*
2 ** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $
3 ** Basic library
4 ** See Copyright Notice in lua.h
5 */
6
7
8
9 #include <ctype.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13
14 #define lbaselib_c
15 #define LUA_LIB
16
17 #include "lua.h"
18
19 #include "lauxlib.h"
20 #include "lualib.h"
21
22
23
24
25 /*
26 ** If your system does not support `stdout', you can just remove this function.
27 ** If you need, you can define your own `print' function, following this
28 ** model but changing `fputs' to put the strings at a proper place
29 ** (a console window or a log file, for instance).
30 */
luaB_print(lua_State * L)31 static int luaB_print (lua_State *L) {
32 int n = lua_gettop(L); /* number of arguments */
33 int i;
34 lua_getglobal(L, "tostring");
35 for (i=1; i<=n; i++) {
36 const char *s;
37 lua_pushvalue(L, -1); /* function to be called */
38 lua_pushvalue(L, i); /* value to print */
39 lua_call(L, 1, 1);
40 s = lua_tostring(L, -1); /* get result */
41 if (s == NULL)
42 return luaL_error(L, LUA_QL("tostring") " must return a string to "
43 LUA_QL("print"));
44 if (i>1) fputs("\t", stdout);
45 fputs(s, stdout);
46 lua_pop(L, 1); /* pop result */
47 }
48 fputs("\n", stdout);
49 return 0;
50 }
51
52
luaB_tonumber(lua_State * L)53 static int luaB_tonumber (lua_State *L) {
54 int base = luaL_optint(L, 2, 10);
55 if (base == 10) { /* standard conversion */
56 luaL_checkany(L, 1);
57 if (lua_isnumber(L, 1)) {
58 lua_pushnumber(L, lua_tonumber(L, 1));
59 return 1;
60 }
61 }
62 else {
63 const char *s1 = luaL_checkstring(L, 1);
64 char *s2;
65 unsigned long n;
66 luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
67 n = strtoul(s1, &s2, base);
68 if (s1 != s2) { /* at least one valid digit? */
69 while (isspace((unsigned char)(*s2))) s2++; /* skip trailing spaces */
70 if (*s2 == '\0') { /* no invalid trailing characters? */
71 lua_pushnumber(L, (lua_Number)n);
72 return 1;
73 }
74 }
75 }
76 lua_pushnil(L); /* else not a number */
77 return 1;
78 }
79
80
luaB_error(lua_State * L)81 static int luaB_error (lua_State *L) {
82 int level = luaL_optint(L, 2, 1);
83 lua_settop(L, 1);
84 if (lua_isstring(L, 1) && level > 0) { /* add extra information? */
85 luaL_where(L, level);
86 lua_pushvalue(L, 1);
87 lua_concat(L, 2);
88 }
89 return lua_error(L);
90 }
91
92
luaB_getmetatable(lua_State * L)93 static int luaB_getmetatable (lua_State *L) {
94 luaL_checkany(L, 1);
95 if (!lua_getmetatable(L, 1)) {
96 lua_pushnil(L);
97 return 1; /* no metatable */
98 }
99 luaL_getmetafield(L, 1, "__metatable");
100 return 1; /* returns either __metatable field (if present) or metatable */
101 }
102
103
luaB_setmetatable(lua_State * L)104 static int luaB_setmetatable (lua_State *L) {
105 int t = lua_type(L, 2);
106 luaL_checktype(L, 1, LUA_TTABLE);
107 luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
108 "nil or table expected");
109 if (luaL_getmetafield(L, 1, "__metatable"))
110 luaL_error(L, "cannot change a protected metatable");
111 lua_settop(L, 2);
112 lua_setmetatable(L, 1);
113 return 1;
114 }
115
116
getfunc(lua_State * L,int opt)117 static void getfunc (lua_State *L, int opt) {
118 if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
119 else {
120 lua_Debug ar;
121 int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
122 luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
123 if (lua_getstack(L, level, &ar) == 0)
124 luaL_argerror(L, 1, "invalid level");
125 lua_getinfo(L, "f", &ar);
126 if (lua_isnil(L, -1))
127 luaL_error(L, "no function environment for tail call at level %d",
128 level);
129 }
130 }
131
132
luaB_getfenv(lua_State * L)133 static int luaB_getfenv (lua_State *L) {
134 getfunc(L, 1);
135 if (lua_iscfunction(L, -1)) /* is a C function? */
136 lua_pushvalue(L, LUA_GLOBALSINDEX); /* return the thread's global env. */
137 else
138 lua_getfenv(L, -1);
139 return 1;
140 }
141
142
luaB_setfenv(lua_State * L)143 static int luaB_setfenv (lua_State *L) {
144 luaL_checktype(L, 2, LUA_TTABLE);
145 getfunc(L, 0);
146 lua_pushvalue(L, 2);
147 if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
148 /* change environment of current thread */
149 lua_pushthread(L);
150 lua_insert(L, -2);
151 lua_setfenv(L, -2);
152 return 0;
153 }
154 else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
155 luaL_error(L,
156 LUA_QL("setfenv") " cannot change environment of given object");
157 return 1;
158 }
159
160
luaB_rawequal(lua_State * L)161 static int luaB_rawequal (lua_State *L) {
162 luaL_checkany(L, 1);
163 luaL_checkany(L, 2);
164 lua_pushboolean(L, lua_rawequal(L, 1, 2));
165 return 1;
166 }
167
168
luaB_rawget(lua_State * L)169 static int luaB_rawget (lua_State *L) {
170 luaL_checktype(L, 1, LUA_TTABLE);
171 luaL_checkany(L, 2);
172 lua_settop(L, 2);
173 lua_rawget(L, 1);
174 return 1;
175 }
176
luaB_rawset(lua_State * L)177 static int luaB_rawset (lua_State *L) {
178 luaL_checktype(L, 1, LUA_TTABLE);
179 luaL_checkany(L, 2);
180 luaL_checkany(L, 3);
181 lua_settop(L, 3);
182 lua_rawset(L, 1);
183 return 1;
184 }
185
186
luaB_gcinfo(lua_State * L)187 static int luaB_gcinfo (lua_State *L) {
188 lua_pushinteger(L, lua_getgccount(L));
189 return 1;
190 }
191
192
luaB_collectgarbage(lua_State * L)193 static int luaB_collectgarbage (lua_State *L) {
194 static const char *const opts[] = {"stop", "restart", "collect",
195 "count", "step", "setpause", "setstepmul", NULL};
196 static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
197 LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
198 int o = luaL_checkoption(L, 1, "collect", opts);
199 int ex = luaL_optint(L, 2, 0);
200 int res = lua_gc(L, optsnum[o], ex);
201 switch (optsnum[o]) {
202 case LUA_GCCOUNT: {
203 int b = lua_gc(L, LUA_GCCOUNTB, 0);
204 lua_pushnumber(L, res + ((lua_Number)b/1024));
205 return 1;
206 }
207 case LUA_GCSTEP: {
208 lua_pushboolean(L, res);
209 return 1;
210 }
211 default: {
212 lua_pushnumber(L, res);
213 return 1;
214 }
215 }
216 }
217
218
luaB_type(lua_State * L)219 static int luaB_type (lua_State *L) {
220 luaL_checkany(L, 1);
221 lua_pushstring(L, luaL_typename(L, 1));
222 return 1;
223 }
224
225
luaB_next(lua_State * L)226 static int luaB_next (lua_State *L) {
227 luaL_checktype(L, 1, LUA_TTABLE);
228 lua_settop(L, 2); /* create a 2nd argument if there isn't one */
229 if (lua_next(L, 1))
230 return 2;
231 else {
232 lua_pushnil(L);
233 return 1;
234 }
235 }
236
237
luaB_pairs(lua_State * L)238 static int luaB_pairs (lua_State *L) {
239 luaL_checktype(L, 1, LUA_TTABLE);
240 lua_pushvalue(L, lua_upvalueindex(1)); /* return generator, */
241 lua_pushvalue(L, 1); /* state, */
242 lua_pushnil(L); /* and initial value */
243 return 3;
244 }
245
246
ipairsaux(lua_State * L)247 static int ipairsaux (lua_State *L) {
248 int i = luaL_checkint(L, 2);
249 luaL_checktype(L, 1, LUA_TTABLE);
250 i++; /* next value */
251 lua_pushinteger(L, i);
252 lua_rawgeti(L, 1, i);
253 return (lua_isnil(L, -1)) ? 0 : 2;
254 }
255
256
luaB_ipairs(lua_State * L)257 static int luaB_ipairs (lua_State *L) {
258 luaL_checktype(L, 1, LUA_TTABLE);
259 lua_pushvalue(L, lua_upvalueindex(1)); /* return generator, */
260 lua_pushvalue(L, 1); /* state, */
261 lua_pushinteger(L, 0); /* and initial value */
262 return 3;
263 }
264
265
load_aux(lua_State * L,int status)266 static int load_aux (lua_State *L, int status) {
267 if (status == 0) /* OK? */
268 return 1;
269 else {
270 lua_pushnil(L);
271 lua_insert(L, -2); /* put before error message */
272 return 2; /* return nil plus error message */
273 }
274 }
275
276
luaB_loadstring(lua_State * L)277 static int luaB_loadstring (lua_State *L) {
278 size_t l;
279 const char *s = luaL_checklstring(L, 1, &l);
280 const char *chunkname = luaL_optstring(L, 2, s);
281 return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
282 }
283
284
luaB_loadfile(lua_State * L)285 static int luaB_loadfile (lua_State *L) {
286 const char *fname = luaL_optstring(L, 1, NULL);
287 return load_aux(L, luaL_loadfile(L, fname));
288 }
289
290
291 /*
292 ** Reader for generic `load' function: `lua_load' uses the
293 ** stack for internal stuff, so the reader cannot change the
294 ** stack top. Instead, it keeps its resulting string in a
295 ** reserved slot inside the stack.
296 */
generic_reader(lua_State * L,void * ud,size_t * size)297 static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
298 (void)ud; /* to avoid warnings */
299 luaL_checkstack(L, 2, "too many nested functions");
300 lua_pushvalue(L, 1); /* get function */
301 lua_call(L, 0, 1); /* call it */
302 if (lua_isnil(L, -1)) {
303 *size = 0;
304 return NULL;
305 }
306 else if (lua_isstring(L, -1)) {
307 lua_replace(L, 3); /* save string in a reserved stack slot */
308 return lua_tolstring(L, 3, size);
309 }
310 else luaL_error(L, "reader function must return a string");
311 return NULL; /* to avoid warnings */
312 }
313
314
luaB_load(lua_State * L)315 static int luaB_load (lua_State *L) {
316 int status;
317 const char *cname = luaL_optstring(L, 2, "=(load)");
318 luaL_checktype(L, 1, LUA_TFUNCTION);
319 lua_settop(L, 3); /* function, eventual name, plus one reserved slot */
320 status = lua_load(L, generic_reader, NULL, cname);
321 return load_aux(L, status);
322 }
323
324
luaB_dofile(lua_State * L)325 static int luaB_dofile (lua_State *L) {
326 const char *fname = luaL_optstring(L, 1, NULL);
327 int n = lua_gettop(L);
328 if (luaL_loadfile(L, fname) != 0) lua_error(L);
329 lua_call(L, 0, LUA_MULTRET);
330 return lua_gettop(L) - n;
331 }
332
333
luaB_assert(lua_State * L)334 static int luaB_assert (lua_State *L) {
335 luaL_checkany(L, 1);
336 if (!lua_toboolean(L, 1))
337 return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
338 return lua_gettop(L);
339 }
340
341
luaB_unpack(lua_State * L)342 static int luaB_unpack (lua_State *L) {
343 int i, e, n;
344 luaL_checktype(L, 1, LUA_TTABLE);
345 i = luaL_optint(L, 2, 1);
346 e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
347 if (i > e) return 0; /* empty range */
348 n = e - i + 1; /* number of elements */
349 if (n <= 0 || !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */
350 return luaL_error(L, "too many results to unpack");
351 lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */
352 while (i++ < e) /* push arg[i + 1...e] */
353 lua_rawgeti(L, 1, i);
354 return n;
355 }
356
357
luaB_select(lua_State * L)358 static int luaB_select (lua_State *L) {
359 int n = lua_gettop(L);
360 if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
361 lua_pushinteger(L, n-1);
362 return 1;
363 }
364 else {
365 int i = luaL_checkint(L, 1);
366 if (i < 0) i = n + i;
367 else if (i > n) i = n;
368 luaL_argcheck(L, 1 <= i, 1, "index out of range");
369 return n - i;
370 }
371 }
372
373
luaB_pcall(lua_State * L)374 static int luaB_pcall (lua_State *L) {
375 int status;
376 luaL_checkany(L, 1);
377 status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
378 lua_pushboolean(L, (status == 0));
379 lua_insert(L, 1);
380 return lua_gettop(L); /* return status + all results */
381 }
382
383
luaB_xpcall(lua_State * L)384 static int luaB_xpcall (lua_State *L) {
385 int status;
386 luaL_checkany(L, 2);
387 lua_settop(L, 2);
388 lua_insert(L, 1); /* put error function under function to be called */
389 status = lua_pcall(L, 0, LUA_MULTRET, 1);
390 lua_pushboolean(L, (status == 0));
391 lua_replace(L, 1);
392 return lua_gettop(L); /* return status + all results */
393 }
394
395
luaB_tostring(lua_State * L)396 static int luaB_tostring (lua_State *L) {
397 luaL_checkany(L, 1);
398 if (luaL_callmeta(L, 1, "__tostring")) /* is there a metafield? */
399 return 1; /* use its value */
400 switch (lua_type(L, 1)) {
401 case LUA_TNUMBER:
402 lua_pushstring(L, lua_tostring(L, 1));
403 break;
404 case LUA_TSTRING:
405 lua_pushvalue(L, 1);
406 break;
407 case LUA_TBOOLEAN:
408 lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
409 break;
410 case LUA_TNIL:
411 lua_pushliteral(L, "nil");
412 break;
413 /*
414 * SPRING - synced safety change
415 */
416 case LUA_TNONE: { lua_pushliteral(L, "<none>"); break; }
417 case LUA_TTABLE: { lua_pushliteral(L, "<table>"); break; }
418 case LUA_TUSERDATA: { lua_pushliteral(L, "<userdata>"); break; }
419 case LUA_TLIGHTUSERDATA: { lua_pushliteral(L, "<lightuserdata>"); break; }
420 case LUA_TFUNCTION: { lua_pushliteral(L, "<function>"); break; }
421 case LUA_TTHREAD: { lua_pushliteral(L, "<thread>"); break; }
422 default: { lua_pushliteral(L, "<unknown_type>"); break; }
423 /*
424 default:
425 lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
426 break;
427 */
428 }
429 return 1;
430 }
431
432
luaB_newproxy(lua_State * L)433 static int luaB_newproxy (lua_State *L) {
434 lua_settop(L, 1);
435 lua_newuserdata(L, 0); /* create proxy */
436 if (lua_toboolean(L, 1) == 0)
437 return 1; /* no metatable */
438 else if (lua_isboolean(L, 1)) {
439 lua_newtable(L); /* create a new metatable `m' ... */
440 lua_pushvalue(L, -1); /* ... and mark `m' as a valid metatable */
441 lua_pushboolean(L, 1);
442 lua_rawset(L, lua_upvalueindex(1)); /* weaktable[m] = true */
443 }
444 else {
445 int validproxy = 0; /* to check if weaktable[metatable(u)] == true */
446 if (lua_getmetatable(L, 1)) {
447 lua_rawget(L, lua_upvalueindex(1));
448 validproxy = lua_toboolean(L, -1);
449 lua_pop(L, 1); /* remove value */
450 }
451 luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
452 lua_getmetatable(L, 1); /* metatable is valid; get it */
453 }
454 lua_setmetatable(L, 2);
455 return 1;
456 }
457
458
459 static const luaL_Reg base_funcs[] = {
460 {"assert", luaB_assert},
461 {"collectgarbage", luaB_collectgarbage},
462 {"dofile", luaB_dofile},
463 {"error", luaB_error},
464 {"gcinfo", luaB_gcinfo},
465 {"getfenv", luaB_getfenv},
466 {"getmetatable", luaB_getmetatable},
467 {"loadfile", luaB_loadfile},
468 {"load", luaB_load},
469 {"loadstring", luaB_loadstring},
470 {"next", luaB_next},
471 {"pcall", luaB_pcall},
472 {"print", luaB_print},
473 {"rawequal", luaB_rawequal},
474 {"rawget", luaB_rawget},
475 {"rawset", luaB_rawset},
476 {"select", luaB_select},
477 {"setfenv", luaB_setfenv},
478 {"setmetatable", luaB_setmetatable},
479 {"tonumber", luaB_tonumber},
480 {"tostring", luaB_tostring},
481 {"type", luaB_type},
482 {"unpack", luaB_unpack},
483 {"xpcall", luaB_xpcall},
484 {NULL, NULL}
485 };
486
487
488 /*
489 ** {======================================================
490 ** Coroutine library
491 ** =======================================================
492 */
493
494 #define CO_RUN 0 /* running */
495 #define CO_SUS 1 /* suspended */
496 #define CO_NOR 2 /* 'normal' (it resumed another coroutine) */
497 #define CO_DEAD 3
498
499 static const char *const statnames[] =
500 {"running", "suspended", "normal", "dead"};
501
costatus(lua_State * L,lua_State * co)502 static int costatus (lua_State *L, lua_State *co) {
503 if (L == co) return CO_RUN;
504 switch (lua_status(co)) {
505 case LUA_YIELD:
506 return CO_SUS;
507 case 0: {
508 lua_Debug ar;
509 if (lua_getstack(co, 0, &ar) > 0) /* does it have frames? */
510 return CO_NOR; /* it is running */
511 else if (lua_gettop(co) == 0)
512 return CO_DEAD;
513 else
514 return CO_SUS; /* initial state */
515 }
516 default: /* some error occured */
517 return CO_DEAD;
518 }
519 }
520
521
luaB_costatus(lua_State * L)522 static int luaB_costatus (lua_State *L) {
523 lua_State *co = lua_tothread(L, 1);
524 luaL_argcheck(L, co, 1, "coroutine expected");
525 lua_pushstring(L, statnames[costatus(L, co)]);
526 return 1;
527 }
528
529
auxresume(lua_State * L,lua_State * co,int narg)530 static int auxresume (lua_State *L, lua_State *co, int narg) {
531 int status = costatus(L, co);
532 if (!lua_checkstack(co, narg))
533 luaL_error(L, "too many arguments to resume");
534 if (status != CO_SUS) {
535 lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
536 return -1; /* error flag */
537 }
538 lua_xmove(L, co, narg);
539 lua_setlevel(L, co);
540 status = lua_resume(co, narg);
541 if (status == 0 || status == LUA_YIELD) {
542 int nres = lua_gettop(co);
543 if (!lua_checkstack(L, nres + 1))
544 luaL_error(L, "too many results to resume");
545 lua_xmove(co, L, nres); /* move yielded values */
546 return nres;
547 }
548 else {
549 lua_xmove(co, L, 1); /* move error message */
550 return -1; /* error flag */
551 }
552 }
553
554
luaB_coresume(lua_State * L)555 static int luaB_coresume (lua_State *L) {
556 lua_State *co = lua_tothread(L, 1);
557 int r;
558 luaL_argcheck(L, co, 1, "coroutine expected");
559 r = auxresume(L, co, lua_gettop(L) - 1);
560 if (r < 0) {
561 lua_pushboolean(L, 0);
562 lua_insert(L, -2);
563 return 2; /* return false + error message */
564 }
565 else {
566 lua_pushboolean(L, 1);
567 lua_insert(L, -(r + 1));
568 return r + 1; /* return true + `resume' returns */
569 }
570 }
571
572
luaB_auxwrap(lua_State * L)573 static int luaB_auxwrap (lua_State *L) {
574 lua_State *co = lua_tothread(L, lua_upvalueindex(1));
575 int r = auxresume(L, co, lua_gettop(L));
576 if (r < 0) {
577 if (lua_isstring(L, -1)) { /* error object is a string? */
578 luaL_where(L, 1); /* add extra info */
579 lua_insert(L, -2);
580 lua_concat(L, 2);
581 }
582 lua_error(L); /* propagate error */
583 }
584 return r;
585 }
586
587
luaB_cocreate(lua_State * L)588 static int luaB_cocreate (lua_State *L) {
589 lua_State *NL = lua_newthread(L);
590 luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
591 "Lua function expected");
592 lua_pushvalue(L, 1); /* move function to top */
593 lua_xmove(L, NL, 1); /* move function from L to NL */
594 return 1;
595 }
596
597
luaB_cowrap(lua_State * L)598 static int luaB_cowrap (lua_State *L) {
599 luaB_cocreate(L);
600 lua_pushcclosure(L, luaB_auxwrap, 1);
601 return 1;
602 }
603
604
luaB_yield(lua_State * L)605 static int luaB_yield (lua_State *L) {
606 return lua_yield(L, lua_gettop(L));
607 }
608
609
luaB_corunning(lua_State * L)610 static int luaB_corunning (lua_State *L) {
611 if (lua_pushthread(L))
612 lua_pushnil(L); /* main thread is not a coroutine */
613 return 1;
614 }
615
616
617 static const luaL_Reg co_funcs[] = {
618 {"create", luaB_cocreate},
619 {"resume", luaB_coresume},
620 {"running", luaB_corunning},
621 {"status", luaB_costatus},
622 {"wrap", luaB_cowrap},
623 {"yield", luaB_yield},
624 {NULL, NULL}
625 };
626
627 /* }====================================================== */
628
629
auxopen(lua_State * L,const char * name,lua_CFunction f,lua_CFunction u)630 static void auxopen (lua_State *L, const char *name,
631 lua_CFunction f, lua_CFunction u) {
632 lua_pushcfunction(L, u);
633 lua_pushcclosure(L, f, 1);
634 lua_setfield(L, -2, name);
635 }
636
637
base_open(lua_State * L)638 static void base_open (lua_State *L) {
639 /* set global _G */
640 lua_pushvalue(L, LUA_GLOBALSINDEX);
641 lua_setglobal(L, "_G");
642 /* open lib into global table */
643 luaL_register(L, "_G", base_funcs);
644 lua_pushliteral(L, LUA_VERSION);
645 lua_setglobal(L, "_VERSION"); /* set global _VERSION */
646 /* `ipairs' and `pairs' need auxiliary functions as upvalues */
647 auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
648 auxopen(L, "pairs", luaB_pairs, luaB_next);
649 /* `newproxy' needs a weaktable as upvalue */
650 lua_createtable(L, 0, 1); /* new table `w' */
651 lua_pushvalue(L, -1); /* `w' will be its own metatable */
652 lua_setmetatable(L, -2);
653 lua_pushliteral(L, "kv");
654 lua_setfield(L, -2, "__mode"); /* metatable(w).__mode = "kv" */
655 lua_pushcclosure(L, luaB_newproxy, 1);
656 lua_setglobal(L, "newproxy"); /* set global `newproxy' */
657 }
658
659
luaopen_base(lua_State * L)660 LUALIB_API int luaopen_base (lua_State *L) {
661 base_open(L);
662 luaL_register(L, LUA_COLIBNAME, co_funcs);
663 return 2;
664 }
665
666