Line data Source code
1 : /*
2 : ** $Id: loadlib.c,v 1.52.1.4 2009/09/09 13:17:16 roberto Exp $
3 : ** Dynamic library loader for Lua
4 : ** See Copyright Notice in lua.h
5 : **
6 : ** This module contains an implementation of loadlib for Unix systems
7 : ** that have dlfcn, an implementation for Darwin (Mac OS X), an
8 : ** implementation for Windows, and a stub for other systems.
9 : */
10 :
11 :
12 : #include <stdlib.h>
13 : #include <string.h>
14 :
15 :
16 : #define loadlib_c
17 : #define LUA_LIB
18 :
19 : #include "lua.h"
20 :
21 : #include "lauxlib.h"
22 : #include "lualib.h"
23 :
24 :
25 : /* prefix for open functions in C libraries */
26 : #define LUA_POF "luaopen_"
27 :
28 : /* separator for open functions in C libraries */
29 : #define LUA_OFSEP "_"
30 :
31 :
32 : #define LIBPREFIX "LOADLIB: "
33 :
34 : #define POF LUA_POF
35 : #define LIB_FAIL "open"
36 :
37 :
38 : /* error codes for ll_loadfunc */
39 : #define ERRLIB 1
40 : #define ERRFUNC 2
41 :
42 : #define setprogdir(L) ((void)0)
43 :
44 :
45 : static void ll_unloadlib (void *lib);
46 : static void *ll_load (lua_State *L, const char *path);
47 : static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);
48 :
49 :
50 :
51 : #if defined(LUA_DL_DLOPEN)
52 : /*
53 : ** {========================================================================
54 : ** This is an implementation of loadlib based on the dlfcn interface.
55 : ** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
56 : ** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least
57 : ** as an emulation layer on top of native functions.
58 : ** =========================================================================
59 : */
60 :
61 : #include <dlfcn.h>
62 :
63 0 : static void ll_unloadlib (void *lib) {
64 0 : dlclose(lib);
65 0 : }
66 :
67 :
68 1 : static void *ll_load (lua_State *L, const char *path) {
69 1 : void *lib = dlopen(path, RTLD_NOW);
70 1 : if (lib == NULL) lua_pushstring(L, dlerror());
71 1 : return lib;
72 : }
73 :
74 :
75 0 : static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
76 0 : lua_CFunction f = (lua_CFunction)dlsym(lib, sym);
77 0 : if (f == NULL) lua_pushstring(L, dlerror());
78 0 : return f;
79 : }
80 :
81 : /* }====================================================== */
82 :
83 :
84 :
85 : #elif defined(LUA_DL_DLL)
86 : /*
87 : ** {======================================================================
88 : ** This is an implementation of loadlib for Windows using native functions.
89 : ** =======================================================================
90 : */
91 :
92 : #include <windows.h>
93 :
94 :
95 : #undef setprogdir
96 :
97 : static void setprogdir (lua_State *L) {
98 : char buff[MAX_PATH + 1];
99 : char *lb;
100 : DWORD nsize = sizeof(buff)/sizeof(char);
101 : DWORD n = GetModuleFileNameA(NULL, buff, nsize);
102 : if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
103 : luaL_error(L, "unable to get ModuleFileName");
104 : else {
105 : *lb = '\0';
106 : luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);
107 : lua_remove(L, -2); /* remove original string */
108 : }
109 : }
110 :
111 :
112 : static void pusherror (lua_State *L) {
113 : int error = GetLastError();
114 : char buffer[128];
115 : if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
116 : NULL, error, 0, buffer, sizeof(buffer), NULL))
117 : lua_pushstring(L, buffer);
118 : else
119 : lua_pushfstring(L, "system error %d\n", error);
120 : }
121 :
122 : static void ll_unloadlib (void *lib) {
123 : FreeLibrary((HINSTANCE)lib);
124 : }
125 :
126 :
127 : static void *ll_load (lua_State *L, const char *path) {
128 : HINSTANCE lib = LoadLibraryA(path);
129 : if (lib == NULL) pusherror(L);
130 : return lib;
131 : }
132 :
133 :
134 : static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
135 : lua_CFunction f = (lua_CFunction)GetProcAddress((HINSTANCE)lib, sym);
136 : if (f == NULL) pusherror(L);
137 : return f;
138 : }
139 :
140 : /* }====================================================== */
141 :
142 :
143 :
144 : #elif defined(LUA_DL_DYLD)
145 : /*
146 : ** {======================================================================
147 : ** Native Mac OS X / Darwin Implementation
148 : ** =======================================================================
149 : */
150 :
151 : #include <mach-o/dyld.h>
152 :
153 :
154 : /* Mac appends a `_' before C function names */
155 : #undef POF
156 : #define POF "_" LUA_POF
157 :
158 :
159 : static void pusherror (lua_State *L) {
160 : const char *err_str;
161 : const char *err_file;
162 : NSLinkEditErrors err;
163 : int err_num;
164 : NSLinkEditError(&err, &err_num, &err_file, &err_str);
165 : lua_pushstring(L, err_str);
166 : }
167 :
168 :
169 : static const char *errorfromcode (NSObjectFileImageReturnCode ret) {
170 : switch (ret) {
171 : case NSObjectFileImageInappropriateFile:
172 : return "file is not a bundle";
173 : case NSObjectFileImageArch:
174 : return "library is for wrong CPU type";
175 : case NSObjectFileImageFormat:
176 : return "bad format";
177 : case NSObjectFileImageAccess:
178 : return "cannot access file";
179 : case NSObjectFileImageFailure:
180 : default:
181 : return "unable to load library";
182 : }
183 : }
184 :
185 :
186 : static void ll_unloadlib (void *lib) {
187 : NSUnLinkModule((NSModule)lib, NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);
188 : }
189 :
190 :
191 : static void *ll_load (lua_State *L, const char *path) {
192 : NSObjectFileImage img;
193 : NSObjectFileImageReturnCode ret;
194 : /* this would be a rare case, but prevents crashing if it happens */
195 : if(!_dyld_present()) {
196 : lua_pushliteral(L, "dyld not present");
197 : return NULL;
198 : }
199 : ret = NSCreateObjectFileImageFromFile(path, &img);
200 : if (ret == NSObjectFileImageSuccess) {
201 : NSModule mod = NSLinkModule(img, path, NSLINKMODULE_OPTION_PRIVATE |
202 : NSLINKMODULE_OPTION_RETURN_ON_ERROR);
203 : NSDestroyObjectFileImage(img);
204 : if (mod == NULL) pusherror(L);
205 : return mod;
206 : }
207 : lua_pushstring(L, errorfromcode(ret));
208 : return NULL;
209 : }
210 :
211 :
212 : static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
213 : NSSymbol nss = NSLookupSymbolInModule((NSModule)lib, sym);
214 : if (nss == NULL) {
215 : lua_pushfstring(L, "symbol " LUA_QS " not found", sym);
216 : return NULL;
217 : }
218 : return (lua_CFunction)NSAddressOfSymbol(nss);
219 : }
220 :
221 : /* }====================================================== */
222 :
223 :
224 :
225 : #else
226 : /*
227 : ** {======================================================
228 : ** Fallback for other systems
229 : ** =======================================================
230 : */
231 :
232 : #undef LIB_FAIL
233 : #define LIB_FAIL "absent"
234 :
235 :
236 : #define DLMSG "dynamic libraries not enabled; check your Lua installation"
237 :
238 :
239 : static void ll_unloadlib (void *lib) {
240 : (void)lib; /* to avoid warnings */
241 : }
242 :
243 :
244 : static void *ll_load (lua_State *L, const char *path) {
245 : (void)path; /* to avoid warnings */
246 : lua_pushliteral(L, DLMSG);
247 : return NULL;
248 : }
249 :
250 :
251 : static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
252 : (void)lib; (void)sym; /* to avoid warnings */
253 : lua_pushliteral(L, DLMSG);
254 : return NULL;
255 : }
256 :
257 : /* }====================================================== */
258 : #endif
259 :
260 :
261 :
262 1 : static void **ll_register (lua_State *L, const char *path) {
263 : void **plib;
264 1 : lua_pushfstring(L, "%s%s", LIBPREFIX, path);
265 1 : lua_gettable(L, LUA_REGISTRYINDEX); /* check library in registry? */
266 1 : if (!lua_isnil(L, -1)) /* is there an entry? */
267 0 : plib = (void **)lua_touserdata(L, -1);
268 : else { /* no entry yet; create one */
269 1 : lua_pop(L, 1);
270 1 : plib = (void **)lua_newuserdata(L, sizeof(const void *));
271 1 : *plib = NULL;
272 1 : luaL_getmetatable(L, "_LOADLIB");
273 1 : lua_setmetatable(L, -2);
274 1 : lua_pushfstring(L, "%s%s", LIBPREFIX, path);
275 1 : lua_pushvalue(L, -2);
276 1 : lua_settable(L, LUA_REGISTRYINDEX);
277 : }
278 1 : return plib;
279 : }
280 :
281 :
282 : /*
283 : ** __gc tag method: calls library's `ll_unloadlib' function with the lib
284 : ** handle
285 : */
286 1 : static int gctm (lua_State *L) {
287 1 : void **lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
288 1 : if (*lib) ll_unloadlib(*lib);
289 1 : *lib = NULL; /* mark library as closed */
290 1 : return 0;
291 : }
292 :
293 :
294 1 : static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
295 1 : void **reg = ll_register(L, path);
296 1 : if (*reg == NULL) *reg = ll_load(L, path);
297 1 : if (*reg == NULL)
298 1 : return ERRLIB; /* unable to load library */
299 : else {
300 0 : lua_CFunction f = ll_sym(L, *reg, sym);
301 0 : if (f == NULL)
302 0 : return ERRFUNC; /* unable to find function */
303 0 : lua_pushcfunction(L, f);
304 0 : return 0; /* return function */
305 : }
306 : }
307 :
308 :
309 1 : static int ll_loadlib (lua_State *L) {
310 1 : const char *path = luaL_checkstring(L, 1);
311 1 : const char *init = luaL_checkstring(L, 2);
312 1 : int stat = ll_loadfunc(L, path, init);
313 1 : if (stat == 0) /* no errors? */
314 0 : return 1; /* return the loaded function */
315 : else { /* error; error message is on stack top */
316 1 : lua_pushnil(L);
317 1 : lua_insert(L, -2);
318 1 : lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : "init");
319 1 : return 3; /* return nil, error message, and where */
320 : }
321 : }
322 :
323 :
324 :
325 : /*
326 : ** {======================================================
327 : ** 'require' function
328 : ** =======================================================
329 : */
330 :
331 :
332 824 : static int readable (const char *filename) {
333 824 : FILE *f = fopen(filename, "r"); /* try to open file */
334 824 : if (f == NULL) return 0; /* open failed */
335 99 : fclose(f);
336 99 : return 1;
337 : }
338 :
339 :
340 958 : static const char *pushnexttemplate (lua_State *L, const char *path) {
341 : const char *l;
342 1683 : while (*path == *LUA_PATHSEP) path++; /* skip separators */
343 958 : if (*path == '\0') return NULL; /* no more templates */
344 824 : l = strchr(path, *LUA_PATHSEP); /* find next separator */
345 824 : if (l == NULL) l = path + strlen(path);
346 824 : lua_pushlstring(L, path, l - path); /* template */
347 824 : return l;
348 : }
349 :
350 :
351 233 : static const char *findfile (lua_State *L, const char *name,
352 : const char *pname) {
353 : const char *path;
354 233 : name = luaL_gsub(L, name, ".", LUA_DIRSEP);
355 233 : lua_getfield(L, LUA_ENVIRONINDEX, pname);
356 233 : path = lua_tostring(L, -1);
357 233 : if (path == NULL)
358 0 : luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
359 233 : lua_pushliteral(L, ""); /* error accumulator */
360 958 : while ((path = pushnexttemplate(L, path)) != NULL) {
361 : const char *filename;
362 824 : filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
363 824 : lua_remove(L, -2); /* remove path template */
364 824 : if (readable(filename)) /* does file exist and is readable? */
365 99 : return filename; /* return that file name */
366 725 : lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
367 725 : lua_remove(L, -2); /* remove file name */
368 725 : lua_concat(L, 2); /* add entry to possible error message */
369 : }
370 134 : return NULL; /* not found */
371 : }
372 :
373 :
374 1 : static void loaderror (lua_State *L, const char *filename) {
375 1 : luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
376 : lua_tostring(L, 1), filename, lua_tostring(L, -1));
377 0 : }
378 :
379 :
380 144 : static int loader_Lua (lua_State *L) {
381 : const char *filename;
382 144 : const char *name = luaL_checkstring(L, 1);
383 144 : filename = findfile(L, name, "path");
384 144 : if (filename == NULL) return 1; /* library not found in this path */
385 99 : if (luaL_loadfile(L, filename) != 0)
386 1 : loaderror(L, filename);
387 98 : return 1; /* library loaded successfully */
388 : }
389 :
390 :
391 0 : static const char *mkfuncname (lua_State *L, const char *modname) {
392 : const char *funcname;
393 0 : const char *mark = strchr(modname, *LUA_IGMARK);
394 0 : if (mark) modname = mark + 1;
395 0 : funcname = luaL_gsub(L, modname, ".", LUA_OFSEP);
396 0 : funcname = lua_pushfstring(L, POF"%s", funcname);
397 0 : lua_remove(L, -2); /* remove 'gsub' result */
398 0 : return funcname;
399 : }
400 :
401 :
402 45 : static int loader_C (lua_State *L) {
403 : const char *funcname;
404 45 : const char *name = luaL_checkstring(L, 1);
405 45 : const char *filename = findfile(L, name, "cpath");
406 45 : if (filename == NULL) return 1; /* library not found in this path */
407 0 : funcname = mkfuncname(L, name);
408 0 : if (ll_loadfunc(L, filename, funcname) != 0)
409 0 : loaderror(L, filename);
410 0 : return 1; /* library loaded successfully */
411 : }
412 :
413 :
414 45 : static int loader_Croot (lua_State *L) {
415 : const char *funcname;
416 : const char *filename;
417 45 : const char *name = luaL_checkstring(L, 1);
418 45 : const char *p = strchr(name, '.');
419 : int stat;
420 45 : if (p == NULL) return 0; /* is root */
421 44 : lua_pushlstring(L, name, p - name);
422 44 : filename = findfile(L, lua_tostring(L, -1), "cpath");
423 44 : if (filename == NULL) return 1; /* root not found */
424 0 : funcname = mkfuncname(L, name);
425 0 : if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {
426 0 : if (stat != ERRFUNC) loaderror(L, filename); /* real error */
427 0 : lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
428 : name, filename);
429 0 : return 1; /* function not found */
430 : }
431 0 : return 1;
432 : }
433 :
434 :
435 145 : static int loader_preload (lua_State *L) {
436 145 : const char *name = luaL_checkstring(L, 1);
437 145 : lua_getfield(L, LUA_ENVIRONINDEX, "preload");
438 145 : if (!lua_istable(L, -1))
439 0 : luaL_error(L, LUA_QL("package.preload") " must be a table");
440 145 : lua_getfield(L, -1, name);
441 145 : if (lua_isnil(L, -1)) /* not found? */
442 144 : lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
443 145 : return 1;
444 : }
445 :
446 :
447 : static const int sentinel_ = 0;
448 : #define sentinel ((void *)&sentinel_)
449 :
450 :
451 167 : static int ll_require (lua_State *L) {
452 167 : const char *name = luaL_checkstring(L, 1);
453 : int i;
454 167 : lua_settop(L, 1); /* _LOADED table will be at index 2 */
455 167 : lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
456 167 : lua_getfield(L, 2, name);
457 167 : if (lua_toboolean(L, -1)) { /* is it there? */
458 22 : if (lua_touserdata(L, -1) == sentinel) /* check loops */
459 0 : luaL_error(L, "loop or previous error loading module " LUA_QS, name);
460 22 : return 1; /* package is already loaded */
461 : }
462 : /* else must load it; iterate over available loaders */
463 145 : lua_getfield(L, LUA_ENVIRONINDEX, "loaders");
464 145 : if (!lua_istable(L, -1))
465 0 : luaL_error(L, LUA_QL("package.loaders") " must be a table");
466 145 : lua_pushliteral(L, ""); /* error message accumulator */
467 424 : for (i=1; ; i++) {
468 424 : lua_rawgeti(L, -2, i); /* get a loader */
469 424 : if (lua_isnil(L, -1))
470 45 : luaL_error(L, "module " LUA_QS " not found:%s",
471 : name, lua_tostring(L, -2));
472 379 : lua_pushstring(L, name);
473 379 : lua_call(L, 1, 1); /* call it */
474 378 : if (lua_isfunction(L, -1)) /* did it find module? */
475 99 : break; /* module loaded successfully */
476 279 : else if (lua_isstring(L, -1)) /* loader returned error message? */
477 278 : lua_concat(L, 2); /* accumulate it */
478 : else
479 1 : lua_pop(L, 1);
480 : }
481 99 : lua_pushlightuserdata(L, sentinel);
482 99 : lua_setfield(L, 2, name); /* _LOADED[name] = sentinel */
483 99 : lua_pushstring(L, name); /* pass name as argument to module */
484 99 : lua_call(L, 1, 1); /* run loaded module */
485 99 : if (!lua_isnil(L, -1)) /* non-nil return? */
486 53 : lua_setfield(L, 2, name); /* _LOADED[name] = returned value */
487 99 : lua_getfield(L, 2, name);
488 99 : if (lua_touserdata(L, -1) == sentinel) { /* module did not set a value? */
489 46 : lua_pushboolean(L, 1); /* use true as result */
490 46 : lua_pushvalue(L, -1); /* extra copy to be returned */
491 46 : lua_setfield(L, 2, name); /* _LOADED[name] = true */
492 : }
493 99 : return 1;
494 : }
495 :
496 : /* }====================================================== */
497 :
498 :
499 :
500 : /*
501 : ** {======================================================
502 : ** 'module' function
503 : ** =======================================================
504 : */
505 :
506 :
507 2 : static void setfenv (lua_State *L) {
508 : lua_Debug ar;
509 4 : if (lua_getstack(L, 1, &ar) == 0 ||
510 4 : lua_getinfo(L, "f", &ar) == 0 || /* get calling function */
511 2 : lua_iscfunction(L, -1))
512 0 : luaL_error(L, LUA_QL("module") " not called from a Lua function");
513 2 : lua_pushvalue(L, -2);
514 2 : lua_setfenv(L, -2);
515 2 : lua_pop(L, 1);
516 2 : }
517 :
518 :
519 2 : static void dooptions (lua_State *L, int n) {
520 : int i;
521 3 : for (i = 2; i <= n; i++) {
522 1 : lua_pushvalue(L, i); /* get option (a function) */
523 1 : lua_pushvalue(L, -2); /* module */
524 1 : lua_call(L, 1, 0);
525 : }
526 2 : }
527 :
528 :
529 2 : static void modinit (lua_State *L, const char *modname) {
530 : const char *dot;
531 2 : lua_pushvalue(L, -1);
532 2 : lua_setfield(L, -2, "_M"); /* module._M = module */
533 2 : lua_pushstring(L, modname);
534 2 : lua_setfield(L, -2, "_NAME");
535 2 : dot = strrchr(modname, '.'); /* look for last dot in module name */
536 2 : if (dot == NULL) dot = modname;
537 0 : else dot++;
538 : /* set _PACKAGE as package name (full module name minus last part) */
539 2 : lua_pushlstring(L, modname, dot - modname);
540 2 : lua_setfield(L, -2, "_PACKAGE");
541 2 : }
542 :
543 :
544 2 : static int ll_module (lua_State *L) {
545 2 : const char *modname = luaL_checkstring(L, 1);
546 2 : int loaded = lua_gettop(L) + 1; /* index of _LOADED table */
547 2 : lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
548 2 : lua_getfield(L, loaded, modname); /* get _LOADED[modname] */
549 2 : if (!lua_istable(L, -1)) { /* not found? */
550 2 : lua_pop(L, 1); /* remove previous result */
551 : /* try global variable (and create one if it does not exist) */
552 2 : if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)
553 0 : return luaL_error(L, "name conflict for module " LUA_QS, modname);
554 2 : lua_pushvalue(L, -1);
555 2 : lua_setfield(L, loaded, modname); /* _LOADED[modname] = new table */
556 : }
557 : /* check whether table already has a _NAME field */
558 2 : lua_getfield(L, -1, "_NAME");
559 2 : if (!lua_isnil(L, -1)) /* is table an initialized module? */
560 0 : lua_pop(L, 1);
561 : else { /* no; initialize it */
562 2 : lua_pop(L, 1);
563 2 : modinit(L, modname);
564 : }
565 2 : lua_pushvalue(L, -1);
566 2 : setfenv(L);
567 2 : dooptions(L, loaded - 1);
568 2 : return 0;
569 : }
570 :
571 :
572 2 : static int ll_seeall (lua_State *L) {
573 2 : luaL_checktype(L, 1, LUA_TTABLE);
574 2 : if (!lua_getmetatable(L, 1)) {
575 2 : lua_createtable(L, 0, 1); /* create new metatable */
576 2 : lua_pushvalue(L, -1);
577 2 : lua_setmetatable(L, 1);
578 : }
579 2 : lua_pushvalue(L, LUA_GLOBALSINDEX);
580 2 : lua_setfield(L, -2, "__index"); /* mt.__index = _G */
581 2 : return 0;
582 : }
583 :
584 :
585 : /* }====================================================== */
586 :
587 :
588 :
589 : /* auxiliary mark (for internal use) */
590 : #define AUXMARK "\1"
591 :
592 166 : static void setpath (lua_State *L, const char *fieldname, const char *envname,
593 : const char *def) {
594 166 : const char *path = getenv(envname);
595 166 : if (path == NULL) /* no environment variable? */
596 0 : lua_pushstring(L, def); /* use default */
597 : else {
598 : /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
599 166 : path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,
600 : LUA_PATHSEP AUXMARK LUA_PATHSEP);
601 166 : luaL_gsub(L, path, AUXMARK, def);
602 166 : lua_remove(L, -2);
603 : }
604 : setprogdir(L);
605 166 : lua_setfield(L, -2, fieldname);
606 166 : }
607 :
608 :
609 : static const luaL_Reg pk_funcs[] = {
610 : {"loadlib", ll_loadlib},
611 : {"seeall", ll_seeall},
612 : {NULL, NULL}
613 : };
614 :
615 :
616 : static const luaL_Reg ll_funcs[] = {
617 : {"module", ll_module},
618 : {"require", ll_require},
619 : {NULL, NULL}
620 : };
621 :
622 :
623 : static const lua_CFunction loaders[] =
624 : {loader_preload, loader_Lua, loader_C, loader_Croot, NULL};
625 :
626 :
627 83 : LUALIB_API int luaopen_package (lua_State *L) {
628 : int i;
629 : /* create new type _LOADLIB */
630 83 : luaL_newmetatable(L, "_LOADLIB");
631 83 : lua_pushcfunction(L, gctm);
632 83 : lua_setfield(L, -2, "__gc");
633 : /* create `package' table */
634 83 : luaL_register(L, LUA_LOADLIBNAME, pk_funcs);
635 : #if defined(LUA_COMPAT_LOADLIB)
636 : lua_getfield(L, -1, "loadlib");
637 : lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
638 : #endif
639 83 : lua_pushvalue(L, -1);
640 83 : lua_replace(L, LUA_ENVIRONINDEX);
641 : /* create `loaders' table */
642 83 : lua_createtable(L, sizeof(loaders)/sizeof(loaders[0]) - 1, 0);
643 : /* fill it with pre-defined loaders */
644 415 : for (i=0; loaders[i] != NULL; i++) {
645 332 : lua_pushcfunction(L, loaders[i]);
646 332 : lua_rawseti(L, -2, i+1);
647 : }
648 83 : lua_setfield(L, -2, "loaders"); /* put it in field `loaders' */
649 83 : setpath(L, "path", LUA_PATH, LUA_PATH_DEFAULT); /* set field `path' */
650 83 : setpath(L, "cpath", LUA_CPATH, LUA_CPATH_DEFAULT); /* set field `cpath' */
651 : /* store config information */
652 83 : lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n"
653 : LUA_EXECDIR "\n" LUA_IGMARK);
654 83 : lua_setfield(L, -2, "config");
655 : /* set field `loaded' */
656 83 : luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 2);
657 83 : lua_setfield(L, -2, "loaded");
658 : /* set field `preload' */
659 83 : lua_newtable(L);
660 83 : lua_setfield(L, -2, "preload");
661 83 : lua_pushvalue(L, LUA_GLOBALSINDEX);
662 83 : luaL_register(L, NULL, ll_funcs); /* open lib into global table */
663 83 : lua_pop(L, 1);
664 83 : return 1; /* return 'package' table */
665 : }
666 :
|
