/* Support for dynamic loading of extension modules */ #include <kernel/image.h>#include <kernel/OS.h>#include <stdlib.h> #include "Python.h"#include "importdl.h" const struct filedescr _PyImport_DynLoadFiletab[] = {	{".so", "rb", C_EXTENSION},	{"module.so", "rb", C_EXTENSION},	{0, 0}}; #if defined(MAXPATHLEN) && !defined(_SYS_PARAM_H)#undef MAXPATHLEN#endif #ifdef WITH_THREAD#include "pythread.h"static PyThread_type_lock beos_dyn_lock;#endif static PyObject *beos_dyn_images = NULL; /* ---------------------------------------------------------------------- * 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] * * As of 1.5.2, the PyImport_BeImageID() function has been removed; Donn * tells me it's not necessary anymore because of PyCObject_Import(). * [chrish] */ /* 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 );	}} /* 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	}} /* * 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 );	}} /* * 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}   dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,				    const char *pathname, FILE *fp){	dl_funcptr p;	image_id the_id;	status_t retval;	char fullpath[PATH_MAX];	char funcname[258]; 	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 );		} 		if( the_id == B_ERROR )			PyOS_snprintf( buff, sizeof(buff),				       "BeOS: Failed to load %.200s",				       fullpath );		else			PyOS_snprintf( buff, sizeof(buff), 				       "Unknown error loading %.200s", 				       fullpath ); 		PyErr_SetString( PyExc_ImportError, buff );		return NULL;	} 	PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);	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:			PyOS_snprintf( buff, sizeof(buff),			       "can't load init function for dynamic module: "		               "Invalid image ID for %.180s", fullpath );			break;		case B_BAD_INDEX:			PyOS_snprintf( buff, sizeof(buff),			       "can't load init function for dynamic module: "		               "Bad index for %.180s", funcname );			break;		default:			PyOS_snprintf( buff, sizeof(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( fqname, the_id ); 	return p;}