/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.

STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

******************************************************************/

/* Support for dynamic loading of extension modules */
/* If no dynamic linking is supported, this file still generates some code! */

#include "Python.h"

#ifdef HAVE_SYS_PARAM_H
/* osdefs.h will define MAXPATHLEN if it's not already defined. */
#include <sys/param.h>
#endif
#include "osdefs.h"
#include "importdl.h"

/* Explanation of some of the the various #defines used by dynamic linking...

   symbol	-- defined for:

   DYNAMIC_LINK -- any kind of dynamic linking
   USE_RLD	-- NeXT dynamic linking
   USE_DL	-- Jack's dl for IRIX 4 or GNU dld with emulation for Jack's dl
   USE_SHLIB	-- SunOS or IRIX 5 (SVR4?) shared libraries
   _AIX		-- AIX style dynamic linking
   MS_WIN32	-- Windows NT style dynamic linking (using DLLs)
   MS_WIN16	-- Windows 16-bit dynamic linking (using DLLs)
   PYOS_OS2 -- IBM OS/2 dynamic linking (using DLLs)
   _DL_FUNCPTR_DEFINED	-- if the typedef dl_funcptr has been defined
   USE_MAC_DYNAMIC_LOADING -- Mac CFM shared libraries
   SHORT_EXT	-- short extension for dynamic module, e.g. ".so"
   LONG_EXT	-- long extension, e.g. "module.so"
   hpux		-- HP-UX Dynamic Linking - defined by the compiler
   __NetBSD__	-- NetBSD shared libraries
		   (assuming dlerror() was introduced between 1.2 and 1.3)
   __FreeBSD__	-- FreeBSD shared libraries
   __BEOS__ -- BeOS shared libraries - defined by the compiler

   (The other WITH_* symbols are used only once, to set the
   appropriate symbols.)
*/

/* Configure dynamic linking */

#ifdef __hpux
#ifndef hpux
#define hpux
#endif
#endif

#ifdef hpux
#define DYNAMIC_LINK
#include <errno.h>
typedef void (*dl_funcptr)();
#define _DL_FUNCPTR_DEFINED 1
#define SHORT_EXT ".sl"
#define LONG_EXT "module.sl"
#endif 

#if defined(PYOS_OS2)
#define DYNAMIC_LINK
#define  INCL_DOSERRORS
#define  INCL_DOSMODULEMGR
#include <os2.h>
typedef int (* APIENTRY dl_funcptr)();
#define _DL_FUNCPTR_DEFINED 1
#define SHORT_EXT ".pyd"
#define LONG_EXT ".dll"
#endif

#if defined(__NetBSD__) && (NetBSD < 199712)
#define DYNAMIC_LINK
#define USE_SHLIB

#define dlerror() "error in dynamic linking"
#endif

#ifdef MS_WINDOWS /* i.e. MS_WIN32 or MS_WIN16 */
#define DYNAMIC_LINK
#include <windows.h>
#include <direct.h>
typedef FARPROC dl_funcptr;
#define _DL_FUNCPTR_DEFINED
#ifdef _DEBUG
#define SHORT_EXT "_d.pyd"
#define LONG_EXT "_d.dll"
#else
#define SHORT_EXT ".pyd"
#define LONG_EXT ".dll"
#endif
#endif

#ifdef NeXT
#define DYNAMIC_LINK
#define USE_RLD
/* Define this to 1 if you want be able to load ObjC modules as well:
   it switches between two different way of loading modules on the NeXT,
   one that directly interfaces with the dynamic loader (rld_load(), which
   does not correctly load ObjC object files), and another that uses the
   ObjC runtime (objc_loadModules()) to do the job.
   You'll have to add ``-ObjC'' to the compiler flags if you set this to 1.
*/
#define HANDLE_OBJC_MODULES 1
#if HANDLE_OBJC_MODULES
#include <objc/Object.h>
#include <objc/objc-load.h>
#endif
#define SHORT_EXT ".so"
#define LONG_EXT "module.so"
#endif

#ifdef WITH_SGI_DL
#define DYNAMIC_LINK
#define USE_DL
#endif

#ifdef WITH_DL_DLD
#define DYNAMIC_LINK
#define USE_DL
#endif

#ifdef USE_MAC_DYNAMIC_LOADING
#define DYNAMIC_LINK
#define SHORT_EXT ".slb"
#ifdef __CFM68K__
#define LONG_EXT ".CFM68K.slb"
#else
#define LONG_EXT ".ppc.slb"
#endif
#ifndef _DL_FUNCPTR_DEFINED
typedef void (*dl_funcptr)();
#endif
#endif

