Changes for BeOS, QNX and long long, by Chris Herborth.

12 files changed, 559 insertions, 1 deletions

diff --git a/Include/import.h b/Include/import.h
index 0f6e92f..2b59b51 100644
--- a/Include/import.h
+++ b/Include/import.h
@@ -54,6 +54,11 @@ int PyImport_ImportFrozenModule Py_PROTO((char *));
 extern PyObject *_PyImport_FindExtension Py_PROTO((char *, char *));
 extern PyObject *_PyImport_FixupExtension Py_PROTO((char *, char *));
 
+#ifdef __BEOS__
+#include <kernel/image.h>
+extern image_id PyImport_BeImageID( char *name );
+#endif
+
 struct _inittab {
 	char *name;
 	void (*initfunc)();
diff --git a/Include/longobject.h b/Include/longobject.h
index 88854a6..774bfda 100644
--- a/Include/longobject.h
+++ b/Include/longobject.h
@@ -50,6 +50,13 @@ extern long PyLong_AsLong Py_PROTO((PyObject *));
 extern unsigned long PyLong_AsUnsignedLong Py_PROTO((PyObject *));
 extern double PyLong_AsDouble Py_PROTO((PyObject *));
 
+#ifdef HAVE_LONG_LONG
+extern PyObject *PyLong_FromLongLong Py_PROTO((long long ));
+extern PyObject *PyLong_FromUnsignedLongLong Py_PROTO((unsigned long long));
+extern long long PyLong_AsLongLong Py_PROTO((PyObject *));
+extern unsigned long long PyLong_AsUnsignedLongLong Py_PROTO((PyObject *));
+#endif
+
 PyObject *PyLong_FromString Py_PROTO((char *, char **, int));
 
 #ifdef __cplusplus
diff --git a/Include/pythread.h b/Include/pythread.h
index 09415c9..d38c174 100644
--- a/Include/pythread.h
+++ b/Include/pythread.h
@@ -20,10 +20,17 @@ extern "C" {
 #endif
 
 /* Macros defining new names for all these symbols */
+/* BeOS note: We have exit_thread(), and no legacy code to
+ * support, so we won't allow exit_thread and _exit_thread
+ * in here.  Actually, I think these #defines should vanish;
+ * aren't they cheesy in the face of the Great Renaming? [cjh]
+ */
 #define init_thread PyThread_init_thread
 #define start_new_thread PyThread_start_new_thread
+#ifndef __BEOS__
 #define exit_thread PyThread_exit_thread
 #define _exit_thread PyThread__exit_thread
+#endif
 #define get_thread_ident PyThread_get_thread_ident
 #define allocate_lock PyThread_allocate_lock
 #define free_lock PyThread_free_lock
@@ -43,8 +50,13 @@ extern "C" {
 
 void init_thread Py_PROTO((void));
 int start_new_thread Py_PROTO((void (*)(void *), void *));
+#ifndef __BEOS__
 void exit_thread Py_PROTO((void));
 void _exit_thread Py_PROTO((void));
+#else
+void PyThread_exit_thread Py_PROTO((void));
+void PyThread__exit_thread Py_PROTO((void));
+#endif
 long get_thread_ident Py_PROTO((void));
 
 type_lock allocate_lock Py_PROTO((void));
diff --git a/Include/thread.h b/Include/thread.h
index 09415c9..d38c174 100644
--- a/Include/thread.h
+++ b/Include/thread.h
@@ -20,10 +20,17 @@ extern "C" {
 #endif
 
 /* Macros defining new names for all these symbols */
+/* BeOS note: We have exit_thread(), and no legacy code to
+ * support, so we won't allow exit_thread and _exit_thread
+ * in here.  Actually, I think these #defines should vanish;
+ * aren't they cheesy in the face of the Great Renaming? [cjh]
+ */
 #define init_thread PyThread_init_thread
 #define start_new_thread PyThread_start_new_thread
+#ifndef __BEOS__
 #define exit_thread PyThread_exit_thread
 #define _exit_thread PyThread__exit_thread
+#endif
 #define get_thread_ident PyThread_get_thread_ident
 #define allocate_lock PyThread_allocate_lock
 #define free_lock PyThread_free_lock
@@ -43,8 +50,13 @@ extern "C" {
 
 void init_thread Py_PROTO((void));
 int start_new_thread Py_PROTO((void (*)(void *), void *));
+#ifndef __BEOS__
 void exit_thread Py_PROTO((void));
 void _exit_thread Py_PROTO((void));
+#else
+void PyThread_exit_thread Py_PROTO((void));
+void PyThread__exit_thread Py_PROTO((void));
+#endif
 long get_thread_ident Py_PROTO((void));
 
 type_lock allocate_lock Py_PROTO((void));
diff --git a/Objects/longobject.c b/Objects/longobject.c
index b15a3f0..a6be3d9 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -277,6 +277,198 @@ PyLong_AsDouble(vv)
 	return x * sign;
 }
 
+#ifdef HAVE_LONG_LONG
+/*
+ * long long support by Chris Herborth (chrish@qnx.com)
+ *
+ * For better or worse :-), I tried to follow the coding style already
+ * here.
+ */
+
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
+/* Hopefully this is portable... */
+#ifndef LONG_MAX
+#define LONG_MAX 2147483647L
+#endif
+#ifndef ULONG_MAX
+#define ULONG_MAX 4294967295U
+#endif
+#ifndef LONGLONG_MAX
+#define LONGLONG_MAX 9223372036854775807LL
+#endif
+#ifndef ULONGLONG_MAX
+#define ULONGLONG_MAX 0xffffffffffffffffULL
+#endif
+
+/* Create a new long int object from a C long long int */
+
+PyObject *
+PyLong_FromLongLong(ival)
+	long long ival;
+{
+#if SIZEOF_LONG_LONG == SIZEOF_LONG
+	/* In case the compiler is faking it. */
+	return PyLong_FromLong( (long)ival );
+#else
+	if( ival <= (long long)LONG_MAX ) {
+		return PyLong_FromLong( (long)ival );
+	} else if( ival <= (unsigned long long)ULONG_MAX ) {
+		return PyLong_FromUnsignedLong( (unsigned long)ival );
+	} else {
+		/* Assume a C long long fits in at most 10 'digits'.
+		 * Should be OK if we're assuming long fits in 5.
+		 */
+		PyLongObject *v = _PyLong_New(10);
+
+		if (v != NULL) {
+			unsigned long long t = ival;
+			int i;
+			if (ival < 0) {
+				t = -ival;
+				v->ob_size = -(v->ob_size);
+  			}
+
+			for (i = 0; i < 10; i++) {
+				v->ob_digit[i] = (digit) (t & MASK);
+				t >>= SHIFT;
+			}
+
+			v = long_normalize(v);
+		}
+
+		return (PyObject *)v;
+	}
+
+	/* If we got here, we're confused... */
+	PyErr_SetString( PyExc_ArithmeticError, "invalid long integer" );
+	return NULL;
+#endif
+}
+
+/* Create a new long int object from a C unsigned long long int */
+PyObject *
+PyLong_FromUnsignedLongLong(ival)
+	unsigned long long ival;
+{
+#if SIZEOF_LONG_LONG == SIZEOF_LONG
+	/* In case the compiler is faking it. */
+	return PyLong_FromUnsignedLong( (unsigned long)ival );
+#else
+	if( ival <= (unsigned long long)ULONG_MAX ) {
+		return PyLong_FromUnsignedLong( (unsigned long)ival );
+	} else {
+		/* Assume a C long fits in at most 10 'digits'. */
+		PyLongObject *v = _PyLong_New(10);
+
+		if (v != NULL) {
+			unsigned long long t = ival;
+			int i;
+			for (i = 0; i < 10; i++) {
+				v->ob_digit[i] = (digit) (t & MASK);
+				t >>= SHIFT;
+			}
+
+			v = long_normalize(v);
+		}
+
+		return (PyObject *)v;
+	}
+
+	/* If we got here, we're confused... */
+	PyErr_SetString( PyExc_ArithmeticError, "invalid unsigned long integer" );
+	return NULL;
+#endif
+}
+
+/* Get a C long long int from a long int object.
+   Returns -1 and sets an error condition if overflow occurs. */
+
+long long
+PyLong_AsLongLong(vv)
+	PyObject *vv;
+{
+#if SIZEOF_LONG_LONG == SIZEOF_LONG
+	/* In case the compiler is faking it. */
+	return (long long)PyLong_AsLong( vv );
+#else
+	register PyLongObject *v;
+	long long x, prev;
+	int i, sign;
+	
+	if (vv == NULL || !PyLong_Check(vv)) {
+		PyErr_BadInternalCall();
+		return -1;
+	}
+
+	v = (PyLongObject *)vv;
+	i = v->ob_size;
+	sign = 1;
+	x = 0;
+
+	if (i < 0) {
+		sign = -1;
+		i = -(i);
+	}
+
+	while (--i >= 0) {
+		prev = x;
+		x = (x << SHIFT) + v->ob_digit[i];
+		if ((x >> SHIFT) != prev) {
+			PyErr_SetString(PyExc_OverflowError,
+				"long int too long to convert");
+			return -1;
+		}
+	}
+
+	return x * sign;
+#endif
+}
+
+unsigned long long
+PyLong_AsUnsignedLongLong(vv)
+	PyObject *vv;
+{
+#if SIZEOF_LONG_LONG == 4
+	/* In case the compiler is faking it. */
+	return (unsigned long long)PyLong_AsUnsignedLong( vv );
+#else
+	register PyLongObject *v;
+	unsigned long long x, prev;
+	int i;
+	
+	if (vv == NULL || !PyLong_Check(vv)) {
+		PyErr_BadInternalCall();
+		return (unsigned long long) -1;
+	}
+
+	v = (PyLongObject *)vv;
+	i = v->ob_size;
+	x = 0;
+
+	if (i < 0) {
+		PyErr_SetString(PyExc_OverflowError,
+			   "can't convert negative value to unsigned long");
+		return (unsigned long long) -1;
+	}
+
+	while (--i >= 0) {
+		prev = x;
+		x = (x << SHIFT) + v->ob_digit[i];
+		if ((x >> SHIFT) != prev) {
+			PyErr_SetString(PyExc_OverflowError,
+				"long int too long to convert");
+			return (unsigned long long) -1;
+		}
+	}
+
+	return x;
+#endif
+}
+#endif /* HAVE_LONG_LONG */
+
 /* Multiply by a single digit, ignoring the sign. */
 
 static PyLongObject *
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 @@ extern void PyWinFreeze_ExeTerm();
 #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 @@ convertsimple1(arg, p_format, p_va)
 			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 @@ skipitem(p_format, p_va)
 			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 @@ static PyMethodDef imp_methods[] = {
 	{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 @@ PERFORMANCE OF THIS SOFTWARE.
    __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 int  aix_bindnewmodule(void *, void *);
 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 @@ _PyImport_LoadDynamicModule(name, pathname, fp)
 			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 @@ aix_loaderror(pathname)
 }
 
 #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 @@ do_mkvalue(p_format, p_va)
 		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 @@ void init_thread _P0()
 #include "thread_os2.h"
 #endif
 
+#ifdef BEOS_THREADS
+#include "thread_beos.h"
+#endif
+
 /*
 #ifdef FOOBAR_THREADS
 #include "thread_foobar.h"