Changes for BeOS, QNX and long long, by Chris Herborth.
diff --git a/Python/frozenmain.c b/Python/frozenmain.c
index ab9d60d..cb46d65 100644
--- a/Python/frozenmain.c
+++ b/Python/frozenmain.c
@@ -42,6 +42,11 @@
#include <unistd.h> /* For isatty() */
#endif
+/* For isatty()'s proto. - [cjh] */
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
/* Main program */
int
diff --git a/Python/getargs.c b/Python/getargs.c
index e4c2634..34e3a5c 100644
--- a/Python/getargs.c
+++ b/Python/getargs.c
@@ -499,6 +499,20 @@
break;
}
+#if HAVE_LONG_LONG
+ case 'L': /* long long */
+ {
+ long long *p = va_arg( *p_va, long long * );
+ long long ival = PyLong_AsLongLong( arg );
+ if( ival == (long long)-1 && PyErr_Occurred() ) {
+ return "long<L>";
+ } else {
+ *p = ival;
+ }
+ break;
+ }
+#endif
+
case 'f': /* float */
{
float *p = va_arg(*p_va, float *);
@@ -988,6 +1002,14 @@
break;
}
+#if HAVE_LONG_LONG
+ case 'L': /* long long int */
+ {
+ (void) va_arg(*p_va, long long *);
+ break;
+ }
+#endif
+
case 'f': /* float */
{
(void) va_arg(*p_va, float *);
diff --git a/Python/import.c b/Python/import.c
index f745a94..b859c2b 100644
--- a/Python/import.c
+++ b/Python/import.c
@@ -2274,7 +2274,7 @@
{NULL, NULL} /* sentinel */
};
-int
+static int
setint(d, name, value)
PyObject *d;
char *name;
diff --git a/Python/importdl.c b/Python/importdl.c
index 93282a3..2947d15 100644
--- a/Python/importdl.c
+++ b/Python/importdl.c
@@ -61,6 +61,7 @@
__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.)
@@ -164,6 +165,44 @@
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
@@ -597,6 +636,96 @@
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
@@ -785,3 +914,159 @@
}
#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__ */
diff --git a/Python/modsupport.c b/Python/modsupport.c
index 76fc2d9..f5c61da 100644
--- a/Python/modsupport.c
+++ b/Python/modsupport.c
@@ -291,6 +291,11 @@
case 'l':
return PyInt_FromLong((long)va_arg(*p_va, long));
+#if HAVE_LONG_LONG
+ case 'L':
+ return PyLong_FromLongLong((long long)va_arg(*p_va, long long));
+#endif
+
case 'f':
case 'd':
return PyFloat_FromDouble(
diff --git a/Python/pyfpe.c b/Python/pyfpe.c
index 6048cde..b3d9985 100644
--- a/Python/pyfpe.c
+++ b/Python/pyfpe.c
@@ -12,4 +12,13 @@
jmp_buf PyFPE_jbuf;
int PyFPE_counter = 0;
double PyFPE_dummy(void *dummy){ return 1.0; }
+#else
+#ifdef __MWERKS__
+/*
+ * Metrowerks fails when compiling an empty file, at least in strict ANSI
+ * mode. - [cjh]
+ */
+static double PyFPE_dummy( void * );
+static double PyFPE_dummy( void *dummy ) { return 1.0; }
+#endif
#endif
diff --git a/Python/thread.c b/Python/thread.c
index f441752..9da701d 100644
--- a/Python/thread.c
+++ b/Python/thread.c
@@ -153,6 +153,10 @@
#include "thread_os2.h"
#endif
+#ifdef BEOS_THREADS
+#include "thread_beos.h"
+#endif
+
/*
#ifdef FOOBAR_THREADS
#include "thread_foobar.h"