#if !defined(DYNAMIC_LINK) && (defined(HAVE_DLOPEN) || defined(M_UNIX))
#define DYNAMIC_LINK
#define USE_SHLIB
#endif

#ifdef _AIX
#undef USE_SHLIB /* AIX 4.2 and higher have dlfcn.h but we don't want it */
#define DYNAMIC_LINK
#define SHORT_EXT ".so"
#define LONG_EXT "module.so"
#include <sys/ldr.h>
typedef void (*dl_funcptr)();
#define _DL_FUNCPTR_DEFINED
static int  aix_getoldmodules(void **);
static int  aix_bindnewmodule(void *, void *);
static void aix_loaderror(char *);
#endif

#ifdef __BEOS__
#  undef USE_SHLIB /* probably not defined anyway */
#  define DYNAMIC_LINK
#  define SHORT_EXT ".so"
#  define LONG_EXT "module.so"
typedef void (*dl_funcptr)(void);
#  define _DL_FUNCPTR_DEFINED

#  if defined(MAXPATHLEN) && !defined(_SYS_PARAM_H)
#    undef MAXPATHLEN
#  endif

#  include <kernel/image.h>
#  include <kernel/OS.h>
#  include <stdlib.h>
#  include <unistd.h>

#  ifdef WITH_THREAD
#    include "thread.h"
static type_lock beos_dyn_lock;
#  endif

static PyObject *beos_dyn_images = NULL;

static void beos_init_dyn( void );
static void beos_cleanup_dyn( void );
static void beos_nuke_dyn( PyObject *item );
static void beos_add_dyn( char *pathname, image_id id );

/* External interface for finding image IDs; useful if you need to
 * do your own symbol lookup in dynamically loaded modules. [Donn Cave]
 *
 * Hmm, could we hack up the Sun dlmodule instead for this sort of thing?
 * That might be more generally useful. [chrish]
 */
image_id PyImport_BeImageID( char *name );
#endif

#ifdef DYNAMIC_LINK

#ifdef USE_SHLIB
#include <sys/types.h>
#include <sys/stat.h>
#if defined(__NetBSD__) && (NetBSD < 199712)
#include <nlist.h>
#include <link.h>
#else
#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#endif
#endif
#ifndef _DL_FUNCPTR_DEFINED
typedef void (*dl_funcptr)();
#endif
#ifndef RTLD_LAZY
#define RTLD_LAZY 1
#endif
#define SHORT_EXT ".so"
#define LONG_EXT "module.so"
#endif /* USE_SHLIB */

#if defined(USE_DL) || defined(hpux)
#include "dl.h"
#endif

#ifdef USE_MAC_DYNAMIC_LOADING
#include <Aliases.h>
#include <CodeFragments.h>
#ifdef SYMANTEC__CFM68K__ /* Really an older version of Universal Headers */
#define CFragConnectionID ConnectionID
#define kLoadCFrag 0x01
#endif
#ifdef USE_GUSI
#include "TFileSpec.h"		/* for Path2FSSpec() */
#endif
#include <Files.h>
#include "macdefs.h"
#include "macglue.h"
#endif

#ifdef USE_RLD
#include <mach-o/rld.h>
#define FUNCNAME_PATTERN "_init%.200s"
#ifndef _DL_FUNCPTR_DEFINED
typedef void (*dl_funcptr)();
#endif
#endif /* USE_RLD */

extern char *Py_GetProgramName();

#ifndef FUNCNAME_PATTERN
#if defined(__hp9000s300) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__BORLANDC__)
#define FUNCNAME_PATTERN "_init%.200s"
#else
#define FUNCNAME_PATTERN "init%.200s"
#endif
#endif

#if !defined(SHORT_EXT) && !defined(LONG_EXT)
#define SHORT_EXT ".o"
#define LONG_EXT "module.o"
#endif /* !SHORT_EXT && !LONG_EXT */

#endif /* DYNAMIC_LINK */

struct filedescr _PyImport_Filetab[] = {
#ifdef SHORT_EXT
	{SHORT_EXT, "rb", C_EXTENSION},
#endif /* !SHORT_EXT */
#ifdef LONG_EXT
	{LONG_EXT, "rb", C_EXTENSION},
#endif /* !LONG_EXT */
	{".py", "r", PY_SOURCE},
	{".pyc", "rb", PY_COMPILED},
	{0, 0}
};

