The Battle for Wesnoth  1.15.0-dev
loadlib.cpp
Go to the documentation of this file.
1 /*
2 ** $Id: loadlib.c,v 1.130.1.1 2017/04/19 17:20:42 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 Windows, and a stub for other
8 ** systems.
9 */
10 
11 #define loadlib_c
12 #define LUA_LIB
13 
14 #include "lprefix.h"
15 
16 
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 
21 #include "lua.h"
22 
23 #include "lauxlib.h"
24 #include "lualib.h"
25 
26 
27 /*
28 ** LUA_IGMARK is a mark to ignore all before it when building the
29 ** luaopen_ function name.
30 */
31 #if !defined (LUA_IGMARK)
32 #define LUA_IGMARK "-"
33 #endif
34 
35 
36 /*
37 ** LUA_CSUBSEP is the character that replaces dots in submodule names
38 ** when searching for a C loader.
39 ** LUA_LSUBSEP is the character that replaces dots in submodule names
40 ** when searching for a Lua loader.
41 */
42 #if !defined(LUA_CSUBSEP)
43 #define LUA_CSUBSEP LUA_DIRSEP
44 #endif
45 
46 #if !defined(LUA_LSUBSEP)
47 #define LUA_LSUBSEP LUA_DIRSEP
48 #endif
49 
50 
51 /* prefix for open functions in C libraries */
52 #define LUA_POF "luaopen_"
53 
54 /* separator for open functions in C libraries */
55 #define LUA_OFSEP "_"
56 
57 
58 /*
59 ** unique key for table in the registry that keeps handles
60 ** for all loaded C libraries
61 */
62 static const int CLIBS = 0;
63 
64 #define LIB_FAIL "open"
65 
66 
67 #define setprogdir(L) ((void)0)
68 
69 
70 /*
71 ** system-dependent functions
72 */
73 
74 /*
75 ** unload library 'lib'
76 */
77 static void lsys_unloadlib (void *lib);
78 
79 /*
80 ** load C library in file 'path'. If 'seeglb', load with all names in
81 ** the library global.
82 ** Returns the library; in case of error, returns NULL plus an
83 ** error string in the stack.
84 */
85 static void *lsys_load (lua_State *L, const char *path, int seeglb);
86 
87 /*
88 ** Try to find a function named 'sym' in library 'lib'.
89 ** Returns the function; in case of error, returns NULL plus an
90 ** error string in the stack.
91 */
92 static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym);
93 
94 
95 
96 
97 #if defined(LUA_USE_DLOPEN) /* { */
98 /*
99 ** {========================================================================
100 ** This is an implementation of loadlib based on the dlfcn interface.
101 ** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
102 ** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least
103 ** as an emulation layer on top of native functions.
104 ** =========================================================================
105 */
106 
107 #include <dlfcn.h>
108 
109 /*
110 ** Macro to convert pointer-to-void* to pointer-to-function. This cast
111 ** is undefined according to ISO C, but POSIX assumes that it works.
112 ** (The '__extension__' in gnu compilers is only to avoid warnings.)
113 */
114 #if defined(__GNUC__)
115 #define cast_func(p) (__extension__ (lua_CFunction)(p))
116 #else
117 #define cast_func(p) ((lua_CFunction)(p))
118 #endif
119 
120 
121 static void lsys_unloadlib (void *lib) {
122  dlclose(lib);
123 }
124 
125 
126 static void *lsys_load (lua_State *L, const char *path, int seeglb) {
127  void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
128  if (lib == NULL) lua_pushstring(L, dlerror());
129  return lib;
130 }
131 
132 
133 static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
134  lua_CFunction f = cast_func(dlsym(lib, sym));
135  if (f == NULL) lua_pushstring(L, dlerror());
136  return f;
137 }
138 
139 /* }====================================================== */
140 
141 
142 
143 #elif defined(LUA_DL_DLL) /* }{ */
144 /*
145 ** {======================================================================
146 ** This is an implementation of loadlib for Windows using native functions.
147 ** =======================================================================
148 */
149 
150 #include <windows.h>
151 
152 
153 /*
154 ** optional flags for LoadLibraryEx
155 */
156 #if !defined(LUA_LLE_FLAGS)
157 #define LUA_LLE_FLAGS 0
158 #endif
159 
160 
161 #undef setprogdir
162 
163 
164 /*
165 ** Replace in the path (on the top of the stack) any occurrence
166 ** of LUA_EXEC_DIR with the executable's path.
167 */
168 static void setprogdir (lua_State *L) {
169  char buff[MAX_PATH + 1];
170  char *lb;
171  DWORD nsize = sizeof(buff)/sizeof(char);
172  DWORD n = GetModuleFileNameA(NULL, buff, nsize); /* get exec. name */
173  if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
174  luaL_error(L, "unable to get ModuleFileName");
175  else {
176  *lb = '\0'; /* cut name on the last '\\' to get the path */
177  luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff);
178  lua_remove(L, -2); /* remove original string */
179  }
180 }
181 
182 
183 
184 
185 static void pusherror (lua_State *L) {
186  int error = GetLastError();
187  char buffer[128];
188  if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
189  NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL))
190  lua_pushstring(L, buffer);
191  else
192  lua_pushfstring(L, "system error %d\n", error);
193 }
194 
195 static void lsys_unloadlib (void *lib) {
196  FreeLibrary((HMODULE)lib);
197 }
198 
199 
200 static void *lsys_load (lua_State *L, const char *path, int seeglb) {
201  HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
202  (void)(seeglb); /* not used: symbols are 'global' by default */
203  if (lib == NULL) pusherror(L);
204  return lib;
205 }
206 
207 
208 static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
209  lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym);
210  if (f == NULL) pusherror(L);
211  return f;
212 }
213 
214 /* }====================================================== */
215 
216 
217 #else /* }{ */
218 /*
219 ** {======================================================
220 ** Fallback for other systems
221 ** =======================================================
222 */
223 
224 #undef LIB_FAIL
225 #define LIB_FAIL "absent"
226 
227 
228 #define DLMSG "dynamic libraries not enabled; check your Lua installation"
229 
230 
231 static void lsys_unloadlib (void *lib) {
232  (void)(lib); /* not used */
233 }
234 
235 
236 static void *lsys_load (lua_State *L, const char *path, int seeglb) {
237  (void)(path); (void)(seeglb); /* not used */
239  return NULL;
240 }
241 
242 
243 static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
244  (void)(lib); (void)(sym); /* not used */
246  return NULL;
247 }
248 
249 /* }====================================================== */
250 #endif /* } */
251 
252 
253 /*
254 ** {==================================================================
255 ** Set Paths
256 ** ===================================================================
257 */
258 
259 /*
260 ** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
261 ** variables that Lua check to set its paths.
262 */
263 #if !defined(LUA_PATH_VAR)
264 #define LUA_PATH_VAR "LUA_PATH"
265 #endif
266 
267 #if !defined(LUA_CPATH_VAR)
268 #define LUA_CPATH_VAR "LUA_CPATH"
269 #endif
270 
271 
272 #define AUXMARK "\1" /* auxiliary mark */
273 
274 
275 /*
276 ** return registry.LUA_NOENV as a boolean
277 */
278 static int noenv (lua_State *L) {
279  int b;
280  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
281  b = lua_toboolean(L, -1);
282  lua_pop(L, 1); /* remove value */
283  return b;
284 }
285 
286 
287 /*
288 ** Set a path
289 */
290 static void setpath (lua_State *L, const char *fieldname,
291  const char *envname,
292  const char *dft) {
293  const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
294  const char *path = getenv(nver); /* use versioned name */
295  if (path == NULL) /* no environment variable? */
296  path = getenv(envname); /* try unversioned name */
297  if (path == NULL || noenv(L)) /* no environment variable? */
298  lua_pushstring(L, dft); /* use default */
299  else {
300  /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
301  path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
302  LUA_PATH_SEP AUXMARK LUA_PATH_SEP);
303  luaL_gsub(L, path, AUXMARK, dft);
304  lua_remove(L, -2); /* remove result from 1st 'gsub' */
305  }
306  setprogdir(L);
307  lua_setfield(L, -3, fieldname); /* package[fieldname] = path value */
308  lua_pop(L, 1); /* pop versioned variable name */
309 }
310 
311 /* }================================================================== */
312 
313 
314 /*
315 ** return registry.CLIBS[path]
316 */
317 static void *checkclib (lua_State *L, const char *path) {
318  void *plib;
320  lua_getfield(L, -1, path);
321  plib = lua_touserdata(L, -1); /* plib = CLIBS[path] */
322  lua_pop(L, 2); /* pop CLIBS table and 'plib' */
323  return plib;
324 }
325 
326 
327 /*
328 ** registry.CLIBS[path] = plib -- for queries
329 ** registry.CLIBS[#CLIBS + 1] = plib -- also keep a list of all libraries
330 */
331 static void addtoclib (lua_State *L, const char *path, void *plib) {
333  lua_pushlightuserdata(L, plib);
334  lua_pushvalue(L, -1);
335  lua_setfield(L, -3, path); /* CLIBS[path] = plib */
336  lua_rawseti(L, -2, luaL_len(L, -2) + 1); /* CLIBS[#CLIBS + 1] = plib */
337  lua_pop(L, 1); /* pop CLIBS table */
338 }
339 
340 
341 /*
342 ** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib
343 ** handles in list CLIBS
344 */
345 static int gctm (lua_State *L) {
346  lua_Integer n = luaL_len(L, 1);
347  for (; n >= 1; n--) { /* for each handle, in reverse order */
348  lua_rawgeti(L, 1, n); /* get handle CLIBS[n] */
350  lua_pop(L, 1); /* pop handle */
351  }
352  return 0;
353 }
354 
355 
356 
357 /* error codes for 'lookforfunc' */
358 #define ERRLIB 1
359 #define ERRFUNC 2
360 
361 /*
362 ** Look for a C function named 'sym' in a dynamically loaded library
363 ** 'path'.
364 ** First, check whether the library is already loaded; if not, try
365 ** to load it.
366 ** Then, if 'sym' is '*', return true (as library has been loaded).
367 ** Otherwise, look for symbol 'sym' in the library and push a
368 ** C function with that symbol.
369 ** Return 0 and 'true' or a function in the stack; in case of
370 ** errors, return an error code and an error message in the stack.
371 */
372 static int lookforfunc (lua_State *L, const char *path, const char *sym) {
373  void *reg = checkclib(L, path); /* check loaded C libraries */
374  if (reg == NULL) { /* must load library? */
375  reg = lsys_load(L, path, *sym == '*'); /* global symbols if 'sym'=='*' */
376  if (reg == NULL) return ERRLIB; /* unable to load library */
377  addtoclib(L, path, reg);
378  }
379  if (*sym == '*') { /* loading only library (no function)? */
380  lua_pushboolean(L, 1); /* return 'true' */
381  return 0; /* no errors */
382  }
383  else {
384  lua_CFunction f = lsys_sym(L, reg, sym);
385  if (f == NULL)
386  return ERRFUNC; /* unable to find function */
387  lua_pushcfunction(L, f); /* else create new function */
388  return 0; /* no errors */
389  }
390 }
391 
392 
393 static int ll_loadlib (lua_State *L) {
394  const char *path = luaL_checkstring(L, 1);
395  const char *init = luaL_checkstring(L, 2);
396  int stat = lookforfunc(L, path, init);
397  if (stat == 0) /* no errors? */
398  return 1; /* return the loaded function */
399  else { /* error; error message is on stack top */
400  lua_pushnil(L);
401  lua_insert(L, -2);
402  lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : "init");
403  return 3; /* return nil, error message, and where */
404  }
405 }
406 
407 
408 
409 /*
410 ** {======================================================
411 ** 'require' function
412 ** =======================================================
413 */
414 
415 
416 static int readable (const char *filename) {
417  FILE *f = fopen(filename, "r"); /* try to open file */
418  if (f == NULL) return 0; /* open failed */
419  fclose(f);
420  return 1;
421 }
422 
423 
424 static const char *pushnexttemplate (lua_State *L, const char *path) {
425  const char *l;
426  while (*path == *LUA_PATH_SEP) path++; /* skip separators */
427  if (*path == '\0') return NULL; /* no more templates */
428  l = strchr(path, *LUA_PATH_SEP); /* find next separator */
429  if (l == NULL) l = path + strlen(path);
430  lua_pushlstring(L, path, l - path); /* template */
431  return l;
432 }
433 
434 
435 static const char *searchpath (lua_State *L, const char *name,
436  const char *path,
437  const char *sep,
438  const char *dirsep) {
439  luaL_Buffer msg; /* to build error message */
440  luaL_buffinit(L, &msg);
441  if (*sep != '\0') /* non-empty separator? */
442  name = luaL_gsub(L, name, sep, dirsep); /* replace it by 'dirsep' */
443  while ((path = pushnexttemplate(L, path)) != NULL) {
444  const char *filename = luaL_gsub(L, lua_tostring(L, -1),
445  LUA_PATH_MARK, name);
446  lua_remove(L, -2); /* remove path template */
447  if (readable(filename)) /* does file exist and is readable? */
448  return filename; /* return that file name */
449  lua_pushfstring(L, "\n\tno file '%s'", filename);
450  lua_remove(L, -2); /* remove file name */
451  luaL_addvalue(&msg); /* concatenate error msg. entry */
452  }
453  luaL_pushresult(&msg); /* create error message */
454  return NULL; /* not found */
455 }
456 
457 
458 static int ll_searchpath (lua_State *L) {
459  const char *f = searchpath(L, luaL_checkstring(L, 1),
460  luaL_checkstring(L, 2),
461  luaL_optstring(L, 3, "."),
462  luaL_optstring(L, 4, LUA_DIRSEP));
463  if (f != NULL) return 1;
464  else { /* error message is on top of the stack */
465  lua_pushnil(L);
466  lua_insert(L, -2);
467  return 2; /* return nil + error message */
468  }
469 }
470 
471 
472 static const char *findfile (lua_State *L, const char *name,
473  const char *pname,
474  const char *dirsep) {
475  const char *path;
476  lua_getfield(L, lua_upvalueindex(1), pname);
477  path = lua_tostring(L, -1);
478  if (path == NULL)
479  luaL_error(L, "'package.%s' must be a string", pname);
480  return searchpath(L, name, path, ".", dirsep);
481 }
482 
483 
484 static int checkload (lua_State *L, int stat, const char *filename) {
485  if (stat) { /* module loaded successfully? */
486  lua_pushstring(L, filename); /* will be 2nd argument to module */
487  return 2; /* return open function and file name */
488  }
489  else
490  return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
491  lua_tostring(L, 1), filename, lua_tostring(L, -1));
492 }
493 
494 
495 static int searcher_Lua (lua_State *L) {
496  const char *filename;
497  const char *name = luaL_checkstring(L, 1);
498  filename = findfile(L, name, "path", LUA_LSUBSEP);
499  if (filename == NULL) return 1; /* module not found in this path */
500  return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
501 }
502 
503 
504 /*
505 ** Try to find a load function for module 'modname' at file 'filename'.
506 ** First, change '.' to '_' in 'modname'; then, if 'modname' has
507 ** the form X-Y (that is, it has an "ignore mark"), build a function
508 ** name "luaopen_X" and look for it. (For compatibility, if that
509 ** fails, it also tries "luaopen_Y".) If there is no ignore mark,
510 ** look for a function named "luaopen_modname".
511 */
512 static int loadfunc (lua_State *L, const char *filename, const char *modname) {
513  const char *openfunc;
514  const char *mark;
515  modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
516  mark = strchr(modname, *LUA_IGMARK);
517  if (mark) {
518  int stat;
519  openfunc = lua_pushlstring(L, modname, mark - modname);
520  openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
521  stat = lookforfunc(L, filename, openfunc);
522  if (stat != ERRFUNC) return stat;
523  modname = mark + 1; /* else go ahead and try old-style name */
524  }
525  openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
526  return lookforfunc(L, filename, openfunc);
527 }
528 
529 
530 static int searcher_C (lua_State *L) {
531  const char *name = luaL_checkstring(L, 1);
532  const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP);
533  if (filename == NULL) return 1; /* module not found in this path */
534  return checkload(L, (loadfunc(L, filename, name) == 0), filename);
535 }
536 
537 
538 static int searcher_Croot (lua_State *L) {
539  const char *filename;
540  const char *name = luaL_checkstring(L, 1);
541  const char *p = strchr(name, '.');
542  int stat;
543  if (p == NULL) return 0; /* is root */
544  lua_pushlstring(L, name, p - name);
545  filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP);
546  if (filename == NULL) return 1; /* root not found */
547  if ((stat = loadfunc(L, filename, name)) != 0) {
548  if (stat != ERRFUNC)
549  return checkload(L, 0, filename); /* real error */
550  else { /* open function not found */
551  lua_pushfstring(L, "\n\tno module '%s' in file '%s'", name, filename);
552  return 1;
553  }
554  }
555  lua_pushstring(L, filename); /* will be 2nd argument to module */
556  return 2;
557 }
558 
559 
560 static int searcher_preload (lua_State *L) {
561  const char *name = luaL_checkstring(L, 1);
563  if (lua_getfield(L, -1, name) == LUA_TNIL) /* not found? */
564  lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
565  return 1;
566 }
567 
568 
569 static void findloader (lua_State *L, const char *name) {
570  int i;
571  luaL_Buffer msg; /* to build error message */
572  luaL_buffinit(L, &msg);
573  /* push 'package.searchers' to index 3 in the stack */
574  if (lua_getfield(L, lua_upvalueindex(1), "searchers") != LUA_TTABLE)
575  luaL_error(L, "'package.searchers' must be a table");
576  /* iterate over available searchers to find a loader */
577  for (i = 1; ; i++) {
578  if (lua_rawgeti(L, 3, i) == LUA_TNIL) { /* no more searchers? */
579  lua_pop(L, 1); /* remove nil */
580  luaL_pushresult(&msg); /* create error message */
581  luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1));
582  }
583  lua_pushstring(L, name);
584  lua_call(L, 1, 2); /* call it */
585  if (lua_isfunction(L, -2)) /* did it find a loader? */
586  return; /* module loader found */
587  else if (lua_isstring(L, -2)) { /* searcher returned error message? */
588  lua_pop(L, 1); /* remove extra return */
589  luaL_addvalue(&msg); /* concatenate error message */
590  }
591  else
592  lua_pop(L, 2); /* remove both returns */
593  }
594 }
595 
596 
597 static int ll_require (lua_State *L) {
598  const char *name = luaL_checkstring(L, 1);
599  lua_settop(L, 1); /* LOADED table will be at index 2 */
601  lua_getfield(L, 2, name); /* LOADED[name] */
602  if (lua_toboolean(L, -1)) /* is it there? */
603  return 1; /* package is already loaded */
604  /* else must load package */
605  lua_pop(L, 1); /* remove 'getfield' result */
606  findloader(L, name);
607  lua_pushstring(L, name); /* pass name as argument to module loader */
608  lua_insert(L, -2); /* name is 1st argument (before search data) */
609  lua_call(L, 2, 1); /* run loader to load module */
610  if (!lua_isnil(L, -1)) /* non-nil return? */
611  lua_setfield(L, 2, name); /* LOADED[name] = returned value */
612  if (lua_getfield(L, 2, name) == LUA_TNIL) { /* module set no value? */
613  lua_pushboolean(L, 1); /* use true as result */
614  lua_pushvalue(L, -1); /* extra copy to be returned */
615  lua_setfield(L, 2, name); /* LOADED[name] = true */
616  }
617  return 1;
618 }
619 
620 /* }====================================================== */
621 
622 
623 
624 /*
625 ** {======================================================
626 ** 'module' function
627 ** =======================================================
628 */
629 #if defined(LUA_COMPAT_MODULE)
630 
631 /*
632 ** changes the environment variable of calling function
633 */
634 static void set_env (lua_State *L) {
635  lua_Debug ar;
636  if (lua_getstack(L, 1, &ar) == 0 ||
637  lua_getinfo(L, "f", &ar) == 0 || /* get calling function */
638  lua_iscfunction(L, -1))
639  luaL_error(L, "'module' not called from a Lua function");
640  lua_pushvalue(L, -2); /* copy new environment table to top */
641  lua_setupvalue(L, -2, 1);
642  lua_pop(L, 1); /* remove function */
643 }
644 
645 
646 static void dooptions (lua_State *L, int n) {
647  int i;
648  for (i = 2; i <= n; i++) {
649  if (lua_isfunction(L, i)) { /* avoid 'calling' extra info. */
650  lua_pushvalue(L, i); /* get option (a function) */
651  lua_pushvalue(L, -2); /* module */
652  lua_call(L, 1, 0);
653  }
654  }
655 }
656 
657 
658 static void modinit (lua_State *L, const char *modname) {
659  const char *dot;
660  lua_pushvalue(L, -1);
661  lua_setfield(L, -2, "_M"); /* module._M = module */
662  lua_pushstring(L, modname);
663  lua_setfield(L, -2, "_NAME");
664  dot = strrchr(modname, '.'); /* look for last dot in module name */
665  if (dot == NULL) dot = modname;
666  else dot++;
667  /* set _PACKAGE as package name (full module name minus last part) */
668  lua_pushlstring(L, modname, dot - modname);
669  lua_setfield(L, -2, "_PACKAGE");
670 }
671 
672 
673 static int ll_module (lua_State *L) {
674  const char *modname = luaL_checkstring(L, 1);
675  int lastarg = lua_gettop(L); /* last parameter */
676  luaL_pushmodule(L, modname, 1); /* get/create module table */
677  /* check whether table already has a _NAME field */
678  if (lua_getfield(L, -1, "_NAME") != LUA_TNIL)
679  lua_pop(L, 1); /* table is an initialized module */
680  else { /* no; initialize it */
681  lua_pop(L, 1);
682  modinit(L, modname);
683  }
684  lua_pushvalue(L, -1);
685  set_env(L);
686  dooptions(L, lastarg);
687  return 1;
688 }
689 
690 
691 static int ll_seeall (lua_State *L) {
692  luaL_checktype(L, 1, LUA_TTABLE);
693  if (!lua_getmetatable(L, 1)) {
694  lua_createtable(L, 0, 1); /* create new metatable */
695  lua_pushvalue(L, -1);
696  lua_setmetatable(L, 1);
697  }
699  lua_setfield(L, -2, "__index"); /* mt.__index = _G */
700  return 0;
701 }
702 
703 #endif
704 /* }====================================================== */
705 
706 
707 
708 static const luaL_Reg pk_funcs[] = {
709  {"loadlib", ll_loadlib},
710  {"searchpath", ll_searchpath},
711 #if defined(LUA_COMPAT_MODULE)
712  {"seeall", ll_seeall},
713 #endif
714  /* placeholders */
715  {"preload", NULL},
716  {"cpath", NULL},
717  {"path", NULL},
718  {"searchers", NULL},
719  {"loaded", NULL},
720  {NULL, NULL}
721 };
722 
723 
724 static const luaL_Reg ll_funcs[] = {
725 #if defined(LUA_COMPAT_MODULE)
726  {"module", ll_module},
727 #endif
728  {"require", ll_require},
729  {NULL, NULL}
730 };
731 
732 
733 static void createsearcherstable (lua_State *L) {
734  static const lua_CFunction searchers[] =
736  int i;
737  /* create 'searchers' table */
738  lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
739  /* fill it with predefined searchers */
740  for (i=0; searchers[i] != NULL; i++) {
741  lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */
742  lua_pushcclosure(L, searchers[i], 1);
743  lua_rawseti(L, -2, i+1);
744  }
745 #if defined(LUA_COMPAT_LOADERS)
746  lua_pushvalue(L, -1); /* make a copy of 'searchers' table */
747  lua_setfield(L, -3, "loaders"); /* put it in field 'loaders' */
748 #endif
749  lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */
750 }
751 
752 
753 /*
754 ** create table CLIBS to keep track of loaded C libraries,
755 ** setting a finalizer to close all libraries when closing state.
756 */
757 static void createclibstable (lua_State *L) {
758  lua_newtable(L); /* create CLIBS table */
759  lua_createtable(L, 0, 1); /* create metatable for CLIBS */
761  lua_setfield(L, -2, "__gc"); /* set finalizer for CLIBS table */
762  lua_setmetatable(L, -2);
763  lua_rawsetp(L, LUA_REGISTRYINDEX, &CLIBS); /* set CLIBS table in registry */
764 }
765 
766 
768  createclibstable(L);
769  luaL_newlib(L, pk_funcs); /* create 'package' table */
771  /* set paths */
774  /* store config information */
776  LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
777  lua_setfield(L, -2, "config");
778  /* set field 'loaded' */
780  lua_setfield(L, -2, "loaded");
781  /* set field 'preload' */
783  lua_setfield(L, -2, "preload");
785  lua_pushvalue(L, -2); /* set 'package' as upvalue for next lib */
786  luaL_setfuncs(L, ll_funcs, 1); /* open lib into global table */
787  lua_pop(L, 1); /* pop global table */
788  return 1; /* return 'package' table */
789 }
790 
Definition: lua.h:441
LUALIB_API void luaL_addvalue(luaL_Buffer *B)
Definition: lauxlib.cpp:558
LUA_API void lua_pushlightuserdata(lua_State *L, void *p)
Definition: lapi.cpp:565
#define LUA_IGMARK
Definition: loadlib.cpp:32
LUA_API void lua_createtable(lua_State *L, int narray, int nrec)
Definition: lapi.cpp:684
#define lua_pushcfunction(L, f)
Definition: lua.h:350
#define LUA_PATH_VAR
Definition: loadlib.cpp:264
#define LUA_CSUBSEP
Definition: loadlib.cpp:43
#define LUA_POF
Definition: loadlib.cpp:52
LUALIB_API lua_Integer luaL_len(lua_State *L, int idx)
Definition: lauxlib.cpp:798
static int ll_searchpath(lua_State *L)
Definition: loadlib.cpp:458
static int ll_require(lua_State *L)
Definition: loadlib.cpp:597
static void findloader(lua_State *L, const char *name)
Definition: loadlib.cpp:569
LUA_API void lua_settop(lua_State *L, int idx)
Definition: lapi.cpp:172
static const luaL_Reg pk_funcs[]
Definition: loadlib.cpp:708
static int loadfunc(lua_State *L, const char *filename, const char *modname)
Definition: loadlib.cpp:512
#define LUA_CPATH_DEFAULT
Definition: luaconf.h:210
#define LUA_LOADED_TABLE
Definition: lauxlib.h:24
LUA_API void lua_pushboolean(lua_State *L, int b)
Definition: lapi.cpp:557
LUA_API int lua_rawgeti(lua_State *L, int idx, lua_Integer n)
Definition: lapi.cpp:658
static int searcher_C(lua_State *L)
Definition: loadlib.cpp:530
LUALIB_API int luaL_getsubtable(lua_State *L, int idx, const char *fname)
Definition: lauxlib.cpp:951
static l_noret error(LoadState *S, const char *why)
Definition: lundump.cpp:39
LUALIB_API void luaL_pushresult(luaL_Buffer *B)
Definition: lauxlib.cpp:542
LUA_API void lua_rawseti(lua_State *L, int idx, lua_Integer n)
Definition: lapi.cpp:817
LUA_API int lua_gettop(lua_State *L)
Definition: lapi.cpp:167
#define LUA_PRELOAD_TABLE
Definition: lauxlib.h:28
#define lua_remove(L, idx)
Definition: lua.h:371
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
#define LIB_FAIL
Definition: loadlib.cpp:225
LUA_API void lua_pushcclosure(lua_State *L, lua_CFunction fn, int n)
Definition: lapi.cpp:532
static void createsearcherstable(lua_State *L)
Definition: loadlib.cpp:733
LUA_API int lua_getstack(lua_State *L, int level, lua_Debug *ar)
Definition: ldebug.cpp:110
static int lookforfunc(lua_State *L, const char *path, const char *sym)
Definition: loadlib.cpp:372
#define ERRLIB
Definition: loadlib.cpp:358
static int ll_loadlib(lua_State *L)
Definition: loadlib.cpp:393
static int checkload(lua_State *L, int stat, const char *filename)
Definition: loadlib.cpp:484
#define lua_pop(L, n)
Definition: lua.h:344
#define luaL_loadfile(L, f)
Definition: lauxlib.h:86
#define b
static const char * name(const std::vector< SDL_Joystick *> &joysticks, const std::size_t index)
Definition: joystick.cpp:48
#define lua_upvalueindex(i)
Definition: lua.h:43
LUA_INTEGER lua_Integer
Definition: lua.h:93
struct utils::detail::formula_initer init
LUALIB_API const char * luaL_gsub(lua_State *L, const char *s, const char *p, const char *r)
Definition: lauxlib.cpp:991
int(* lua_CFunction)(lua_State *L)
Definition: lua.h:105
LUA_API int lua_isstring(lua_State *L, int idx)
Definition: lapi.cpp:283
static void * checkclib(lua_State *L, const char *path)
Definition: loadlib.cpp:317
#define LUA_TNIL
Definition: lua.h:64
#define LUA_VERSUFFIX
Definition: lualib.h:15
LUA_API int lua_toboolean(lua_State *L, int idx)
Definition: lapi.cpp:367
#define LUA_OFSEP
Definition: loadlib.cpp:55
#define lua_pushglobaltable(L)
Definition: lua.h:363
LUAMOD_API int luaopen_package(lua_State *L)
Definition: loadlib.cpp:767
LUALIB_API void luaL_buffinit(lua_State *L, luaL_Buffer *B)
Definition: lauxlib.cpp:569
static const int CLIBS
Definition: loadlib.cpp:62
#define AUXMARK
Definition: loadlib.cpp:272
#define LUA_LSUBSEP
Definition: loadlib.cpp:47
LUA_API const char * lua_pushlstring(lua_State *L, const char *s, size_t len)
Definition: lapi.cpp:479
LUA_API int lua_getmetatable(lua_State *L, int objindex)
Definition: lapi.cpp:697
static void createclibstable(lua_State *L)
Definition: loadlib.cpp:757
LUA_API int lua_rawgetp(lua_State *L, int idx, const void *p)
Definition: lapi.cpp:670
LUA_API int lua_setmetatable(lua_State *L, int objindex)
Definition: lapi.cpp:846
std::string path
Definition: game_config.cpp:39
static void addtoclib(lua_State *L, const char *path, void *plib)
Definition: loadlib.cpp:331
#define lua_newtable(L)
Definition: lua.h:346
LUA_API void lua_pushnil(lua_State *L)
Definition: lapi.cpp:450
LUA_API const char * lua_setupvalue(lua_State *L, int funcindex, int n)
Definition: lapi.cpp:1236
#define lua_pushliteral(L, s)
Definition: lua.h:361
#define LUA_DIRSEP
Definition: luaconf.h:223
LUALIB_API void luaL_checktype(lua_State *L, int arg, int t)
Definition: lauxlib.cpp:378
static std::string mark
Definition: tstring.cpp:73
LUA_API void * lua_touserdata(lua_State *L, int idx)
Definition: lapi.cpp:413
#define LUA_PATH_SEP
Definition: luaconf.h:168
#define lua_isnil(L, n)
Definition: lua.h:355
std::size_t i
Definition: function.cpp:933
static int searcher_preload(lua_State *L)
Definition: loadlib.cpp:560
LUA_API int lua_getinfo(lua_State *L, const char *what, lua_Debug *ar)
Definition: ldebug.cpp:309
mock_party p
#define lua_isfunction(L, n)
Definition: lua.h:352
static const char * pushnexttemplate(lua_State *L, const char *path)
Definition: loadlib.cpp:424
#define LUAMOD_API
Definition: luaconf.h:261
#define lua_tostring(L, i)
Definition: lua.h:366
static void lsys_unloadlib(void *lib)
Definition: loadlib.cpp:231
LUA_API void lua_rawsetp(lua_State *L, int idx, const void *p)
Definition: lapi.cpp:830
static int searcher_Croot(lua_State *L)
Definition: loadlib.cpp:538
LUA_API int lua_iscfunction(lua_State *L, int idx)
Definition: lapi.cpp:264
LUA_API void lua_pushvalue(lua_State *L, int idx)
Definition: lapi.cpp:237
#define luaL_newlib(L, l)
Definition: lauxlib.h:119
#define lua_call(L, n, r)
Definition: lua.h:274
LUALIB_API int luaL_error(lua_State *L, const char *fmt,...)
Definition: lauxlib.cpp:223
static int searcher_Lua(lua_State *L)
Definition: loadlib.cpp:495
#define LUA_REGISTRYINDEX
Definition: lua.h:42
static int readable(const char *filename)
Definition: loadlib.cpp:416
static void setpath(lua_State *L, const char *fieldname, const char *envname, const char *dft)
Definition: loadlib.cpp:290
static int noenv(lua_State *L)
Definition: loadlib.cpp:278
#define f
#define LUA_OK
Definition: lua.h:47
static int gctm(lua_State *L)
Definition: loadlib.cpp:345
#define lua_insert(L, idx)
Definition: lua.h:369
#define LUA_PATH_DEFAULT
Definition: luaconf.h:206
LUA_API const char * lua_pushfstring(lua_State *L, const char *fmt,...)
Definition: lapi.cpp:519
static const luaL_Reg ll_funcs[]
Definition: loadlib.cpp:724
static const char * searchpath(lua_State *L, const char *name, const char *path, const char *sep, const char *dirsep)
Definition: loadlib.cpp:435
LUALIB_API void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup)
Definition: lauxlib.cpp:934
#define LUA_EXEC_DIR
Definition: luaconf.h:170
#define ERRFUNC
Definition: loadlib.cpp:359
static const char * findfile(lua_State *L, const char *name, const char *pname, const char *dirsep)
Definition: loadlib.cpp:472
LUA_API int lua_getfield(lua_State *L, int idx, const char *k)
Definition: lapi.cpp:622
#define setprogdir(L)
Definition: loadlib.cpp:67
#define DLMSG
Definition: loadlib.cpp:228
#define LUA_TTABLE
Definition: lua.h:69
static map_location::DIRECTION n
#define luaL_optstring(L, n, d)
Definition: lauxlib.h:125
static void * lsys_load(lua_State *L, const char *path, int seeglb)
Definition: loadlib.cpp:236
LUA_API const char * lua_pushstring(lua_State *L, const char *s)
Definition: lapi.cpp:491
LUA_API void lua_setfield(lua_State *L, int idx, const char *k)
Definition: lapi.cpp:777
#define LUA_PATH_MARK
Definition: luaconf.h:169
#define LUA_CPATH_VAR
Definition: loadlib.cpp:268
static lua_CFunction lsys_sym(lua_State *L, void *lib, const char *sym)
Definition: loadlib.cpp:243
#define luaL_checkstring(L, n)
Definition: lauxlib.h:124