home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / py2s152.zip / Python / importdl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-06-27  |  31.2 KB  |  1,159 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* Support for dynamic loading of extension modules */
  33. /* If no dynamic linking is supported, this file still generates some code! */
  34.  
  35. #include "Python.h"
  36.  
  37. #ifdef HAVE_SYS_PARAM_H
  38. /* osdefs.h will define MAXPATHLEN if it's not already defined. */
  39. #include <sys/param.h>
  40. #endif
  41. #include "osdefs.h"
  42. #include "importdl.h"
  43.  
  44. /* Explanation of some of the the various #defines used by dynamic linking...
  45.  
  46.    symbol    -- defined for:
  47.  
  48.    DYNAMIC_LINK -- any kind of dynamic linking
  49.    USE_RLD    -- NeXT dynamic linking with FVM shlibs
  50.    USE_DYLD     -- NeXT dynamic linking with frameworks
  51.    USE_DL    -- Jack's dl for IRIX 4 or GNU dld with emulation for Jack's dl
  52.    USE_SHLIB    -- SunOS or IRIX 5 (SVR4?) shared libraries
  53.    _AIX        -- AIX style dynamic linking
  54.    MS_WIN32    -- Windows NT style dynamic linking (using DLLs)
  55.    MS_WIN16    -- Windows 16-bit dynamic linking (using DLLs)
  56.    PYOS_OS2 -- IBM OS/2 dynamic linking (using DLLs)
  57.    _DL_FUNCPTR_DEFINED    -- if the typedef dl_funcptr has been defined
  58.    USE_MAC_DYNAMIC_LOADING -- Mac CFM shared libraries
  59.    SHORT_EXT    -- short extension for dynamic module, e.g. ".so"
  60.    LONG_EXT    -- long extension, e.g. "module.so"
  61.    hpux        -- HP-UX Dynamic Linking - defined by the compiler
  62.    __NetBSD__    -- NetBSD shared libraries
  63.            (assuming dlerror() was introduced between 1.2 and 1.3)
  64.    __FreeBSD__    -- FreeBSD shared libraries
  65.    __BEOS__ -- BeOS shared libraries - defined by the compiler
  66.  
  67.    (The other WITH_* symbols are used only once, to set the
  68.    appropriate symbols.)
  69. */
  70.  
  71. /* Configure dynamic linking */
  72.  
  73. #ifdef __hpux
  74. #ifndef hpux
  75. #define hpux
  76. #endif
  77. #endif
  78.  
  79. #ifdef hpux
  80. #define DYNAMIC_LINK
  81. #include <errno.h>
  82. typedef void (*dl_funcptr)();
  83. #define _DL_FUNCPTR_DEFINED 1
  84. #define SHORT_EXT ".sl"
  85. #define LONG_EXT "module.sl"
  86. #endif 
  87.  
  88. #if defined(PYOS_OS2)
  89. #define DYNAMIC_LINK
  90. #define  INCL_DOSERRORS
  91. #define  INCL_DOSMODULEMGR
  92. #include <os2.h>
  93. typedef int (* APIENTRY dl_funcptr)();
  94. #define _DL_FUNCPTR_DEFINED 1
  95. #define SHORT_EXT ".pyd"
  96. #define LONG_EXT ".dll"
  97. #endif
  98.  
  99. #if defined(__NetBSD__) && (NetBSD < 199712)
  100. #define DYNAMIC_LINK
  101. #define USE_SHLIB
  102.  
  103. #define dlerror() "error in dynamic linking"
  104. #endif
  105.  
  106. #ifdef MS_WINDOWS /* i.e. MS_WIN32 or MS_WIN16 */
  107. #define DYNAMIC_LINK
  108. #include <windows.h>
  109. #include <direct.h>
  110. typedef FARPROC dl_funcptr;
  111. #define _DL_FUNCPTR_DEFINED
  112. #ifdef _DEBUG
  113. #define SHORT_EXT "_d.pyd"
  114. #define LONG_EXT "_d.dll"
  115. #else
  116. #define SHORT_EXT ".pyd"
  117. #define LONG_EXT ".dll"
  118. #endif
  119. #endif
  120.  
  121. #ifdef WITH_DYLD
  122. #define DYNAMIC_LINK
  123. #define USE_DYLD
  124. #define SHORT_EXT ".so"
  125. #define LONG_EXT "module.so"
  126. #define FUNCNAME_PATTERN "_init%.200s"
  127. #endif
  128.  
  129. #if defined(NeXT) && !defined(DYNAMIC_LINK)
  130. #define DYNAMIC_LINK
  131. #define USE_RLD
  132. /* Define this to 1 if you want be able to load ObjC modules as well:
  133.    it switches between two different way of loading modules on the NeXT,
  134.    one that directly interfaces with the dynamic loader (rld_load(), which
  135.    does not correctly load ObjC object files), and another that uses the
  136.    ObjC runtime (objc_loadModules()) to do the job.
  137.    You'll have to add ``-ObjC'' to the compiler flags if you set this to 1.
  138. */
  139. #define HANDLE_OBJC_MODULES 1
  140. #if HANDLE_OBJC_MODULES
  141. #include <objc/Object.h>
  142. #include <objc/objc-load.h>
  143. #endif
  144. #define SHORT_EXT ".so"
  145. #define LONG_EXT "module.so"
  146. #endif
  147.  
  148. #ifdef WITH_SGI_DL
  149. #define DYNAMIC_LINK
  150. #define USE_DL
  151. #endif
  152.  
  153. #ifdef WITH_DL_DLD
  154. #define DYNAMIC_LINK
  155. #define USE_DL
  156. #endif
  157.  
  158. #ifdef USE_MAC_DYNAMIC_LOADING
  159. #define DYNAMIC_LINK
  160. #define SHORT_EXT ".slb"
  161. #ifdef __CFM68K__
  162. #define LONG_EXT ".CFM68K.slb"
  163. #else
  164. #define LONG_EXT ".ppc.slb"
  165. #endif
  166. #ifndef _DL_FUNCPTR_DEFINED
  167. typedef void (*dl_funcptr)();
  168. #endif
  169. #endif
  170.  
  171. #if !defined(DYNAMIC_LINK) && (defined(HAVE_DLOPEN) || defined(M_UNIX))
  172. #define DYNAMIC_LINK
  173. #define USE_SHLIB
  174. #endif
  175.  
  176. #ifdef _AIX
  177. #undef USE_SHLIB /* AIX 4.2 and higher have dlfcn.h but we don't want it */
  178. #define DYNAMIC_LINK
  179. #define SHORT_EXT ".so"
  180. #define LONG_EXT "module.so"
  181. #include <sys/ldr.h>
  182. typedef void (*dl_funcptr)();
  183. #define _DL_FUNCPTR_DEFINED
  184. static int  aix_getoldmodules(void **);
  185. static int  aix_bindnewmodule(void *, void *);
  186. static void aix_loaderror(char *);
  187. #endif
  188.  
  189. #ifdef __BEOS__
  190. #undef USE_SHLIB /* probably not defined anyway */
  191. #define DYNAMIC_LINK
  192. #define SHORT_EXT ".so"
  193. #define LONG_EXT "module.so"
  194. typedef void (*dl_funcptr)(void);
  195. #define _DL_FUNCPTR_DEFINED
  196.  
  197. #if defined(MAXPATHLEN) && !defined(_SYS_PARAM_H)
  198. #undef MAXPATHLEN
  199. #endif
  200.  
  201. #include <kernel/image.h>
  202. #include <kernel/OS.h>
  203. #include <stdlib.h>
  204. #include <unistd.h>
  205.  
  206. #ifdef WITH_THREAD
  207. #include "pythread.h"
  208. static PyThread_type_lock beos_dyn_lock;
  209. #endif
  210.  
  211. static PyObject *beos_dyn_images = NULL;
  212.  
  213. static void beos_init_dyn( void );
  214. static void beos_cleanup_dyn( void );
  215. static void beos_nuke_dyn( PyObject *item );
  216. static void beos_add_dyn( char *pathname, image_id id );
  217. #endif
  218.  
  219. #ifdef DYNAMIC_LINK
  220.  
  221. #ifdef USE_SHLIB
  222. #include <sys/types.h>
  223. #include <sys/stat.h>
  224. #if defined(__NetBSD__) && (NetBSD < 199712)
  225. #include <nlist.h>
  226. #include <link.h>
  227. #else
  228. #ifdef HAVE_DLFCN_H
  229. #include <dlfcn.h>
  230. #endif
  231. #endif
  232. #ifndef _DL_FUNCPTR_DEFINED
  233. typedef void (*dl_funcptr)();
  234. #endif
  235. #ifndef RTLD_LAZY
  236. #define RTLD_LAZY 1
  237. #endif
  238. #define SHORT_EXT ".so"
  239. #define LONG_EXT "module.so"
  240. #endif /* USE_SHLIB */
  241.  
  242. #if defined(USE_DL) || defined(hpux)
  243. #include "dl.h"
  244. #endif
  245.  
  246. #ifdef USE_MAC_DYNAMIC_LOADING
  247. #include <Aliases.h>
  248. #include <CodeFragments.h>
  249. #ifdef SYMANTEC__CFM68K__ /* Really an older version of Universal Headers */
  250. #define CFragConnectionID ConnectionID
  251. #define kLoadCFrag 0x01
  252. #endif
  253. #ifdef USE_GUSI
  254. #include "TFileSpec.h"        /* for Path2FSSpec() */
  255. #endif
  256. #include <Files.h>
  257. #include "macdefs.h"
  258. #include "macglue.h"
  259. #endif
  260.  
  261. #ifdef USE_RLD
  262. #include <mach-o/rld.h>
  263. #ifndef _DL_FUNCPTR_DEFINED
  264. typedef void (*dl_funcptr)();
  265. #endif
  266. #endif /* USE_RLD */
  267.  
  268. #ifdef USE_DYLD
  269. #include <mach-o/dyld.h>
  270. #ifndef _DL_FUNCPTR_DEFINED
  271. typedef void (*dl_funcptr)();
  272. #endif
  273. #endif /* USE_DYLD */
  274.  
  275. extern char *Py_GetProgramName();
  276.  
  277. #ifndef FUNCNAME_PATTERN
  278. #if defined(__hp9000s300) || (defined(__NetBSD__) || defined(__FreeBSD__)) && !defined(__ELF__) || defined(__OpenBSD__) || defined(__BORLANDC__) || defined(NeXT)
  279. #define FUNCNAME_PATTERN "_init%.200s"
  280. #else
  281. #define FUNCNAME_PATTERN "init%.200s"
  282. #endif
  283. #endif
  284.  
  285. #if !defined(SHORT_EXT) && !defined(LONG_EXT)
  286. #define SHORT_EXT ".o"
  287. #define LONG_EXT "module.o"
  288. #endif /* !SHORT_EXT && !LONG_EXT */
  289.  
  290. #endif /* DYNAMIC_LINK */
  291.  
  292. struct filedescr _PyImport_Filetab[] = {
  293. #ifdef SHORT_EXT
  294.     {SHORT_EXT, "rb", C_EXTENSION},
  295. #endif /* !SHORT_EXT */
  296. #ifdef LONG_EXT
  297.     {LONG_EXT, "rb", C_EXTENSION},
  298. #endif /* !LONG_EXT */
  299.     {".py", "r", PY_SOURCE},
  300.     {".pyc", "rb", PY_COMPILED},
  301.     {0, 0}
  302. };
  303.  
  304. #ifdef NO_DYNAMIC_LINK
  305. #undef DYNAMIC_LINK
  306. #endif
  307.  
  308. PyObject *
  309. _PyImport_LoadDynamicModule(name, pathname, fp)
  310.     char *name;
  311.     char *pathname;
  312.     FILE *fp;
  313. {
  314. #ifndef DYNAMIC_LINK
  315.     PyErr_SetString(PyExc_ImportError,
  316.             "dynamically linked modules not supported");
  317.     return NULL;
  318. #else
  319.     PyObject *m, *d, *s;
  320.     char funcname[258];
  321.     char *lastdot, *shortname, *packagecontext;
  322.     dl_funcptr p = NULL;
  323. #ifdef USE_SHLIB
  324.     static struct {
  325.         dev_t dev;
  326.         ino_t ino;
  327.         void *handle;
  328.     } handles[128];
  329.     static int nhandles = 0;
  330.     char pathbuf[260];
  331.     if (strchr(pathname, '/') == NULL) {
  332.         /* Prefix bare filename with "./" */
  333.         sprintf(pathbuf, "./%-.255s", pathname);
  334.         pathname = pathbuf;
  335.     }
  336. #endif
  337.     if ((m = _PyImport_FindExtension(name, pathname)) != NULL) {
  338.         Py_INCREF(m);
  339.         return m;
  340.     }
  341.     lastdot = strrchr(name, '.');
  342.     if (lastdot == NULL) {
  343.         packagecontext = NULL;
  344.         shortname = name;
  345.     }
  346.     else {
  347.         packagecontext = name;
  348.         shortname = lastdot+1;
  349.     }
  350.     sprintf(funcname, FUNCNAME_PATTERN, shortname);
  351. #ifdef USE_SHLIB
  352.     if (fp != NULL) {
  353.         int i;
  354.         struct stat statb;
  355.         fstat(fileno(fp), &statb);
  356.         for (i = 0; i < nhandles; i++) {
  357.             if (statb.st_dev == handles[i].dev &&
  358.                 statb.st_ino == handles[i].ino) {
  359.                 p = (dl_funcptr) dlsym(handles[i].handle,
  360.                                funcname);
  361.                 goto got_it;
  362.             }
  363.         }
  364.         if (nhandles < 128) {
  365.             handles[nhandles].dev = statb.st_dev;
  366.             handles[nhandles].ino = statb.st_ino;
  367.         }
  368.     }
  369. #endif /* USE_SHLIB */
  370. #ifdef USE_MAC_DYNAMIC_LOADING
  371.     /*
  372.     ** Dynamic loading of CFM shared libraries on the Mac.  The
  373.     ** code has become more convoluted than it was, because we
  374.     ** want to be able to put multiple modules in a single
  375.     ** file. For this reason, we have to determine the fragment
  376.     ** name, and we cannot use the library entry point but we have
  377.     ** to locate the correct init routine "by hand".
  378.     */
  379.     {
  380.         FSSpec libspec;
  381.         CFragConnectionID connID;
  382.         Ptr mainAddr;
  383.         Str255 errMessage;
  384.         OSErr err;
  385. #ifndef USE_GUSI
  386.         Boolean isfolder, didsomething;
  387. #endif
  388.         char buf[512];
  389.         Str63 fragname;
  390.         Ptr symAddr;
  391.         CFragSymbolClass class;
  392.         
  393.         /* First resolve any aliases to find the real file */
  394. #ifdef USE_GUSI
  395.         err = Path2FSSpec(pathname, &libspec);
  396. #else
  397.         (void)FSMakeFSSpec(0, 0, Pstring(pathname), &libspec);
  398.         err = ResolveAliasFile(&libspec, 1, &isfolder, &didsomething);
  399. #endif
  400.         if ( err ) {
  401.             sprintf(buf, "%.255s: %.200s",
  402.                 pathname, PyMac_StrError(err));
  403.             PyErr_SetString(PyExc_ImportError, buf);
  404.             return NULL;
  405.         }
  406.         /* Next, determine the fragment name,
  407.            by stripping '.slb' and 'module' */
  408.         memcpy(fragname+1, libspec.name+1, libspec.name[0]);
  409.         fragname[0] = libspec.name[0];
  410.         if( strncmp((char *)(fragname+1+fragname[0]-4),
  411.                 ".slb", 4) == 0 )
  412.             fragname[0] -= 4;
  413.         if ( strncmp((char *)(fragname+1+fragname[0]-6),
  414.                  "module", 6) == 0 )
  415.             fragname[0] -= 6;
  416.         /* Load the fragment
  417.            (or return the connID if it is already loaded */
  418.         err = GetDiskFragment(&libspec, 0, 0, fragname, 
  419.                       kLoadCFrag, &connID, &mainAddr,
  420.                       errMessage);
  421.         if ( err ) {
  422.             sprintf(buf, "%.*s: %.200s",
  423.                 errMessage[0], errMessage+1,
  424.                 PyMac_StrError(err));
  425.             PyErr_SetString(PyExc_ImportError, buf);
  426.             return NULL;
  427.         }
  428.         /* Locate the address of the correct init function */
  429.         err = FindSymbol(connID, Pstring(funcname), &symAddr, &class);
  430.         if ( err ) {
  431.             sprintf(buf, "%s: %.200s",
  432.                 funcname, PyMac_StrError(err));
  433.             PyErr_SetString(PyExc_ImportError, buf);
  434.             return NULL;
  435.         }
  436.         p = (dl_funcptr)symAddr;
  437.     }
  438. #endif /* USE_MAC_DYNAMIC_LOADING */
  439. #ifdef USE_SHLIB
  440.     {
  441. #ifdef RTLD_NOW
  442.         /* RTLD_NOW: resolve externals now
  443.            (i.e. core dump now if some are missing) */
  444.         void *handle = dlopen(pathname, RTLD_NOW);
  445. #else
  446.         void *handle;
  447.         if (Py_VerboseFlag)
  448.             printf("dlopen(\"%s\", %d);\n", pathname,
  449.                    RTLD_LAZY);
  450.         handle = dlopen(pathname, RTLD_LAZY);
  451. #endif /* RTLD_NOW */
  452.         if (handle == NULL) {
  453.             PyErr_SetString(PyExc_ImportError, dlerror());
  454.             return NULL;
  455.         }
  456.         if (fp != NULL && nhandles < 128)
  457.             handles[nhandles++].handle = handle;
  458.         p = (dl_funcptr) dlsym(handle, funcname);
  459.     }
  460. #endif /* USE_SHLIB */
  461. #ifdef _AIX
  462.     /*
  463.     -- Invoke load() with L_NOAUTODEFER leaving the imported symbols
  464.     -- of the shared module unresolved. Thus we have to resolve them
  465.     -- explicitely with loadbind. The new module is loaded, then we
  466.     -- resolve its symbols using the list of already loaded modules
  467.     -- (only those that belong to the python executable). Get these
  468.     -- with loadquery(L_GETINFO).
  469.     */
  470.     {
  471.         static void *staticmodlistptr = NULL;
  472.  
  473.         if (!staticmodlistptr)
  474.             if (aix_getoldmodules(&staticmodlistptr) == -1)
  475.                 return NULL;
  476.         p = (dl_funcptr) load(pathname, L_NOAUTODEFER, 0);
  477.         if (p == NULL) {
  478.             aix_loaderror(pathname);
  479.             return NULL;
  480.         }
  481.         if (aix_bindnewmodule((void *)p, staticmodlistptr) == -1) {
  482.             aix_loaderror(pathname);
  483.             return NULL;
  484.         }
  485.     }
  486. #endif /* _AIX */
  487. #ifdef MS_WIN32
  488.     {
  489.         HINSTANCE hDLL;
  490.         char pathbuf[260];
  491.         if (strchr(pathname, SEP) == NULL &&
  492.             strchr(pathname, ALTSEP) == NULL)
  493.         {
  494.             /* Prefix bare filename with ".\" */
  495.             char *p = pathbuf;
  496.             *p = '\0';
  497.             _getcwd(pathbuf, sizeof pathbuf);
  498.             if (*p != '\0' && p[1] == ':')
  499.                 p += 2;
  500.             sprintf(p, ".\\%-.255s", pathname);
  501.             pathname = pathbuf;
  502.         }
  503.         /* Look for dependent DLLs in directory of pathname first */
  504.         /* XXX This call doesn't exist in Windows CE */
  505.         hDLL = LoadLibraryEx(pathname, NULL,
  506.                      LOAD_WITH_ALTERED_SEARCH_PATH);
  507.         if (hDLL==NULL){
  508.             char errBuf[256];
  509.             unsigned int errorCode;
  510.  
  511.             /* Get an error string from Win32 error code */
  512.             char theInfo[256]; /* Pointer to error text
  513.                           from system */
  514.             int theLength; /* Length of error text */
  515.  
  516.             errorCode = GetLastError();
  517.  
  518.             theLength = FormatMessage(
  519.                 FORMAT_MESSAGE_FROM_SYSTEM, /* flags */
  520.                 NULL, /* message source */
  521.                 errorCode, /* the message (error) ID */
  522.                 0, /* default language environment */
  523.                 (LPTSTR) theInfo, /* the buffer */
  524.                 sizeof(theInfo), /* the buffer size */
  525.                 NULL); /* no additional format args. */
  526.  
  527.             /* Problem: could not get the error message.
  528.                This should not happen if called correctly. */
  529.             if (theLength == 0) {
  530.                 sprintf(errBuf,
  531.                     "DLL load failed with error code %d",
  532.                     errorCode);
  533.             } else {
  534.                 int len;
  535.                 /* For some reason a \r\n
  536.                    is appended to the text */
  537.                 if (theLength >= 2 &&
  538.                     theInfo[theLength-2] == '\r' &&
  539.                     theInfo[theLength-1] == '\n') {
  540.                     theLength -= 2;
  541.                     theInfo[theLength] = '\0';
  542.                 }
  543.                 strcpy(errBuf, "DLL load failed: ");
  544.                 len = strlen(errBuf);
  545.                 strncpy(errBuf+len, theInfo,
  546.                     sizeof(errBuf)-len);
  547.                 errBuf[sizeof(errBuf)-1] = '\0';
  548.             }
  549.             PyErr_SetString(PyExc_ImportError, errBuf);
  550.         return NULL;
  551.         }
  552.         p = GetProcAddress(hDLL, funcname);
  553.     }
  554. #endif /* MS_WIN32 */
  555. #ifdef MS_WIN16
  556.     {
  557.         HINSTANCE hDLL;
  558.         char pathbuf[16];
  559.         if (strchr(pathname, SEP) == NULL &&
  560.             strchr(pathname, ALTSEP) == NULL)
  561.         {
  562.             /* Prefix bare filename with ".\" */
  563.             sprintf(pathbuf, ".\\%-.13s", pathname);
  564.             pathname = pathbuf;
  565.         }
  566.         hDLL = LoadLibrary(pathname);
  567.         if (hDLL < HINSTANCE_ERROR){
  568.             char errBuf[256];
  569.             sprintf(errBuf,
  570.                 "DLL load failed with error code %d", hDLL);
  571.             PyErr_SetString(PyExc_ImportError, errBuf);
  572.             return NULL;
  573.         }
  574.         p = GetProcAddress(hDLL, funcname);
  575.     }
  576. #endif /* MS_WIN16 */
  577.  
  578. #if defined(PYOS_OS2)
  579.     {
  580.         APIRET  rc;
  581.         HMODULE hDLL;
  582.         char failreason[256];
  583.  
  584.         rc = DosLoadModule(failreason,
  585.                    sizeof(failreason),
  586.                    pathname,
  587.                    &hDLL);
  588.  
  589.         if (rc != NO_ERROR) {
  590.             char errBuf[256];
  591.             sprintf(errBuf,
  592.                 "DLL load failed, rc = %d, problem '%s': %s",
  593.                 rc, failreason);
  594.             PyErr_SetString(PyExc_ImportError, errBuf);
  595.             return NULL;
  596.         }
  597.  
  598.         rc = DosQueryProcAddr(hDLL, 0L, funcname, &p);
  599.         if (rc != NO_ERROR)
  600.             p = NULL; /* Signify Failure to Acquire Entrypoint */
  601.     }
  602. #endif /* PYOS_OS2 */
  603.  
  604. #ifdef USE_DL
  605.     p =  dl_loadmod(Py_GetProgramName(), pathname, funcname);
  606. #endif /* USE_DL */
  607. #ifdef USE_RLD
  608.     {
  609.         NXStream *errorStream;
  610.         struct mach_header *new_header;
  611.         const char *filenames[2];
  612.         long ret;
  613.         unsigned long ptr;
  614.  
  615.         errorStream = NXOpenMemory(NULL, 0, NX_WRITEONLY);
  616.         filenames[0] = pathname;
  617.         filenames[1] = NULL;
  618.  
  619. #if HANDLE_OBJC_MODULES
  620.  
  621. /* The following very bogus line of code ensures that
  622.    objc_msgSend, etc are linked into the binary.  Without
  623.    it, dynamic loading of a module that includes objective-c
  624.    method calls will fail with "undefined symbol _objc_msgSend()".
  625.    This remains true even in the presence of the -ObjC flag
  626.    to the compiler
  627. */
  628.  
  629.         [Object name];
  630.  
  631. /* objc_loadModules() dynamically loads the object files
  632.    indicated by the paths in filenames.  If there are any
  633.    errors generated during loading -- typically due to the
  634.    inability to find particular symbols -- an error message
  635.    will be written to errorStream.
  636.    It returns 0 if the module is successfully loaded, 1
  637.    otherwise.
  638. */
  639.  
  640.         ret = !objc_loadModules(filenames, errorStream,
  641.                     NULL, &new_header, NULL);
  642.  
  643. #else /* !HANDLE_OBJC_MODULES */
  644.  
  645.         ret = rld_load(errorStream, &new_header, 
  646.                 filenames, NULL);
  647.  
  648. #endif /* HANDLE_OBJC_MODULES */
  649.  
  650.         /* extract the error messages for the exception */
  651.         if(!ret) {
  652.             char *streamBuf;
  653.             int len, maxLen;
  654.  
  655.             NXPutc(errorStream, (char)0);
  656.  
  657.             NXGetMemoryBuffer(errorStream,
  658.                 &streamBuf, &len, &maxLen);
  659.             PyErr_SetString(PyExc_ImportError, streamBuf);
  660.         }
  661.  
  662.         if(ret && rld_lookup(errorStream, funcname, &ptr))
  663.             p = (dl_funcptr) ptr;
  664.  
  665.         NXCloseMemory(errorStream, NX_FREEBUFFER);
  666.  
  667.         if(!ret)
  668.             return NULL;
  669.     }
  670. #endif /* USE_RLD */
  671. #ifdef USE_DYLD
  672.     /* This is also NeXT-specific. However, frameworks (the new style
  673.     of shared library) and rld() can't be used in the same program;
  674.     instead, you have to use dyld, which is mostly unimplemented. */
  675.     {
  676.         NSObjectFileImageReturnCode rc;
  677.         NSObjectFileImage image;
  678.         NSModule newModule;
  679.         NSSymbol theSym;
  680.         void *symaddr;
  681.         const char *errString;
  682.     
  683.         rc = NSCreateObjectFileImageFromFile(pathname, &image);
  684.         switch(rc) {
  685.             default:
  686.             case NSObjectFileImageFailure:
  687.             NSObjectFileImageFormat:
  688.             /* for these a message is printed on stderr by dyld */
  689.             errString = "Can't create object file image";
  690.             break;
  691.             case NSObjectFileImageSuccess:
  692.             errString = NULL;
  693.             break;
  694.             case NSObjectFileImageInappropriateFile:
  695.             errString = "Inappropriate file type for dynamic loading";
  696.             break;
  697.             case NSObjectFileImageArch:
  698.             errString = "Wrong CPU type in object file";
  699.             break;
  700.             NSObjectFileImageAccess:
  701.             errString = "Can't read object file (no access)";
  702.             break;
  703.         }
  704.         if (errString == NULL) {
  705.             newModule = NSLinkModule(image, pathname, TRUE);
  706.             if (!newModule)
  707.                 errString = "Failure linking new module";
  708.         }
  709.         if (errString != NULL) {
  710.             PyErr_SetString(PyExc_ImportError, errString);
  711.             return NULL;
  712.         }
  713.         if (!NSIsSymbolNameDefined(funcname)) {
  714.             /* UnlinkModule() isn't implimented in current versions, but calling it does no harm */
  715.             NSUnLinkModule(newModule, FALSE);
  716.             PyErr_Format(PyExc_ImportError, "Loaded module does not contain symbol %s", funcname);
  717.             return NULL;
  718.         }
  719.         theSym = NSLookupAndBindSymbol(funcname);
  720.         p = (dl_funcptr)NSAddressOfSymbol(theSym);
  721.      }
  722. #endif /* USE_DYLD */
  723. #ifdef hpux
  724.     {
  725.         shl_t lib;
  726.         int flags;
  727.  
  728.         flags = BIND_FIRST | BIND_DEFERRED;
  729.         if (Py_VerboseFlag) {
  730.             flags = DYNAMIC_PATH | BIND_FIRST | BIND_IMMEDIATE |
  731.                 BIND_NONFATAL | BIND_VERBOSE;
  732.             printf("shl_load %s\n",pathname);
  733.         }
  734.         lib = shl_load(pathname, flags, 0);
  735.         /* XXX Chuck Blake once wrote that 0 should be BIND_NOSTART? */
  736.         if (lib == NULL) {
  737.             char buf[256];
  738.             if (Py_VerboseFlag)
  739.                 perror(pathname);
  740.             sprintf(buf, "Failed to load %.200s", pathname);
  741.             PyErr_SetString(PyExc_ImportError, buf);
  742.             return NULL;
  743.         }
  744.         if (Py_VerboseFlag)
  745.             printf("shl_findsym %s\n", funcname);
  746.         shl_findsym(&lib, funcname, TYPE_UNDEFINED, (void *) &p);
  747.         if (p == NULL && Py_VerboseFlag)
  748.             perror(funcname);
  749.     }
  750. #endif /* hpux */
  751. #ifdef __BEOS__
  752.     {
  753.         image_id the_id;
  754.         status_t retval;
  755.         char fullpath[PATH_MAX];
  756.  
  757.         if( Py_VerboseFlag ) {
  758.             printf( "load_add_on( %s )\n", pathname );
  759.         }
  760.  
  761.         /* Hmm, this old bug appears to have regenerated itself; if the
  762.          * path isn't absolute, load_add_on() will fail.  Reported to Be
  763.          * April 21, 1998.
  764.          */
  765.         if( pathname[0] != '/' ) {
  766.             (void)getcwd( fullpath, PATH_MAX );
  767.             (void)strncat( fullpath, "/", PATH_MAX );
  768.             (void)strncat( fullpath, pathname, PATH_MAX );
  769.             
  770.             if( Py_VerboseFlag ) {
  771.                 printf( "load_add_on( %s )\n", fullpath );
  772.             }
  773.         } else {
  774.             (void)strcpy( fullpath, pathname );
  775.         }
  776.  
  777.         the_id = load_add_on( fullpath );
  778.         if( the_id < B_NO_ERROR ) {
  779.             /* It's too bad load_add_on() doesn't set errno or something...
  780.              */
  781.             char buff[256];  /* hate hard-coded string sizes... */
  782.  
  783.             if( Py_VerboseFlag ) {
  784.                 printf( "load_add_on( %s ) failed", fullpath );
  785.             }
  786.  
  787.             switch( the_id ) {
  788.             case B_ERROR:
  789.                 sprintf( buff, "BeOS: Failed to load %.200s", fullpath );
  790.                 break;
  791.             default:
  792.                 sprintf( buff, "Unknown error loading %.200s", fullpath );
  793.                 break;
  794.             }
  795.  
  796.             PyErr_SetString( PyExc_ImportError, buff );
  797.             return NULL;
  798.         }
  799.  
  800.         if( Py_VerboseFlag ) {
  801.             printf( "get_image_symbol( %s )\n", funcname );
  802.         }
  803.  
  804.         retval = get_image_symbol( the_id, funcname, B_SYMBOL_TYPE_TEXT, &p );
  805.         if( retval != B_NO_ERROR || p == NULL ) {
  806.             /* That's bad, we can't find that symbol in the module...
  807.              */
  808.             char buff[256];  /* hate hard-coded string sizes... */
  809.  
  810.             if( Py_VerboseFlag ) {
  811.                 printf( "get_image_symbol( %s ) failed", funcname );
  812.             }
  813.  
  814.             switch( retval ) {
  815.             case B_BAD_IMAGE_ID:
  816.                 sprintf( buff, "can't load init function for dynamic module: "
  817.                                "Invalid image ID for %.180s", fullpath );
  818.                 break;
  819.             case B_BAD_INDEX:
  820.                 sprintf( buff, "can't load init function for dynamic module: "
  821.                                "Bad index for %.180s", funcname );
  822.                 break;
  823.             default:
  824.                 sprintf( buff, "can't load init function for dynamic module: "
  825.                                "Unknown error looking up %.180s", funcname );
  826.                 break;
  827.             }
  828.  
  829.             retval = unload_add_on( the_id );
  830.  
  831.             PyErr_SetString( PyExc_ImportError, buff );
  832.             return NULL;
  833.         }
  834.  
  835.         /* Save the module name and image ID for later so we can clean up
  836.          * gracefully.
  837.          */
  838.         beos_add_dyn( name, the_id );
  839.     }
  840. #endif /* __BEOS__ */
  841. #ifdef USE_SHLIB
  842.   got_it:
  843. #endif
  844.     if (p == NULL) {
  845.         PyErr_Format(PyExc_ImportError,
  846.            "dynamic module does not define init function (%.200s)",
  847.                  funcname);
  848.         return NULL;
  849.     }
  850.     _Py_PackageContext = packagecontext;
  851.     (*p)();
  852.     _Py_PackageContext = NULL;
  853.     if (PyErr_Occurred())
  854.         return NULL;
  855.     if (_PyImport_FixupExtension(name, pathname) == NULL)
  856.         return NULL;
  857.  
  858.     m = PyDict_GetItemString(PyImport_GetModuleDict(), name);
  859.     if (m == NULL) {
  860.         PyErr_SetString(PyExc_SystemError,
  861.                 "dynamic module not initialized properly");
  862.         return NULL;
  863.     }
  864.     /* Remember the filename as the __file__ attribute */
  865.     d = PyModule_GetDict(m);
  866.     s = PyString_FromString(pathname);
  867.     if (s == NULL || PyDict_SetItemString(d, "__file__", s) != 0)
  868.         PyErr_Clear(); /* Not important enough to report */
  869.     Py_XDECREF(s);
  870.     if (Py_VerboseFlag)
  871.         PySys_WriteStderr(
  872.             "import %s # dynamically loaded from %s\n",
  873.             name, pathname);
  874.     Py_INCREF(m);
  875.     return m;
  876. #endif /* DYNAMIC_LINK */
  877. }
  878.  
  879.  
  880. #ifdef _AIX
  881.  
  882. #include <ctype.h>    /*  for isdigit()      */
  883. #include <errno.h>    /*  for global errno      */
  884. #include <string.h>    /*  for strerror()        */
  885. #include <stdlib.h>    /*  for malloc(), free()  */
  886.  
  887. typedef struct Module {
  888.     struct Module *next;
  889.     void          *entry;
  890. } Module, *ModulePtr;
  891.  
  892. static int
  893. aix_getoldmodules(modlistptr)
  894.     void **modlistptr;
  895. {
  896.     register ModulePtr       modptr, prevmodptr;
  897.     register struct ld_info  *ldiptr;
  898.     register char            *ldibuf;
  899.     register int             errflag, bufsize = 1024;
  900.     register unsigned int    offset;
  901.     
  902.     /*
  903.     -- Get the list of loaded modules into ld_info structures.
  904.     */
  905.     if ((ldibuf = malloc(bufsize)) == NULL) {
  906.         PyErr_SetString(PyExc_ImportError, strerror(errno));
  907.         return -1;
  908.     }
  909.     while ((errflag = loadquery(L_GETINFO, ldibuf, bufsize)) == -1
  910.            && errno == ENOMEM) {
  911.         free(ldibuf);
  912.         bufsize += 1024;
  913.         if ((ldibuf = malloc(bufsize)) == NULL) {
  914.             PyErr_SetString(PyExc_ImportError, strerror(errno));
  915.             return -1;
  916.         }
  917.     }
  918.     if (errflag == -1) {
  919.         PyErr_SetString(PyExc_ImportError, strerror(errno));
  920.         return -1;
  921.     }
  922.     /*
  923.     -- Make the modules list from the ld_info structures.
  924.     */
  925.     ldiptr = (struct ld_info *)ldibuf;
  926.     prevmodptr = NULL;
  927.     do {
  928.         if (strstr(ldiptr->ldinfo_filename, "python") == NULL) {
  929.             /*
  930.             -- Extract only the modules containing "python" as a
  931.             -- substring, like the "python[version]" executable or
  932.             -- "libpython[version].a" in case python is embedded.
  933.             */
  934.             offset = (unsigned int)ldiptr->ldinfo_next;
  935.             ldiptr = (struct ld_info *)((unsigned int)
  936.                             ldiptr + offset);
  937.             continue;
  938.         }
  939.         if ((modptr = (ModulePtr)malloc(sizeof(Module))) == NULL) {
  940.             PyErr_SetString(PyExc_ImportError, strerror(errno));
  941.             while (*modlistptr) {
  942.                 modptr = (ModulePtr)*modlistptr;
  943.                 *modlistptr = (void *)modptr->next;
  944.                 free(modptr);
  945.             }
  946.             return -1;
  947.         }
  948.         modptr->entry = ldiptr->ldinfo_dataorg;
  949.         modptr->next  = NULL;
  950.         if (prevmodptr == NULL)
  951.             *modlistptr = (void *)modptr;
  952.         else
  953.             prevmodptr->next = modptr;
  954.         prevmodptr = modptr;
  955.         offset = (unsigned int)ldiptr->ldinfo_next;
  956.         ldiptr = (struct ld_info *)((unsigned int)ldiptr + offset);
  957.     } while (offset);
  958.     free(ldibuf);
  959.     return 0;
  960. }
  961.  
  962. static int
  963. aix_bindnewmodule(newmoduleptr, modlistptr)
  964.     void *newmoduleptr;
  965.     void *modlistptr;        
  966. {
  967.     register ModulePtr modptr;
  968.  
  969.     /*
  970.     -- Bind the new module with the list of loaded modules.
  971.     */
  972.     for (modptr = (ModulePtr)modlistptr; modptr; modptr = modptr->next)
  973.         if (loadbind(0, modptr->entry, newmoduleptr) != 0)
  974.             return -1;
  975.     return 0;
  976. }
  977.  
  978. static void
  979. aix_loaderror(pathname)
  980.     char *pathname;
  981. {
  982.  
  983.     char *message[1024], errbuf[1024];
  984.     register int i,j;
  985.  
  986.     struct errtab { 
  987.         int errNo;
  988.         char *errstr;
  989.     } load_errtab[] = {
  990.         {L_ERROR_TOOMANY,    "too many errors, rest skipped."},
  991.         {L_ERROR_NOLIB,        "can't load library:"},
  992.         {L_ERROR_UNDEF,        "can't find symbol in library:"},
  993.         {L_ERROR_RLDBAD,
  994.          "RLD index out of range or bad relocation type:"},
  995.         {L_ERROR_FORMAT,    "not a valid, executable xcoff file:"},
  996.         {L_ERROR_MEMBER,
  997.          "file not an archive or does not contain requested member:"},
  998.         {L_ERROR_TYPE,        "symbol table mismatch:"},
  999.         {L_ERROR_ALIGN,        "text alignment in file is wrong."},
  1000.         {L_ERROR_SYSTEM,    "System error:"},
  1001.         {L_ERROR_ERRNO,        NULL}
  1002.     };
  1003.  
  1004. #define LOAD_ERRTAB_LEN    (sizeof(load_errtab)/sizeof(load_errtab[0]))
  1005. #define ERRBUF_APPEND(s) strncat(errbuf, s, sizeof(errbuf)-strlen(errbuf)-1)
  1006.  
  1007.     sprintf(errbuf, "from module %.200s ", pathname);
  1008.  
  1009.     if (!loadquery(L_GETMESSAGES, &message[0], sizeof(message))) {
  1010.         ERRBUF_APPEND(strerror(errno));
  1011.         ERRBUF_APPEND("\n");
  1012.     }
  1013.     for(i = 0; message[i] && *message[i]; i++) {
  1014.         int nerr = atoi(message[i]);
  1015.         for (j=0; j<LOAD_ERRTAB_LEN ; j++) {
  1016.             if (nerr == load_errtab[j].errNo && load_errtab[j].errstr)
  1017.             ERRBUF_APPEND(load_errtab[j].errstr);
  1018.         }
  1019.         while (isdigit(*message[i])) message[i]++ ; 
  1020.         ERRBUF_APPEND(message[i]);
  1021.         ERRBUF_APPEND("\n");
  1022.     }
  1023.     errbuf[strlen(errbuf)-1] = '\0';    /* trim off last newline */
  1024.     PyErr_SetString(PyExc_ImportError, errbuf); 
  1025.     return; 
  1026. }
  1027.  
  1028. #endif /* _AIX */
  1029.  
  1030. #ifdef __BEOS__
  1031. /* ----------------------------------------------------------------------
  1032.  * BeOS dynamic loading support
  1033.  *
  1034.  * This uses shared libraries, but BeOS has its own way of doing things
  1035.  * (much easier than dlfnc.h, from the look of things).  We'll use a
  1036.  * Python Dictionary object to store the images_ids so we can be very
  1037.  * nice and unload them when we exit.
  1038.  *
  1039.  * Note that this is thread-safe.  Probably irrelevent, because of losing
  1040.  * systems... Python probably disables threads while loading modules.
  1041.  * Note the use of "probably"!  Better to be safe than sorry. [chrish]
  1042.  *
  1043.  * As of 1.5.1 this should also work properly when you've configured
  1044.  * Python without thread support; the 1.5 version required it, which wasn't
  1045.  * very friendly.  Note that I haven't tested it without threading... why
  1046.  * would you want to avoid threads on BeOS? [chrish]
  1047.  *
  1048.  * As of 1.5.2, the PyImport_BeImageID() function has been removed; Donn
  1049.  * tells me it's not necessary anymore because of PyCObject_Import().
  1050.  * [chrish]
  1051.  */
  1052.  
  1053. /*
  1054.  * Initialize our dictionary, and the dictionary mutex.
  1055.  */
  1056. static void beos_init_dyn( void )
  1057. {
  1058.     /* We're protected from a race condition here by the atomic init_count
  1059.      * variable.
  1060.      */
  1061.     static int32 init_count = 0;
  1062.     int32 val;
  1063.  
  1064.     val = atomic_add( &init_count, 1 );
  1065.     if( beos_dyn_images == NULL && val == 0 ) {
  1066.         beos_dyn_images = PyDict_New();
  1067. #ifdef WITH_THREAD
  1068.         beos_dyn_lock = PyThread_allocate_lock();
  1069. #endif
  1070.         atexit( beos_cleanup_dyn );
  1071.     }
  1072. }
  1073.  
  1074. /* atexit() handler that'll call unload_add_on() for every item in the
  1075.  * dictionary.
  1076.  */
  1077. static void beos_cleanup_dyn( void )
  1078. {
  1079.     if( beos_dyn_images ) {
  1080.         int idx;
  1081.         int list_size;
  1082.         PyObject *id_list;
  1083.  
  1084. #ifdef WITH_THREAD
  1085.         PyThread_acquire_lock( beos_dyn_lock, 1 );
  1086. #endif
  1087.  
  1088.         id_list = PyDict_Values( beos_dyn_images );
  1089.  
  1090.         list_size = PyList_Size( id_list );
  1091.         for( idx = 0; idx < list_size; idx++ ) {
  1092.             PyObject *the_item;
  1093.             
  1094.             the_item = PyList_GetItem( id_list, idx );
  1095.             beos_nuke_dyn( the_item );
  1096.         }
  1097.  
  1098.         PyDict_Clear( beos_dyn_images );
  1099.  
  1100. #ifdef WITH_THREAD
  1101.         PyThread_free_lock( beos_dyn_lock );
  1102. #endif
  1103.     }
  1104. }
  1105.  
  1106. /* Whack an item; the item is an image_id in disguise, so we'll call
  1107.  * unload_add_on() for it.
  1108.  */
  1109. static void beos_nuke_dyn( PyObject *item )
  1110. {
  1111.     status_t retval;
  1112.  
  1113.     if( item ) {
  1114.         image_id id = (image_id)PyInt_AsLong( item );
  1115.         
  1116.         retval = unload_add_on( id );
  1117.     }
  1118. }
  1119.  
  1120. /*
  1121.  * Add an image_id to the dictionary; the module name of the loaded image
  1122.  * is the key.  Note that if the key is already in the dict, we unload
  1123.  * that image; this should allow reload() to work on dynamically loaded
  1124.  * modules (super-keen!).
  1125.  */
  1126. static void beos_add_dyn( char *name, image_id id )
  1127. {
  1128.     int retval;
  1129.     PyObject *py_id;
  1130.  
  1131.     if( beos_dyn_images == NULL ) {
  1132.         beos_init_dyn();
  1133.     }
  1134.  
  1135. #ifdef WITH_THREAD
  1136.     retval = PyThread_acquire_lock( beos_dyn_lock, 1 );
  1137. #endif
  1138.  
  1139.     /* If there's already an object with this key in the dictionary,
  1140.      * we're doing a reload(), so let's nuke it.
  1141.      */
  1142.     py_id = PyDict_GetItemString( beos_dyn_images, name );
  1143.     if( py_id ) {
  1144.         beos_nuke_dyn( py_id );
  1145.         retval = PyDict_DelItemString( beos_dyn_images, name );
  1146.     }
  1147.  
  1148.     py_id = PyInt_FromLong( (long)id );
  1149.     if( py_id ) {
  1150.         retval = PyDict_SetItemString( beos_dyn_images, name, py_id );
  1151.     }
  1152.  
  1153. #ifdef WITH_THREAD
  1154.     PyThread_release_lock( beos_dyn_lock );
  1155. #endif
  1156. }
  1157.  
  1158. #endif /* __BEOS__ */
  1159.