#ifdef NO_DYNAMIC_LINK
#undef DYNAMIC_LINK
#endif

PyObject *
_PyImport_LoadDynamicModule(name, pathname, fp)
	char *name;
	char *pathname;
	FILE *fp;
{
#ifndef DYNAMIC_LINK
	PyErr_SetString(PyExc_ImportError,
			"dynamically linked modules not supported");
	return NULL;
#else
	PyObject *m, *d, *s;
	char funcname[258];
	char *lastdot, *shortname, *packagecontext;
	dl_funcptr p = NULL;
#ifdef USE_SHLIB
	static struct {
		dev_t dev;
		ino_t ino;
		void *handle;
	} handles[128];
	static int nhandles = 0;
	char pathbuf[260];
	if (strchr(pathname, '/') == NULL) {
		/* Prefix bare filename with "./" */
		sprintf(pathbuf, "./%-.255s", pathname);
		pathname = pathbuf;
	}
#endif
	if ((m = _PyImport_FindExtension(name, pathname)) != NULL) {
		Py_INCREF(m);
		return m;
	}
	lastdot = strrchr(name, '.');
	if (lastdot == NULL) {
		packagecontext = NULL;
		shortname = name;
	}
	else {
		packagecontext = name;
		shortname = lastdot+1;
	}
	sprintf(funcname, FUNCNAME_PATTERN, shortname);
#ifdef USE_SHLIB
	if (fp != NULL) {
		int i;
		struct stat statb;
		fstat(fileno(fp), &statb);
		for (i = 0; i < nhandles; i++) {
			if (statb.st_dev == handles[i].dev &&
			    statb.st_ino == handles[i].ino) {
				p = (dl_funcptr) dlsym(handles[i].handle,
						       funcname);
				goto got_it;
			}
		}
		if (nhandles < 128) {
			handles[nhandles].dev = statb.st_dev;
			handles[nhandles].ino = statb.st_ino;
		}
	}
#endif /* USE_SHLIB */
#ifdef USE_MAC_DYNAMIC_LOADING
	/*
	** Dynamic loading of CFM shared libraries on the Mac.  The
	** code has become more convoluted than it was, because we
	** want to be able to put multiple modules in a single
	** file. For this reason, we have to determine the fragment
	** name, and we cannot use the library entry point but we have
	** to locate the correct init routine "by hand".
	*/
	{
		FSSpec libspec;
		CFragConnectionID connID;
		Ptr mainAddr;
		Str255 errMessage;
		OSErr err;
#ifndef USE_GUSI
		Boolean isfolder, didsomething;
#endif
		char buf[512];
		Str63 fragname;
		Ptr symAddr;
		CFragSymbolClass class;
		
		/* First resolve any aliases to find the real file */
#ifdef USE_GUSI
		err = Path2FSSpec(pathname, &libspec);
#else
		(void)FSMakeFSSpec(0, 0, Pstring(pathname), &libspec);
		err = ResolveAliasFile(&libspec, 1, &isfolder, &didsomething);
#endif
		if ( err ) {
			sprintf(buf, "%.255s: %.200s",
				pathname, PyMac_StrError(err));
			PyErr_SetString(PyExc_ImportError, buf);
			return NULL;
		}
		/* Next, determine the fragment name,
		   by stripping '.slb' and 'module' */
		memcpy(fragname+1, libspec.name+1, libspec.name[0]);
		fragname[0] = libspec.name[0];
		if( strncmp((char *)(fragname+1+fragname[0]-4),
			    ".slb", 4) == 0 )
			fragname[0] -= 4;
		if ( strncmp((char *)(fragname+1+fragname[0]-6),
			     "module", 6) == 0 )
			fragname[0] -= 6;
		/* Load the fragment
		   (or return the connID if it is already loaded */
		err = GetDiskFragment(&libspec, 0, 0, fragname, 
				      kLoadCFrag, &connID, &mainAddr,
				      errMessage);
		if ( err ) {
			sprintf(buf, "%.*s: %.200s",
				errMessage[0], errMessage+1,
				PyMac_StrError(err));
			PyErr_SetString(PyExc_ImportError, buf);
			return NULL;
		}
		/* Locate the address of the correct init function */
		err = FindSymbol(connID, Pstring(funcname), &symAddr, &class);
		if ( err ) {
			sprintf(buf, "%s: %.200s",
				funcname, PyMac_StrError(err));
			PyErr_SetString(PyExc_ImportError, buf);
			return NULL;
		}
		p = (dl_funcptr)symAddr;
	}
#endif /* USE_MAC_DYNAMIC_LOADING */
#ifdef USE_SHLIB
	{
#ifdef RTLD_NOW
		/* RTLD_NOW: resolve externals now
		   (i.e. core dump now if some are missing) */
		void *handle = dlopen(pathname, RTLD_NOW);
#else
		void *handle;
		if (Py_VerboseFlag)
			printf("dlopen(\"%s\", %d);\n", pathname,
			       RTLD_LAZY);
		handle = dlopen(pathname, RTLD_LAZY);
#endif /* RTLD_NOW */
		if (handle == NULL) {
			PyErr_SetString(PyExc_ImportError, dlerror());
			return NULL;
		}
		if (fp != NULL && nhandles < 128)
			handles[nhandles++].handle = handle;
		p = (dl_funcptr) dlsym(handle, funcname);
	}
#endif /* USE_SHLIB */
#ifdef _AIX
	/*
	-- Invoke load() with L_NOAUTODEFER leaving the imported symbols
	-- of the shared module unresolved. Thus we have to resolve them
	-- explicitely with loadbind. The new module is loaded, then we
	-- resolve its symbols using the list of already loaded modules
	-- (only those that belong to the python executable). Get these
	-- with loadquery(L_GETINFO).
	*/
	{
		static void *staticmodlistptr = NULL;

		if (!staticmodlistptr)
			if (aix_getoldmodules(&staticmodlistptr) == -1)
				return NULL;
		p = (dl_funcptr) load(pathname, L_NOAUTODEFER, 0);
		if (p == NULL) {
			aix_loaderror(pathname);
			return NULL;
		}
		if (aix_bindnewmodule((void *)p, staticmodlistptr) == -1) {
			aix_loaderror(pathname);
			return NULL;
		}
	}
#endif /* _AIX */
#ifdef MS_WIN32
	{
		HINSTANCE hDLL;
		char pathbuf[260];
		if (strchr(pathname, SEP) == NULL &&
		    strchr(pathname, ALTSEP) == NULL)
		{
			/* Prefix bare filename with ".\" */
			char *p = pathbuf;
			*p = '\0';
			_getcwd(pathbuf, sizeof pathbuf);
			if (*p != '\0' && p[1] == ':')
				p += 2;
			sprintf(p, ".\\%-.255s", pathname);
			pathname = pathbuf;
		}
		hDLL = LoadLibrary(pathname);
		if (hDLL==NULL){
			char errBuf[256];
			unsigned int errorCode;

			/* Get an error string from Win32 error code */
			char theInfo[256]; /* Pointer to error text
					      from system */
			int theLength; /* Length of error text */

			errorCode = GetLastError();

			theLength = FormatMessage(
				FORMAT_MESSAGE_FROM_SYSTEM, /* flags */
				NULL, /* message source */
				errorCode, /* the message (error) ID */
				0, /* default language environment */
				(LPTSTR) theInfo, /* the buffer */
				sizeof(theInfo), /* the buffer size */
				NULL); /* no additional format args. */

			/* Problem: could not get the error message.
			   This should not happen if called correctly. */
			if (theLength == 0) {
				sprintf(errBuf,
					"DLL load failed with error code %d",
					errorCode);
			} else {
				int len;
				/* For some reason a \r\n
				   is appended to the text */
				if (theLength >= 2 &&
				    theInfo[theLength-2] == '\r' &&
				    theInfo[theLength-1] == '\n') {
					theLength -= 2;
					theInfo[theLength] = '\0';
				}
				strcpy(errBuf, "DLL load failed: ");
				len = strlen(errBuf);
				strncpy(errBuf+len, theInfo,
					sizeof(errBuf)-len);
				errBuf[sizeof(errBuf)-1] = '\0';
			}
			PyErr_SetString(PyExc_ImportError, errBuf);
		return NULL;
		}
		p = GetProcAddress(hDLL, funcname);
	}
#endif /* MS_WIN32 */
#ifdef MS_WIN16
	{
		HINSTANCE hDLL;
		char pathbuf[16];
		if (strchr(pathname, SEP) == NULL &&
		    strchr(pathname, ALTSEP) == NULL)
		{
			/* Prefix bare filename with ".\" */
			sprintf(pathbuf, ".\\%-.13s", pathname);
			pathname = pathbuf;
		}
		hDLL = LoadLibrary(pathname);
		if (hDLL < HINSTANCE_ERROR){
			char errBuf[256];
			sprintf(errBuf,
				"DLL load failed with error code %d", hDLL);
			PyErr_SetString(PyExc_ImportError, errBuf);
			return NULL;
		}
		p = GetProcAddress(hDLL, funcname);
	}
#endif /* MS_WIN16 */

#if defined(PYOS_OS2)
	{
		APIRET  rc;
		HMODULE hDLL;
		char failreason[256];

		rc = DosLoadModule(failreason,
				   sizeof(failreason),
				   pathname,
				   &hDLL);

		if (rc != NO_ERROR) {
			char errBuf[256];
			sprintf(errBuf,
				"DLL load failed, rc = %d, problem '%s': %s",
				rc, failreason);
			PyErr_SetString(PyExc_ImportError, errBuf);
			return NULL;
		}

		rc = DosQueryProcAddr(hDLL, 0L, funcname, &p);
		if (rc != NO_ERROR)
			p = NULL; /* Signify Failure to Acquire Entrypoint */
	}
#endif /* PYOS_OS2 */

#ifdef USE_DL
	p =  dl_loadmod(Py_GetProgramName(), pathname, funcname);
#endif /* USE_DL */
#ifdef USE_RLD
	{
		NXStream *errorStream;
		struct mach_header *new_header;
		const char *filenames[2];
		long ret;
		unsigned long ptr;

		errorStream = NXOpenMemory(NULL, 0, NX_WRITEONLY);
		filenames[0] = pathname;
		filenames[1] = NULL;

#if HANDLE_OBJC_MODULES

/* The following very bogus line of code ensures that
   objc_msgSend, etc are linked into the binary.  Without
   it, dynamic loading of a module that includes objective-c
   method calls will fail with "undefined symbol _objc_msgSend()".
   This remains true even in the presence of the -ObjC flag
   to the compiler
*/

		[Object name];

/* objc_loadModules() dynamically loads the object files
   indicated by the paths in filenames.  If there are any
   errors generated during loading -- typically due to the
   inability to find particular symbols -- an error message
   will be written to errorStream.
   It returns 0 if the module is successfully loaded, 1
   otherwise.
*/

		ret = !objc_loadModules(filenames, errorStream,
					NULL, &new_header, NULL);

#else /* !HANDLE_OBJC_MODULES */

		ret = rld_load(errorStream, &new_header, 
				filenames, NULL);

#endif /* HANDLE_OBJC_MODULES */

		/* extract the error messages for the exception */
		if(!ret) {
			char *streamBuf;
			int len, maxLen;

			NXPutc(errorStream, (char)0);

			NXGetMemoryBuffer(errorStream,
				&streamBuf, &len, &maxLen);
			PyErr_SetString(PyExc_ImportError, streamBuf);
		}

		if(ret && rld_lookup(errorStream, funcname, &ptr))
			p = (dl_funcptr) ptr;

		NXCloseMemory(errorStream, NX_FREEBUFFER);

		if(!ret)
			return NULL;
	}
#endif /* USE_RLD */
#ifdef hpux
	{
		shl_t lib;
		int flags;

		flags = BIND_FIRST | BIND_DEFERRED;
		if (Py_VerboseFlag) {
			flags = DYNAMIC_PATH | BIND_FIRST | BIND_IMMEDIATE |
				BIND_NONFATAL | BIND_VERBOSE;
			printf("shl_load %s\n",pathname);
		}
		lib = shl_load(pathname, flags, 0);
		/* XXX Chuck Blake once wrote that 0 should be BIND_NOSTART? */
		if (lib == NULL) {
			char buf[256];
			if (Py_VerboseFlag)
				perror(pathname);
			sprintf(buf, "Failed to load %.200s", pathname);
			PyErr_SetString(PyExc_ImportError, buf);
			return NULL;
		}
		if (Py_VerboseFlag)
			printf("shl_findsym %s\n", funcname);
		shl_findsym(&lib, funcname, TYPE_UNDEFINED, (void *) &p);
		if (p == NULL && Py_VerboseFlag)
			perror(funcname);
	}
#endif /* hpux */
#ifdef __BEOS__
	{
		image_id the_id;
		status_t retval;
		char fullpath[PATH_MAX];

		if( Py_VerboseFlag ) {
			printf( "load_add_on( %s )\n", pathname );
		}

		/* Hmm, this old bug appears to have regenerated itself; if the
		 * path isn't absolute, load_add_on() will fail.  Reported to Be
		 * April 21, 1998.
		 */
		if( pathname[0] != '/' ) {
			(void)getcwd( fullpath, PATH_MAX );
			(void)strncat( fullpath, "/", PATH_MAX );
			(void)strncat( fullpath, pathname, PATH_MAX );
			
			if( Py_VerboseFlag ) {
				printf( "load_add_on( %s )\n", fullpath );
			}
		} else {
			(void)strcpy( fullpath, pathname );
		}

		the_id = load_add_on( fullpath );
		if( the_id < B_NO_ERROR ) {
			/* It's too bad load_add_on() doesn't set errno or something...
			 */
			char buff[256];  /* hate hard-coded string sizes... */

			if( Py_VerboseFlag ) {
				printf( "load_add_on( %s ) failed", fullpath );
			}

			switch( the_id ) {
			case B_ERROR:
				sprintf( buff, "BeOS: Failed to load %.200s", fullpath );
				break;
			default:
				sprintf( buff, "Unknown error loading %.200s", fullpath );
				break;
			}

			PyErr_SetString( PyExc_ImportError, buff );
			return NULL;
		}

		if( Py_VerboseFlag ) {
			printf( "get_image_symbol( %s )\n", funcname );
		}

		retval = get_image_symbol( the_id, funcname, B_SYMBOL_TYPE_TEXT, &p );
		if( retval != B_NO_ERROR || p == NULL ) {
			/* That's bad, we can't find that symbol in the module...
			 */
			char buff[256];  /* hate hard-coded string sizes... */

			if( Py_VerboseFlag ) {
				printf( "get_image_symbol( %s ) failed", funcname );
			}

			switch( retval ) {
			case B_BAD_IMAGE_ID:
				sprintf( buff, "can't load init function for dynamic module: "
				               "Invalid image ID for %.180s", fullpath );
				break;
			case B_BAD_INDEX:
				sprintf( buff, "can't load init function for dynamic module: "
				               "Bad index for %.180s", funcname );
				break;
			default:
				sprintf( buff, "can't load init function for dynamic module: "
				               "Unknown error looking up %.180s", funcname );
				break;
			}

			retval = unload_add_on( the_id );

			PyErr_SetString( PyExc_ImportError, buff );
			return NULL;
		}

		/* Save the module name and image ID for later so we can clean up
		 * gracefully.
		 */
		beos_add_dyn( name, the_id );
	}
#endif /* __BEOS__ */
#ifdef USE_SHLIB
  got_it:
#endif
	if (p == NULL) {
		PyErr_Format(PyExc_ImportError,
		   "dynamic module does not define init function (%.200s)",
			     funcname);
		return NULL;
	}
	_Py_PackageContext = packagecontext;
	(*p)();
	_Py_PackageContext = NULL;
	if (PyErr_Occurred())
		return NULL;
	if (_PyImport_FixupExtension(name, pathname) == NULL)
		return NULL;

	m = PyDict_GetItemString(PyImport_GetModuleDict(), name);
	if (m == NULL) {
		PyErr_SetString(PyExc_SystemError,
				"dynamic module not initialized properly");
		return NULL;
	}
	/* Remember the filename as the __file__ attribute */
	d = PyModule_GetDict(m);
	s = PyString_FromString(pathname);
	if (s == NULL || PyDict_SetItemString(d, "__file__", s) != 0)
		PyErr_Clear(); /* Not important enough to report */
	Py_XDECREF(s);
	if (Py_VerboseFlag)
		fprintf(stderr,
			"import %s # dynamically loaded from %s\n",
			name, pathname);
	Py_INCREF(m);
	return m;
#endif /* DYNAMIC_LINK */
}


