ref: c00c60d327168c25e56077c8310cf2380833e9be
dir: /sys/src/cmd/python/Python/dynload_beos.c/
/* 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; }