/* 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;

}