#ifdef _AIX

#include <ctype.h>	/*  for isdigit()	  */
#include <errno.h>	/*  for global errno      */
#include <string.h>	/*  for strerror()        */
#include <stdlib.h>	/*  for malloc(), free()  */

typedef struct Module {
	struct Module *next;
	void          *entry;
} Module, *ModulePtr;

static int
aix_getoldmodules(modlistptr)
	void **modlistptr;
{
	register ModulePtr       modptr, prevmodptr;
	register struct ld_info  *ldiptr;
	register char            *ldibuf;
	register int             errflag, bufsize = 1024;
	register unsigned int    offset;
	
	/*
	-- Get the list of loaded modules into ld_info structures.
	*/
	if ((ldibuf = malloc(bufsize)) == NULL) {
		PyErr_SetString(PyExc_ImportError, strerror(errno));
		return -1;
	}
	while ((errflag = loadquery(L_GETINFO, ldibuf, bufsize)) == -1
	       && errno == ENOMEM) {
		free(ldibuf);
		bufsize += 1024;
		if ((ldibuf = malloc(bufsize)) == NULL) {
			PyErr_SetString(PyExc_ImportError, strerror(errno));
			return -1;
		}
	}
	if (errflag == -1) {
		PyErr_SetString(PyExc_ImportError, strerror(errno));
		return -1;
	}
	/*
	-- Make the modules list from the ld_info structures.
	*/
	ldiptr = (struct ld_info *)ldibuf;
	prevmodptr = NULL;
	do {
		if (strstr(ldiptr->ldinfo_filename, "python") == NULL) {
			/*
			-- Extract only the modules containing "python" as a
			-- substring, like the "python[version]" executable or
			-- "libpython[version].a" in case python is embedded.
			*/
			offset = (unsigned int)ldiptr->ldinfo_next;
			ldiptr = (struct ld_info *)((unsigned int)
						    ldiptr + offset);
			continue;
		}
		if ((modptr = (ModulePtr)malloc(sizeof(Module))) == NULL) {
			PyErr_SetString(PyExc_ImportError, strerror(errno));
			while (*modlistptr) {
				modptr = (ModulePtr)*modlistptr;
				*modlistptr = (void *)modptr->next;
				free(modptr);
			}
			return -1;
		}
		modptr->entry = ldiptr->ldinfo_dataorg;
		modptr->next  = NULL;
		if (prevmodptr == NULL)
			*modlistptr = (void *)modptr;
		else
			prevmodptr->next = modptr;
		prevmodptr = modptr;
		offset = (unsigned int)ldiptr->ldinfo_next;
		ldiptr = (struct ld_info *)((unsigned int)ldiptr + offset);
	} while (offset);
	free(ldibuf);
	return 0;
}

