EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Python / dynload_beos.c

\r
/* Support for dynamic loading of extension modules */\r
\r
#include <kernel/image.h>\r
#include <kernel/OS.h>\r
#include <stdlib.h>\r
\r
#include "Python.h"\r
#include "importdl.h"\r
\r
const struct filedescr _PyImport_DynLoadFiletab[] = {\r
    {".so", "rb", C_EXTENSION},\r
    {"module.so", "rb", C_EXTENSION},\r
    {0, 0}\r
};\r
\r
#if defined(MAXPATHLEN) && !defined(_SYS_PARAM_H)\r
#undef MAXPATHLEN\r
#endif\r
\r
#ifdef WITH_THREAD\r
#include "pythread.h"\r
static PyThread_type_lock beos_dyn_lock;\r
#endif\r
\r
static PyObject *beos_dyn_images = NULL;\r
\r
/* ----------------------------------------------------------------------\r
 * BeOS dynamic loading support\r
 *\r
 * This uses shared libraries, but BeOS has its own way of doing things\r
 * (much easier than dlfnc.h, from the look of things).  We'll use a\r
 * Python Dictionary object to store the images_ids so we can be very\r
 * nice and unload them when we exit.\r
 *\r
 * Note that this is thread-safe.  Probably irrelevent, because of losing\r
 * systems... Python probably disables threads while loading modules.\r
 * Note the use of "probably"!  Better to be safe than sorry. [chrish]\r
 *\r
 * As of 1.5.1 this should also work properly when you've configured\r
 * Python without thread support; the 1.5 version required it, which wasn't\r
 * very friendly.  Note that I haven't tested it without threading... why\r
 * would you want to avoid threads on BeOS? [chrish]\r
 *\r
 * As of 1.5.2, the PyImport_BeImageID() function has been removed; Donn\r
 * tells me it's not necessary anymore because of PyCObject_Import().\r
 * [chrish]\r
 */\r
\r
/* Whack an item; the item is an image_id in disguise, so we'll call\r
 * unload_add_on() for it.\r
 */\r
static void beos_nuke_dyn( PyObject *item )\r
{\r
    status_t retval;\r
\r
    if( item ) {\r
        image_id id = (image_id)PyInt_AsLong( item );\r
\r
        retval = unload_add_on( id );\r
    }\r
}\r
\r
/* atexit() handler that'll call unload_add_on() for every item in the\r
 * dictionary.\r
 */\r
static void beos_cleanup_dyn( void )\r
{\r
    if( beos_dyn_images ) {\r
        int idx;\r
        int list_size;\r
        PyObject *id_list;\r
\r
#ifdef WITH_THREAD\r
        PyThread_acquire_lock( beos_dyn_lock, 1 );\r
#endif\r
\r
        id_list = PyDict_Values( beos_dyn_images );\r
\r
        list_size = PyList_Size( id_list );\r
        for( idx = 0; idx < list_size; idx++ ) {\r
            PyObject *the_item;\r
\r
            the_item = PyList_GetItem( id_list, idx );\r
            beos_nuke_dyn( the_item );\r
        }\r
\r
        PyDict_Clear( beos_dyn_images );\r
\r
#ifdef WITH_THREAD\r
        PyThread_free_lock( beos_dyn_lock );\r
#endif\r
    }\r
}\r
\r
/*\r
 * Initialize our dictionary, and the dictionary mutex.\r
 */\r
static void beos_init_dyn( void )\r
{\r
    /* We're protected from a race condition here by the atomic init_count\r
     * variable.\r
     */\r
    static int32 init_count = 0;\r
    int32 val;\r
\r
    val = atomic_add( &init_count, 1 );\r
    if( beos_dyn_images == NULL && val == 0 ) {\r
        beos_dyn_images = PyDict_New();\r
#ifdef WITH_THREAD\r
        beos_dyn_lock = PyThread_allocate_lock();\r
#endif\r
        atexit( beos_cleanup_dyn );\r
    }\r
}\r
\r
/*\r
 * Add an image_id to the dictionary; the module name of the loaded image\r
 * is the key.  Note that if the key is already in the dict, we unload\r
 * that image; this should allow reload() to work on dynamically loaded\r
 * modules (super-keen!).\r
 */\r
