dependencies/lua-5.3/src/loadlib.c

   1 /*
   2 ** $Id: loadlib.c,v 1.130 2017/01/12 17:14:26 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 */
 238   lua_pushliteral(L, DLMSG);
 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 */
 245   lua_pushliteral(L, DLMSG);
 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;
 319   lua_rawgetp(L, LUA_REGISTRYINDEX, &CLIBS);
 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) {
 332   lua_rawgetp(L, LUA_REGISTRYINDEX, &CLIBS);
 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] */
 349     lsys_unloadlib(lua_touserdata(L, -1));
 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);
 562   lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
 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 */
 600   lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
 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   }
 698   lua_pushglobaltable(L);
 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[] =
 735     {searcher_preload, searcher_Lua, searcher_C, searcher_Croot, NULL};
 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 */
 760   lua_pushcfunction(L, gctm);
 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
 767 LUAMOD_API int luaopen_package (lua_State *L) {
 768   createclibstable(L);
 769   luaL_newlib(L, pk_funcs);  /* create 'package' table */
 770   createsearcherstable(L);
 771   /* set paths */
 772   setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
 773   setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
 774   /* store config information */
 775   lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
 776                      LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
 777   lua_setfield(L, -2, "config");
 778   /* set field 'loaded' */
 779   luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
 780   lua_setfield(L, -2, "loaded");
 781   /* set field 'preload' */
 782   luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
 783   lua_setfield(L, -2, "preload");
 784   lua_pushglobaltable(L);
 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