static int
aix_bindnewmodule(newmoduleptr, modlistptr)
	void *newmoduleptr;
	void *modlistptr;        
{
	register ModulePtr modptr;

	/*
	-- Bind the new module with the list of loaded modules.
	*/
	for (modptr = (ModulePtr)modlistptr; modptr; modptr = modptr->next)
		if (loadbind(0, modptr->entry, newmoduleptr) != 0)
			return -1;
	return 0;
}

static void
aix_loaderror(pathname)
	char *pathname;
{

	char *message[1024], errbuf[1024];
	register int i,j;

	struct errtab { 
		int errNo;
		char *errstr;
	} load_errtab[] = {
		{L_ERROR_TOOMANY,	"too many errors, rest skipped."},
		{L_ERROR_NOLIB,		"can't load library:"},
		{L_ERROR_UNDEF,		"can't find symbol in library:"},
		{L_ERROR_RLDBAD,
		 "RLD index out of range or bad relocation type:"},
		{L_ERROR_FORMAT,	"not a valid, executable xcoff file:"},
		{L_ERROR_MEMBER,
		 "file not an archive or does not contain requested member:"},
		{L_ERROR_TYPE,		"symbol table mismatch:"},
		{L_ERROR_ALIGN,		"text alignment in file is wrong."},
		{L_ERROR_SYSTEM,	"System error:"},
		{L_ERROR_ERRNO,		NULL}
	};

#define LOAD_ERRTAB_LEN	(sizeof(load_errtab)/sizeof(load_errtab[0]))
#define ERRBUF_APPEND(s) strncat(errbuf, s, sizeof(errbuf)-strlen(errbuf)-1)

	sprintf(errbuf, "from module %.200s ", pathname);

	if (!loadquery(L_GETMESSAGES, &message[0], sizeof(message))) {
		ERRBUF_APPEND(strerror(errno));
		ERRBUF_APPEND("\n");
	}
	for(i = 0; message[i] && *message[i]; i++) {
		int nerr = atoi(message[i]);
		for (j=0; j<LOAD_ERRTAB_LEN ; j++) {
		    if (nerr == load_errtab[j].errNo && load_errtab[j].errstr)
			ERRBUF_APPEND(load_errtab[j].errstr);
		}
		while (isdigit(*message[i])) message[i]++ ; 
		ERRBUF_APPEND(message[i]);
		ERRBUF_APPEND("\n");
	}
	errbuf[strlen(errbuf)-1] = '\0';	/* trim off last newline */
	PyErr_SetString(PyExc_ImportError, errbuf); 
	return; 
}