static void beos_add_dyn( char *name, image_id id )\r
{\r
    int retval;\r
    PyObject *py_id;\r
\r
    if( beos_dyn_images == NULL ) {\r
        beos_init_dyn();\r
    }\r
\r
#ifdef WITH_THREAD\r
    retval = PyThread_acquire_lock( beos_dyn_lock, 1 );\r
#endif\r
\r
    /* If there's already an object with this key in the dictionary,\r
     * we're doing a reload(), so let's nuke it.\r
     */\r
    py_id = PyDict_GetItemString( beos_dyn_images, name );\r
    if( py_id ) {\r
        beos_nuke_dyn( py_id );\r
        retval = PyDict_DelItemString( beos_dyn_images, name );\r
    }\r
\r
    py_id = PyInt_FromLong( (long)id );\r
    if( py_id ) {\r
        retval = PyDict_SetItemString( beos_dyn_images, name, py_id );\r
    }\r
\r
#ifdef WITH_THREAD\r
    PyThread_release_lock( beos_dyn_lock );\r
#endif\r
}\r
\r
\r
\r
dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,\r
                                    const char *pathname, FILE *fp)\r
{\r
    dl_funcptr p;\r
    image_id the_id;\r
    status_t retval;\r
    char fullpath[PATH_MAX];\r
    char funcname[258];\r
\r
    if( Py_VerboseFlag ) {\r
        printf( "load_add_on( %s )\n", pathname );\r
    }\r
\r
    /* Hmm, this old bug appears to have regenerated itself; if the\r
     * path isn't absolute, load_add_on() will fail.  Reported to Be\r
     * April 21, 1998.\r
     */\r
    if( pathname[0] != '/' ) {\r
        (void)getcwd( fullpath, PATH_MAX );\r
        (void)strncat( fullpath, "/", PATH_MAX );\r
        (void)strncat( fullpath, pathname, PATH_MAX );\r
\r
        if( Py_VerboseFlag ) {\r
            printf( "load_add_on( %s )\n", fullpath );\r
        }\r
    } else {\r
        (void)strcpy( fullpath, pathname );\r
    }\r
\r
    the_id = load_add_on( fullpath );\r
    if( the_id < B_NO_ERROR ) {\r
        /* It's too bad load_add_on() doesn't set errno or something...\r
         */\r
        char buff[256];  /* hate hard-coded string sizes... */\r
\r
        if( Py_VerboseFlag ) {\r
            printf( "load_add_on( %s ) failed", fullpath );\r
        }\r
\r
        if( the_id == B_ERROR )\r
            PyOS_snprintf( buff, sizeof(buff),\r
                           "BeOS: Failed to load %.200s",\r
                           fullpath );\r
        else\r
            PyOS_snprintf( buff, sizeof(buff),\r
                           "Unknown error loading %.200s",\r
                           fullpath );\r
\r
        PyErr_SetString( PyExc_ImportError, buff );\r
        return NULL;\r
    }\r
\r
    PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);\r
    if( Py_VerboseFlag ) {\r
        printf( "get_image_symbol( %s )\n", funcname );\r
    }\r
\r
    retval = get_image_symbol( the_id, funcname, B_SYMBOL_TYPE_TEXT, &p );\r
    if( retval != B_NO_ERROR || p == NULL ) {\r
        /* That's bad, we can't find that symbol in the module...\r
         */\r
        char buff[256];  /* hate hard-coded string sizes... */\r
\r
        if( Py_VerboseFlag ) {\r
            printf( "get_image_symbol( %s ) failed", funcname );\r
        }\r
\r
        switch( retval ) {\r
        case B_BAD_IMAGE_ID:\r
            PyOS_snprintf( buff, sizeof(buff),\r
                   "can't load init function for dynamic module: "\r
                   "Invalid image ID for %.180s", fullpath );\r
            break;\r
        case B_BAD_INDEX:\r
            PyOS_snprintf( buff, sizeof(buff),\r
                   "can't load init function for dynamic module: "\r
                   "Bad index for %.180s", funcname );\r
            break;\r
        default:\r
            PyOS_snprintf( buff, sizeof(buff),\r
                   "can't load init function for dynamic module: "\r
                   "Unknown error looking up %.180s", funcname );\r
            break;\r
        }\r
\r
        retval = unload_add_on( the_id );\r
\r
        PyErr_SetString( PyExc_ImportError, buff );\r
        return NULL;\r
    }\r
\r
    /* Save the module name and image ID for later so we can clean up\r
     * gracefully.\r
     */\r
    beos_add_dyn( fqname, the_id );\r
\r
    return p;\r
}\r