2003-03-17 16:04:58 +03:00
|
|
|
/*
|
2004-12-22 20:43:27 +03:00
|
|
|
** $Id: loadlib.c,v 1.12 2004/12/13 12:14:21 roberto Exp roberto $
|
2003-04-02 17:09:14 +04:00
|
|
|
** Dynamic library loader for Lua
|
2003-03-17 16:04:58 +03:00
|
|
|
** See Copyright Notice in lua.h
|
|
|
|
*
|
2004-10-07 21:27:20 +04:00
|
|
|
* This Lua library exports a single function, called loadlib, which
|
|
|
|
* is called from Lua as loadlib(lib,init), where lib is the full
|
|
|
|
* name of the library to be loaded (including the complete path) and
|
|
|
|
* init is the name of a function to be called after the library is
|
|
|
|
* loaded. Typically, this function will register other functions, thus
|
|
|
|
* making the complete library available to Lua. The init function is
|
|
|
|
* *not* automatically called by loadlib. Instead, loadlib returns the
|
|
|
|
* init function as a Lua function that the client can call when it
|
|
|
|
* thinks is appropriate. In the case of errors, loadlib returns nil and
|
|
|
|
* two strings describing the error. The first string is supplied by
|
|
|
|
* the operating system; it should be informative and useful for error
|
|
|
|
* messages. The second string is "open", "init", or "absent" to identify
|
|
|
|
* the error and is meant to be used for making decisions without having
|
|
|
|
* to look into the first string (whose format is system-dependent).
|
|
|
|
* This module contains an implementation of loadlib for Unix systems
|
|
|
|
* that have dlfcn, an implementation for Darwin (Mac OS X), an
|
|
|
|
* implementation for Windows, and a stub for other systems. See
|
|
|
|
* the list at the end of this file for some links to available
|
|
|
|
* implementations of dlfcn and interfaces to other native dynamic
|
|
|
|
* loaders on top of which loadlib could be implemented.
|
2003-03-17 16:04:58 +03:00
|
|
|
*/
|
|
|
|
|
2004-11-18 22:53:49 +03:00
|
|
|
|
2004-11-19 18:52:12 +03:00
|
|
|
#include <stdlib.h>
|
2004-11-18 22:53:49 +03:00
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
|
2004-05-01 00:13:38 +04:00
|
|
|
#define loadlib_c
|
|
|
|
#define LUA_LIB
|
|
|
|
|
2003-03-17 16:04:58 +03:00
|
|
|
#include "lua.h"
|
|
|
|
#include "lauxlib.h"
|
|
|
|
#include "lualib.h"
|
|
|
|
|
|
|
|
|
2004-11-11 18:42:57 +03:00
|
|
|
#define ERR_OPEN 1
|
|
|
|
#define ERR_FUNCTION 2
|
2004-12-13 15:14:21 +03:00
|
|
|
#define ERR_ABSENT 3
|
2004-11-11 18:42:57 +03:00
|
|
|
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
static void registerlib (lua_State *L, const void *lib);
|
2003-03-17 16:04:58 +03:00
|
|
|
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
#if defined(USE_DLOPEN)
|
2003-03-17 16:04:58 +03:00
|
|
|
/*
|
|
|
|
* This is an implementation of loadlib based on the dlfcn interface.
|
|
|
|
* The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
|
|
|
|
* NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least
|
|
|
|
* as an emulation layer on top of native functions.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <dlfcn.h>
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
#define freelib dlclose
|
|
|
|
|
2004-12-22 20:43:27 +03:00
|
|
|
static int loadlib(lua_State *L, const char *path, const char *init) {
|
|
|
|
void *lib=dlopen(path,RTLD_NOW);
|
|
|
|
if (lib != NULL) {
|
|
|
|
lua_CFunction f=(lua_CFunction) dlsym(lib,init);
|
|
|
|
if (f != NULL) {
|
|
|
|
registerlib(L, lib);
|
|
|
|
lua_pushcfunction(L,f);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* else return appropriate error message */
|
|
|
|
lua_pushstring(L,dlerror());
|
|
|
|
if (lib != NULL) {
|
|
|
|
dlclose(lib);
|
|
|
|
return ERR_FUNCTION; /* error loading function */
|
|
|
|
}
|
|
|
|
else return ERR_OPEN; /* error loading library */
|
2003-03-17 16:04:58 +03:00
|
|
|
}
|
|
|
|
|
2003-04-08 00:11:53 +04:00
|
|
|
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
#elif defined(USE_DLL)
|
2003-03-17 16:04:58 +03:00
|
|
|
/*
|
|
|
|
* This is an implementation of loadlib for Windows using native functions.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <windows.h>
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
#define freelib(lib) FreeLibrary((HINSTANCE)lib)
|
|
|
|
|
2004-12-22 20:43:27 +03:00
|
|
|
|
|
|
|
static void pusherror(lua_State *L) {
|
|
|
|
int error = GetLastError();
|
|
|
|
char buffer[128];
|
|
|
|
if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
|
|
0, error, 0, buffer, sizeof(buffer), 0))
|
|
|
|
lua_pushstring(L,buffer);
|
|
|
|
else
|
|
|
|
lua_pushfstring(L, "system error %d\n", error);
|
2003-03-17 16:04:58 +03:00
|
|
|
}
|
|
|
|
|
2004-12-22 20:43:27 +03:00
|
|
|
|
|
|
|
static int loadlib (lua_State *L, const char *path, const char *init) {
|
|
|
|
HINSTANCE lib = LoadLibrary(path);
|
|
|
|
if (lib != NULL) {
|
|
|
|
lua_CFunction f = (lua_CFunction)GetProcAddress(lib, init);
|
|
|
|
if (f != NULL) {
|
|
|
|
registerlib(L, lib);
|
|
|
|
lua_pushcfunction(L, f);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pusherror(L);
|
|
|
|
if (lib != NULL) {
|
|
|
|
FreeLibrary(lib);
|
|
|
|
return ERR_OPEN;
|
2003-03-17 16:04:58 +03:00
|
|
|
}
|
2004-12-22 20:43:27 +03:00
|
|
|
else return ERR_FUNCTION;
|
2003-03-17 16:04:58 +03:00
|
|
|
}
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
|
2003-04-08 00:11:53 +04:00
|
|
|
|
2004-10-07 21:27:20 +04:00
|
|
|
/* Native Mac OS X / Darwin Implementation */
|
2004-10-18 22:07:31 +04:00
|
|
|
#elif defined(USE_DYLD)
|
2004-10-07 21:27:20 +04:00
|
|
|
|
|
|
|
#include <mach-o/dyld.h>
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
|
|
|
|
/* Mach cannot unload images (?) */
|
|
|
|
#define freelib(lib) ((void)lib)
|
|
|
|
|
2004-12-22 20:43:27 +03:00
|
|
|
|
|
|
|
static void pusherror (lua_State *L) {
|
|
|
|
const char *err_str;
|
|
|
|
const char *err_file;
|
|
|
|
NSLinkEditErrors err;
|
|
|
|
int err_num;
|
|
|
|
NSLinkEditError(&err, &err_num, &err_file, &err_str);
|
|
|
|
lua_pushstring(L, err_str);
|
2004-10-18 22:07:31 +04:00
|
|
|
}
|
|
|
|
|
2004-12-22 20:43:27 +03:00
|
|
|
|
2004-11-11 18:42:57 +03:00
|
|
|
static int loadlib (lua_State *L, const char *path, const char *init) {
|
2004-10-07 21:27:20 +04:00
|
|
|
const struct mach_header *lib;
|
|
|
|
/* this would be a rare case, but prevents crashing if it happens */
|
|
|
|
if(!_dyld_present()) {
|
2004-12-22 20:43:27 +03:00
|
|
|
lua_pushstring(L, "dyld not present.");
|
2004-11-11 18:42:57 +03:00
|
|
|
return ERR_OPEN;
|
2004-10-07 21:27:20 +04:00
|
|
|
}
|
|
|
|
lib = NSAddImage(path, NSADDIMAGE_OPTION_RETURN_ON_ERROR);
|
|
|
|
if(lib != NULL) {
|
|
|
|
NSSymbol init_sym = NSLookupSymbolInImage(lib, init,
|
|
|
|
NSLOOKUPSYMBOLINIMAGE_OPTION_BIND |
|
|
|
|
NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
|
|
|
|
if(init_sym != NULL) {
|
|
|
|
lua_CFunction f = (lua_CFunction)NSAddressOfSymbol(init_sym);
|
2004-10-18 22:07:31 +04:00
|
|
|
registerlib(L, lib);
|
2004-12-22 20:43:27 +03:00
|
|
|
lua_pushcfunction(L, f);
|
2004-11-11 18:42:57 +03:00
|
|
|
return 0;
|
2004-10-07 21:27:20 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* else an error ocurred */
|
2004-10-18 22:07:31 +04:00
|
|
|
pusherror(L);
|
2004-10-07 21:27:20 +04:00
|
|
|
/* Can't unload image */
|
2004-11-11 18:42:57 +03:00
|
|
|
return (lib != NULL) ? ERR_FUNCTION : ERR_OPEN;
|
2004-10-07 21:27:20 +04:00
|
|
|
}
|
|
|
|
|
2003-04-08 00:11:53 +04:00
|
|
|
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
#else
|
2003-04-08 00:11:53 +04:00
|
|
|
/* Fallback for other systems */
|
|
|
|
|
2003-03-17 16:04:58 +03:00
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
#define freelib(lib) ((void)lib)
|
2003-05-15 01:01:53 +04:00
|
|
|
|
2004-12-22 20:43:27 +03:00
|
|
|
static int loadlib (lua_State *L, const char *path, const char *init) {
|
|
|
|
(void)path; (void)init; (void)®isterlib; /* to avoid warnings */
|
|
|
|
lua_pushliteral(L,"`loadlib' not supported");
|
|
|
|
return ERR_ABSENT;
|
2003-03-17 16:04:58 +03:00
|
|
|
}
|
2004-10-18 22:07:31 +04:00
|
|
|
|
2003-03-17 16:04:58 +03:00
|
|
|
#endif
|
|
|
|
|
2004-10-18 22:07:31 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** common code for all implementations: put a library into the registry
|
|
|
|
** so that, when Lua closes its state, the library's __gc metamethod
|
|
|
|
** will be called to unload the library.
|
|
|
|
*/
|
2004-12-22 20:43:27 +03:00
|
|
|
static void registerlib (lua_State *L, const void *lib) {
|
|
|
|
const void **plib = (const void **)lua_newuserdata(L, sizeof(const void *));
|
|
|
|
*plib = lib;
|
|
|
|
luaL_getmetatable(L, "_LOADLIB");
|
|
|
|
lua_setmetatable(L, -2);
|
|
|
|
lua_pushboolean(L, 1);
|
|
|
|
lua_settable(L, LUA_REGISTRYINDEX); /* registry[lib] = true */
|
2004-10-18 22:07:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** __gc tag method: calls library's `freelib' function with the lib
|
|
|
|
** handle
|
|
|
|
*/
|
2004-12-22 20:43:27 +03:00
|
|
|
static int gctm (lua_State *L) {
|
|
|
|
void *lib = *(void **)luaL_checkudata(L, 1, "_LOADLIB");
|
|
|
|
freelib(lib);
|
|
|
|
return 0;
|
2004-10-18 22:07:31 +04:00
|
|
|
}
|
|
|
|
|
2004-11-11 18:42:57 +03:00
|
|
|
|
2004-12-13 15:14:21 +03:00
|
|
|
static int ll_loadlib (lua_State *L) {
|
2004-12-22 20:43:27 +03:00
|
|
|
static const char *const errcodes[] = {NULL, "open", "init", "absent"};
|
|
|
|
const char *path = luaL_checkstring(L, 1);
|
|
|
|
const char *init = luaL_checkstring(L, 2);
|
|
|
|
int res = loadlib(L,path,init);
|
|
|
|
if (res == 0) /* no error? */
|
|
|
|
return 1; /* function is at stack top */
|
|
|
|
else { /* error */
|
|
|
|
lua_pushnil(L);
|
|
|
|
lua_insert(L, -2); /* insert nil before error message */
|
|
|
|
lua_pushstring(L, errcodes[res]);
|
|
|
|
return 3;
|
|
|
|
}
|
2004-11-11 18:42:57 +03:00
|
|
|
}
|
|
|
|
|
2004-11-18 22:53:49 +03:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** {======================================================
|
|
|
|
** `require' and `module' functions
|
|
|
|
** =======================================================
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
static const char *loadLua (lua_State *L, const char *fname, const char *name) {
|
|
|
|
const char *path;
|
|
|
|
/* try first `LUA_PATH' for compatibility */
|
|
|
|
lua_getglobal(L, "LUA_PATH");
|
|
|
|
path = lua_tostring(L, -1);
|
|
|
|
if (!path) {
|
|
|
|
lua_pop(L, 1);
|
|
|
|
luaL_getfield(L, LUA_GLOBALSINDEX, "package.path");
|
|
|
|
path = lua_tostring(L, -1);
|
|
|
|
}
|
|
|
|
if (path == NULL)
|
|
|
|
luaL_error(L, "`package.path' must be a string");
|
|
|
|
fname = luaL_searchpath(L, fname, path);
|
|
|
|
if (fname == NULL) return path; /* library not found in this path */
|
|
|
|
if (luaL_loadfile(L, fname) != 0)
|
|
|
|
luaL_error(L, "error loading package `%s' (%s)", name, lua_tostring(L, -1));
|
|
|
|
return NULL; /* library loaded successfully */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static const char *loadC (lua_State *L, const char *fname, const char *name) {
|
|
|
|
const char *path;
|
|
|
|
const char *funcname;
|
|
|
|
luaL_getfield(L, LUA_GLOBALSINDEX, "package.cpath");
|
|
|
|
path = lua_tostring(L, -1);
|
|
|
|
if (path == NULL)
|
2004-12-22 20:43:27 +03:00
|
|
|
luaL_error(L, "`package.cpath' must be a string");
|
2004-11-18 22:53:49 +03:00
|
|
|
fname = luaL_searchpath(L, fname, path);
|
|
|
|
if (fname == NULL) return path; /* library not found in this path */
|
2004-12-13 15:14:21 +03:00
|
|
|
funcname = luaL_gsub(L, name, ".", LUA_OFSEP);
|
2004-11-18 22:53:49 +03:00
|
|
|
funcname = lua_pushfstring(L, "%s%s", LUA_POF, funcname);
|
|
|
|
if (loadlib(L, fname, funcname) != 0)
|
|
|
|
luaL_error(L, "error loading package `%s' (%s)", name, lua_tostring(L, -1));
|
|
|
|
return NULL; /* library loaded successfully */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int ll_require (lua_State *L) {
|
|
|
|
const char *name = luaL_checkstring(L, 1);
|
|
|
|
lua_settop(L, 1);
|
|
|
|
lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
|
|
|
|
lua_getfield(L, 2, name);
|
|
|
|
if (lua_toboolean(L, -1)) /* is it there? */
|
|
|
|
return 1; /* package is already loaded; return its result */
|
|
|
|
/* else must load it; first mark it as loaded */
|
|
|
|
lua_pushboolean(L, 1);
|
|
|
|
lua_setfield(L, 2, name); /* _LOADED[name] = true */
|
|
|
|
/* check whether it is preloaded */
|
|
|
|
lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
|
|
|
|
lua_getfield(L, -1, name);
|
|
|
|
if (lua_isnil(L, -1)) { /* no preload function for that module? */
|
|
|
|
const char *fname = luaL_gsub(L, name, ".", LUA_DIRSEP);
|
|
|
|
const char *cpath = loadC(L, fname, name); /* try a C module */
|
|
|
|
if (cpath) { /* not found? */
|
|
|
|
const char *path = loadLua(L, fname, name); /* try a Lua module */
|
|
|
|
if (path) { /* yet not found? */
|
|
|
|
lua_pushnil(L);
|
|
|
|
lua_setfield(L, 2, name); /* unmark _LOADED[name] */
|
|
|
|
return luaL_error(L, "package `%s' not found\n"
|
|
|
|
" cpath: %s\n path: %s",
|
|
|
|
name, cpath, path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
lua_pushvalue(L, 1); /* pass name as argument to module */
|
|
|
|
lua_call(L, 1, 1); /* run loaded module */
|
|
|
|
if (!lua_isnil(L, -1)) /* non-nil return? */
|
|
|
|
lua_setfield(L, 2, name); /* update _LOADED[name] with returned value */
|
|
|
|
lua_getfield(L, 2, name); /* return _LOADED[name] */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void setfenv (lua_State *L) {
|
|
|
|
lua_Debug ar;
|
|
|
|
lua_getstack(L, 1, &ar);
|
|
|
|
lua_getinfo(L, "f", &ar);
|
|
|
|
lua_pushvalue(L, -2);
|
|
|
|
lua_setfenv(L, -2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int ll_module (lua_State *L) {
|
|
|
|
const char *modname = luaL_checkstring(L, 1);
|
|
|
|
const char *dot;
|
|
|
|
lua_settop(L, 1);
|
|
|
|
lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
|
|
|
|
/* try to find given table */
|
|
|
|
luaL_getfield(L, LUA_GLOBALSINDEX, modname);
|
|
|
|
if (lua_isnil(L, -1)) { /* not found? */
|
|
|
|
lua_pop(L, 1); /* remove previous result */
|
|
|
|
lua_newtable(L); /* create it */
|
|
|
|
/* register it with given name */
|
|
|
|
lua_pushvalue(L, -1);
|
|
|
|
luaL_setfield(L, LUA_GLOBALSINDEX, modname);
|
|
|
|
}
|
|
|
|
else if (!lua_istable(L, -1))
|
|
|
|
return luaL_error(L, "name conflict for module `%s'", modname);
|
|
|
|
/* check whether table already has a _NAME field */
|
|
|
|
lua_getfield(L, -1, "_NAME");
|
|
|
|
if (!lua_isnil(L, -1)) /* is table an initialized module? */
|
|
|
|
lua_pop(L, 1);
|
|
|
|
else { /* no; initialize it */
|
|
|
|
lua_pop(L, 1);
|
|
|
|
lua_newtable(L); /* create new metatable */
|
|
|
|
lua_pushvalue(L, LUA_GLOBALSINDEX);
|
|
|
|
lua_setfield(L, -2, "__index"); /* mt.__index = _G */
|
|
|
|
lua_setmetatable(L, -2);
|
2004-12-22 20:43:27 +03:00
|
|
|
lua_pushvalue(L, -1);
|
|
|
|
lua_setfield(L, -2, "_M"); /* module._M = module */
|
2004-11-18 22:53:49 +03:00
|
|
|
lua_pushstring(L, modname);
|
|
|
|
lua_setfield(L, -2, "_NAME");
|
|
|
|
dot = strrchr(modname, '.'); /* look for last dot in module name */
|
|
|
|
if (dot == NULL) dot = modname;
|
|
|
|
else dot++;
|
|
|
|
/* set _PACKAGE as package name (full module name minus last part) */
|
|
|
|
lua_pushlstring(L, modname, dot - modname);
|
|
|
|
lua_setfield(L, -2, "_PACKAGE");
|
|
|
|
}
|
|
|
|
lua_pushvalue(L, -1);
|
|
|
|
lua_setfield(L, 2, modname); /* _LOADED[modname] = new table */
|
|
|
|
setfenv(L);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* }====================================================== */
|
|
|
|
|
|
|
|
|
|
|
|
static const luaL_reg ll_funcs[] = {
|
2004-12-13 15:14:21 +03:00
|
|
|
{"loadlib", ll_loadlib},
|
2004-11-18 22:53:49 +03:00
|
|
|
{"require", ll_require},
|
|
|
|
{"module", ll_module},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LUALIB_API int luaopen_loadlib (lua_State *L) {
|
|
|
|
const char *path;
|
|
|
|
/* create new type _LOADLIB */
|
|
|
|
luaL_newmetatable(L, "_LOADLIB");
|
|
|
|
lua_pushcfunction(L, gctm);
|
|
|
|
lua_setfield(L, -2, "__gc");
|
|
|
|
/* create `package' table */
|
|
|
|
lua_newtable(L);
|
|
|
|
lua_pushvalue(L, -1);
|
|
|
|
lua_setglobal(L, "package");
|
|
|
|
/* set field `path' */
|
|
|
|
path = getenv(LUA_PATH);
|
|
|
|
if (path == NULL) path = LUA_PATH_DEFAULT;
|
|
|
|
lua_pushstring(L, path);
|
|
|
|
lua_setfield(L, -2, "path");
|
|
|
|
/* set field `cpath' */
|
|
|
|
path = getenv(LUA_CPATH);
|
|
|
|
if (path == NULL) path = LUA_CPATH_DEFAULT;
|
|
|
|
lua_pushstring(L, path);
|
|
|
|
lua_setfield(L, -2, "cpath");
|
|
|
|
/* set field `loaded' */
|
|
|
|
lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
|
|
|
|
lua_setfield(L, -2, "loaded");
|
|
|
|
/* set field `preload' */
|
|
|
|
lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
|
|
|
|
lua_setfield(L, -2, "preload");
|
|
|
|
lua_pushvalue(L, LUA_GLOBALSINDEX);
|
|
|
|
luaL_openlib(L, NULL, ll_funcs, 0); /* open lib into global table */
|
|
|
|
return 1;
|
2003-03-17 16:04:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2003-04-08 00:11:53 +04:00
|
|
|
* Here are some links to available implementations of dlfcn and
|
|
|
|
* interfaces to other native dynamic loaders on top of which loadlib
|
|
|
|
* could be implemented. Please send contributions and corrections to us.
|
2003-03-17 16:04:58 +03:00
|
|
|
*
|
|
|
|
* AIX
|
|
|
|
* Starting with AIX 4.2, dlfcn is included in the base OS.
|
|
|
|
* There is also an emulation package available.
|
|
|
|
* http://www.faqs.org/faqs/aix-faq/part4/section-21.html
|
|
|
|
*
|
|
|
|
* HPUX
|
|
|
|
* HPUX 11 has dlfcn. For HPUX 10 use shl_*.
|
|
|
|
* http://www.geda.seul.org/mailinglist/geda-dev37/msg00094.html
|
|
|
|
* http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html
|
|
|
|
*
|
|
|
|
* Macintosh, Windows
|
|
|
|
* http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html
|
|
|
|
*
|
|
|
|
* GLIB has wrapper code for BeOS, OS2, Unix and Windows
|
|
|
|
* http://cvs.gnome.org/lxr/source/glib/gmodule/
|
|
|
|
*
|
|
|
|
*/
|