#endif /* _AIX */

#ifdef __BEOS__
/* ----------------------------------------------------------------------
 * BeOS dynamic loading support
 *
 * This uses shared libraries, but BeOS has its own way of doing things
 * (much easier than dlfnc.h, from the look of things).  We'll use a
 * Python Dictionary object to store the images_ids so we can be very
 * nice and unload them when we exit.
 *
 * Note that this is thread-safe.  Probably irrelevent, because of losing
 * systems... Python probably disables threads while loading modules.
 * Note the use of "probably"!  Better to be safe than sorry. [chrish]
 *
 * As of 1.5.1 this should also work properly when you've configured
 * Python without thread support; the 1.5 version required it, which wasn't
 * very friendly.  Note that I haven't tested it without threading... why
 * would you want to avoid threads on BeOS? [chrish]
 */

/*
 * Initialize our dictionary, and the dictionary mutex.
 */
static void beos_init_dyn( void )
{
	/* We're protected from a race condition here by the atomic init_count
	 * variable.
	 */
	static int32 init_count = 0;
	int32 val;

	val = atomic_add( &init_count, 1 );
	if( beos_dyn_images == NULL && val == 0 ) {
		beos_dyn_images = PyDict_New();
#ifdef WITH_THREAD
		beos_dyn_lock = PyThread_allocate_lock();
#endif
		atexit( beos_cleanup_dyn );
	}
}

/* atexit() handler that'll call unload_add_on() for every item in the
 * dictionary.
 */
static void beos_cleanup_dyn( void )
{
	if( beos_dyn_images ) {
		int idx;
		int list_size;
		PyObject *id_list;

#ifdef WITH_THREAD
		PyThread_acquire_lock( beos_dyn_lock, 1 );
#endif

		id_list = PyDict_Values( beos_dyn_images );

		list_size = PyList_Size( id_list );
		for( idx = 0; idx < list_size; idx++ ) {
			PyObject *the_item;
			
			the_item = PyList_GetItem( id_list, idx );
			beos_nuke_dyn( the_item );
		}

		PyDict_Clear( beos_dyn_images );

#ifdef WITH_THREAD
		PyThread_free_lock( beos_dyn_lock );
#endif
	}
}

/* Whack an item; the item is an image_id in disguise, so we'll call
 * unload_add_on() for it.
 */
static void beos_nuke_dyn( PyObject *item )
{
	status_t retval;

	if( item ) {
		image_id id = (image_id)PyInt_AsLong( item );
		
		retval = unload_add_on( id );
	}
}

/*
 * Add an image_id to the dictionary; the module name of the loaded image
 * is the key.  Note that if the key is already in the dict, we unload
 * that image; this should allow reload() to work on dynamically loaded
 * modules (super-keen!).
 */
static void beos_add_dyn( char *name, image_id id )
{
	int retval;
	PyObject *py_id;

	if( beos_dyn_images == NULL ) {
		beos_init_dyn();
	}

#ifdef WITH_THREAD
	retval = PyThread_acquire_lock( beos_dyn_lock, 1 );
#endif

	/* If there's already an object with this key in the dictionary,
	 * we're doing a reload(), so let's nuke it.
	 */
	py_id = PyDict_GetItemString( beos_dyn_images, name );
	if( py_id ) {
		beos_nuke_dyn( py_id );
		retval = PyDict_DelItemString( beos_dyn_images, name );
	}

	py_id = PyInt_FromLong( (long)id );
	if( py_id ) {
		retval = PyDict_SetItemString( beos_dyn_images, name, py_id );
	}

#ifdef WITH_THREAD
	PyThread_release_lock( beos_dyn_lock );
#endif
}

/* Given a module name, return the image_id (if it's a dynamically loaded
 * module). [Donn Cave]
 */
image_id PyImport_BeImageID( char *name )
{
	int retval;
	PyObject *py_id;
	long id;
	
	if( !beos_dyn_images ) {
		return B_ERROR;
	}

#ifdef WITH_THREAD	
	retval = PyThread_acquire_lock( beos_dyn_lock, 1 );
#endif
	
	py_id = PyDict_GetItemString( beos_dyn_images, name );
	if( py_id ) {
		id = PyInt_AsLong( py_id );
	} else {
		id = B_ERROR;
	}

#ifdef WITH_THREAD	
	PyThread_release_lock( beos_dyn_lock );
#endif
	
	return (image_id)id;
}
#endif /* __BEOS__ */