Index: Python/thread_foobar.h =================================================================== --- Python/thread_foobar.h (revision 68351) +++ Python/thread_foobar.h (working copy) @@ -29,54 +29,14 @@ PyThread_init_thread(); } -static -void do_PyThread_exit_thread(int no_cleanup) -{ - dprintf(("PyThread_exit_thread called\n")); - if (!initialized) - if (no_cleanup) - _exit(0); - else - exit(0); -} - void PyThread_exit_thread(void) { - do_PyThread_exit_thread(0); -} - -void -PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static -void do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); + dprintf(("PyThread_exit_thread called\n")); if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); + exit(0); } -void -PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void -PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. */ Index: Python/thread_solaris.h =================================================================== --- Python/thread_solaris.h (revision 68351) +++ Python/thread_solaris.h (working copy) @@ -64,59 +64,15 @@ return thr_self(); } -static void -do_PyThread_exit_thread(int no_cleanup) +void +PyThread_exit_thread(void) { dprintf(("PyThread_exit_thread called\n")); if (!initialized) - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); thr_exit(0); } -void -PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void -PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void -do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); - if (no_cleanup) - _exit(status); - else - exit(status); -} - -void -PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void -PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. */ Index: Python/thread_atheos.h =================================================================== --- Python/thread_atheos.h (revision 68351) +++ Python/thread_atheos.h (working copy) @@ -128,17 +128,14 @@ } -static void do_PyThread_exit_thread(int no_cleanup) +void PyThread_exit_thread(void) { dprintf(("PyThread_exit_thread called\n")); /* Thread-safe way to read a variable without a mutex: */ if (atomic_add(&thread_count, 0) == 0) { /* No threads around, so exit main(). */ - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); } else { /* We're a thread */ exit_thread(0); @@ -146,44 +143,6 @@ } -void PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - - -void PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - - -#ifndef NO_EXIT_PROG -static void do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - - /* No need to do anything, the threads get torn down if main()exits. */ - if (no_cleanup) - _exit(status); - else - exit(status); -} - - -void PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - - -void PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - - /* * Lock support. * Index: Python/thread_lwp.h =================================================================== --- Python/thread_lwp.h (revision 68351) +++ Python/thread_lwp.h (working copy) @@ -47,50 +47,14 @@ return tid.thread_id; } -static void do_PyThread_exit_thread(int no_cleanup) +void PyThread_exit_thread(void) { dprintf(("PyThread_exit_thread called\n")); if (!initialized) - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); lwp_destroy(SELF); } -void PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); - pod_exit(status); -} - -void PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. */ Index: Python/thread_cthread.h =================================================================== --- Python/thread_cthread.h (revision 68351) +++ Python/thread_cthread.h (working copy) @@ -50,59 +50,15 @@ return (long) cthread_self(); } -static void -do_PyThread_exit_thread(int no_cleanup) +void +PyThread_exit_thread(void) { dprintf(("PyThread_exit_thread called\n")); if (!initialized) - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); cthread_exit(0); } -void -PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void -PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static -void do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); - if (no_cleanup) - _exit(status); - else - exit(status); -} - -void -PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void -PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. */ Index: Python/thread_pthread.h =================================================================== --- Python/thread_pthread.h (revision 68351) +++ Python/thread_pthread.h (working copy) @@ -225,55 +225,15 @@ #endif } -static void -do_PyThread_exit_thread(int no_cleanup) +void +PyThread_exit_thread(void) { dprintf(("PyThread_exit_thread called\n")); if (!initialized) { - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); } } -void -PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void -PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void -do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); -} - -void -PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void -PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - #ifdef USE_SEMAPHORES /* Index: Python/thread_wince.h =================================================================== --- Python/thread_wince.h (revision 68351) +++ Python/thread_wince.h (working copy) @@ -53,49 +53,14 @@ return GetCurrentThreadId(); } -static void do_PyThread_exit_thread(int no_cleanup) +void PyThread_exit_thread(void) { - dprintf(("%ld: do_PyThread_exit_thread called\n", PyThread_get_thread_ident())); + dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident())); if (!initialized) - if (no_cleanup) - exit(0); /* XXX - was _exit()!! */ - else - exit(0); + exit(0); _endthread(); } -void PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); -} - -void PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. It has to be implemented using Mutexes, as * CE doesnt support semaphores. Therefore we use some hacks to Index: Python/thread_sgi.h =================================================================== --- Python/thread_sgi.h (revision 68351) +++ Python/thread_sgi.h (working copy) @@ -17,9 +17,6 @@ static int waiting_for_threads; /* protected by count_lock */ static int nthreads; /* protected by count_lock */ static int exit_status; -#ifndef NO_EXIT_PROG -static int do_exit; /* indicates that the program is to exit */ -#endif static int exiting; /* we're already exiting (for maybe_exit) */ static pid_t my_pid; /* PID of main thread */ static struct pidlist { @@ -27,53 +24,11 @@ pid_t child; } pidlist[MAXPROC]; /* PIDs of other threads; protected by count_lock */ static int maxpidindex; /* # of PIDs in pidlist */ - -#ifndef NO_EXIT_PROG /* - * This routine is called as a signal handler when another thread - * exits. When that happens, we must see whether we have to exit as - * well (because of an PyThread_exit_prog()) or whether we should continue on. - */ -static void exit_sig(void) -{ - d2printf(("exit_sig called\n")); - if (exiting && getpid() == my_pid) { - d2printf(("already exiting\n")); - return; - } - if (do_exit) { - d2printf(("exiting in exit_sig\n")); -#ifdef Py_DEBUG - if ((thread_debug & 8) == 0) - thread_debug &= ~1; /* don't produce debug messages */ -#endif - PyThread_exit_thread(); - } -} - -/* - * This routine is called when a process calls exit(). If that wasn't - * done from the library, we do as if an PyThread_exit_prog() was intended. - */ -static void maybe_exit(void) -{ - dprintf(("maybe_exit called\n")); - if (exiting) { - dprintf(("already exiting\n")); - return; - } - PyThread_exit_prog(0); -} -#endif /* NO_EXIT_PROG */ - -/* * Initialization. */ static void PyThread__init_thread(void) { -#ifndef NO_EXIT_PROG - struct sigaction s; -#endif /* NO_EXIT_PROG */ #ifdef USE_DL long addr, size; #endif /* USE_DL */ @@ -93,16 +48,6 @@ if (usconfig(CONF_INITUSERS, 16) < 0) perror("usconfig - CONF_INITUSERS"); my_pid = getpid(); /* so that we know which is the main thread */ -#ifndef NO_EXIT_PROG - atexit(maybe_exit); - s.sa_handler = exit_sig; - sigemptyset(&s.sa_mask); - /*sigaddset(&s.sa_mask, SIGUSR1);*/ - s.sa_flags = 0; - sigaction(SIGUSR1, &s, 0); - if (prctl(PR_SETEXITSIG, SIGUSR1) < 0) - perror("prctl - PR_SETEXITSIG"); -#endif /* NO_EXIT_PROG */ if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0) perror("usconfig - CONF_ARENATYPE"); usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */ @@ -227,46 +172,24 @@ return getpid(); } -static void do_PyThread_exit_thread(int no_cleanup) +void PyThread_exit_thread(void) { dprintf(("PyThread_exit_thread called\n")); if (!initialized) - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); if (ussetlock(count_lock) < 0) perror("ussetlock (count_lock)"); nthreads--; if (getpid() == my_pid) { /* main thread; wait for other threads to exit */ exiting = 1; -#ifndef NO_EXIT_PROG - if (do_exit) { - int i; - - /* notify other threads */ - clean_threads(); - if (nthreads >= 0) { - dprintf(("kill other threads\n")); - for (i = 0; i < maxpidindex; i++) - if (pidlist[i].child > 0) - (void) kill(pidlist[i].child, - SIGKILL); - _exit(exit_status); - } - } -#endif /* NO_EXIT_PROG */ waiting_for_threads = 1; if (ussetlock(wait_lock) < 0) perror("ussetlock (wait_lock)"); for (;;) { if (nthreads < 0) { dprintf(("really exit (%d)\n", exit_status)); - if (no_cleanup) - _exit(exit_status); - else - exit(exit_status); + exit(exit_status); } if (usunsetlock(count_lock) < 0) perror("usunsetlock (count_lock)"); @@ -283,50 +206,11 @@ if (usunsetlock(wait_lock) < 0) perror("usunsetlock (wait_lock)"); } -#ifndef NO_EXIT_PROG - else if (do_exit) - (void) kill(my_pid, SIGUSR1); -#endif /* NO_EXIT_PROG */ if (usunsetlock(count_lock) < 0) perror("usunsetlock (count_lock)"); _exit(0); } -void PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); - do_exit = 1; - exit_status = status; - do_PyThread_exit_thread(no_cleanup); -} - -void PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. */ Index: Python/thread_beos.h =================================================================== --- Python/thread_beos.h (revision 68351) +++ Python/thread_beos.h (working copy) @@ -144,7 +144,7 @@ return ( tid != B_NAME_NOT_FOUND ? tid : -1 ); } -static void do_PyThread_exit_thread( int no_cleanup ) +void PyThread_exit_thread( void ) { int32 threads; @@ -155,52 +155,13 @@ if( threads == 0 ) { /* No threads around, so exit main(). */ - if( no_cleanup ) { - _exit(0); - } else { - exit(0); - } + exit(0); } else { /* Oh, we're a thread, let's try to exit gracefully... */ exit_thread( B_NO_ERROR ); } } -void PyThread_exit_thread( void ) -{ - do_PyThread_exit_thread(0); -} - -void PyThread__exit_thread( void ) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void do_PyThread_exit_prog( int status, int no_cleanup ) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - - /* No need to do anything, the threads get torn down if main() exits. */ - - if (no_cleanup) { - _exit(status); - } else { - exit(status); - } -} - -void PyThread_exit_prog( int status ) -{ - do_PyThread_exit_prog(status, 0); -} - -void PyThread__exit_prog( int status ) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* ---------------------------------------------------------------------- * Lock support. */ Index: Python/thread_os2.h =================================================================== --- Python/thread_os2.h (revision 68351) +++ Python/thread_os2.h (working copy) @@ -68,56 +68,16 @@ #endif } -static void -do_PyThread_exit_thread(int no_cleanup) +void +PyThread_exit_thread(void) { dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident())); if (!initialized) - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); _endthread(); } -void -PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void -PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void -do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); -} - -void -PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void -PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. This is implemented with an event semaphore and critical * sections to make it behave more like a posix mutex than its OS/2 Index: Python/thread_nt.h =================================================================== --- Python/thread_nt.h (revision 68351) +++ Python/thread_nt.h (working copy) @@ -176,55 +176,15 @@ return GetCurrentThreadId(); } -static void -do_PyThread_exit_thread(int no_cleanup) +void +PyThread_exit_thread(void) { dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident())); if (!initialized) - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); _endthread(); } -void -PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void -PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void -do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); -} - -void -PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void -PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. It has too be implemented as semaphores. * I [Dag] tried to implement it with mutex but I could find a way to Index: Python/thread_pth.h =================================================================== --- Python/thread_pth.h (revision 68351) +++ Python/thread_pth.h (working copy) @@ -74,49 +74,14 @@ return (long) *(long *) &threadid; } -static void do_PyThread_exit_thread(int no_cleanup) +void PyThread_exit_thread(void) { dprintf(("PyThread_exit_thread called\n")); if (!initialized) { - if (no_cleanup) - _exit(0); - else - exit(0); + exit(0); } } -void PyThread_exit_thread(void) -{ - do_PyThread_exit_thread(0); -} - -void PyThread__exit_thread(void) -{ - do_PyThread_exit_thread(1); -} - -#ifndef NO_EXIT_PROG -static void do_PyThread_exit_prog(int status, int no_cleanup) -{ - dprintf(("PyThread_exit_prog(%d) called\n", status)); - if (!initialized) - if (no_cleanup) - _exit(status); - else - exit(status); -} - -void PyThread_exit_prog(int status) -{ - do_PyThread_exit_prog(status, 0); -} - -void PyThread__exit_prog(int status) -{ - do_PyThread_exit_prog(status, 1); -} -#endif /* NO_EXIT_PROG */ - /* * Lock support. */ Index: Include/pythread.h =================================================================== --- Include/pythread.h (revision 68351) +++ Include/pythread.h (working copy) @@ -2,9 +2,6 @@ #ifndef Py_PYTHREAD_H #define Py_PYTHREAD_H -#define NO_EXIT_PROG /* don't define PyThread_exit_prog() */ - /* (the result is no use of signals on SGI) */ - typedef void *PyThread_type_lock; typedef void *PyThread_type_sema; @@ -15,7 +12,6 @@ PyAPI_FUNC(void) PyThread_init_thread(void); PyAPI_FUNC(long) PyThread_start_new_thread(void (*)(void *), void *); PyAPI_FUNC(void) PyThread_exit_thread(void); -PyAPI_FUNC(void) PyThread__PyThread_exit_thread(void); PyAPI_FUNC(long) PyThread_get_thread_ident(void); PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void); @@ -28,11 +24,6 @@ PyAPI_FUNC(size_t) PyThread_get_stacksize(void); PyAPI_FUNC(int) PyThread_set_stacksize(size_t); -#ifndef NO_EXIT_PROG -PyAPI_FUNC(void) PyThread_exit_prog(int); -PyAPI_FUNC(void) PyThread__PyThread_exit_prog(int); -#endif - /* Thread Local Storage (TLS) API */ PyAPI_FUNC(int) PyThread_create_key(void); PyAPI_FUNC(void) PyThread_delete_key(int); Index: PC/os2emx/python27.def =================================================================== --- PC/os2emx/python27.def (revision 68351) +++ PC/os2emx/python27.def (working copy) @@ -1161,7 +1161,6 @@ "PyThread_delete_key" "PyThread_set_key_value" "PyThread_get_key_value" - "PyThread__exit_thread" ; From python27_s.lib(gcmodule) ; "initgc" Index: PC/os2vacpp/python.def =================================================================== --- PC/os2vacpp/python.def (revision 68351) +++ PC/os2vacpp/python.def (working copy) @@ -368,7 +368,6 @@ PyThreadState_GetDict PyThreadState_New PyThreadState_Swap - PyThread__exit_thread PyThread_acquire_lock PyThread_allocate_lock PyThread_allocate_sema Index: Modules/threadmodule.c =================================================================== --- Modules/threadmodule.c (revision 68351) +++ Modules/threadmodule.c (working copy) @@ -539,18 +539,6 @@ A subthread can use this function to interrupt the main thread." ); -#ifndef NO_EXIT_PROG -static PyObject * -thread_PyThread_exit_prog(PyObject *self, PyObject *args) -{ - int sts; - if (!PyArg_ParseTuple(args, "i:exit_prog", &sts)) - return NULL; - Py_Exit(sts); /* Calls PyThread_exit_prog(sts) or _PyThread_exit_prog(sts) */ - for (;;) { } /* Should not be reached */ -} -#endif - static lockobject *newlockobject(void); static PyObject * @@ -664,10 +652,6 @@ {"stack_size", (PyCFunction)thread_stack_size, METH_VARARGS, stack_size_doc}, -#ifndef NO_EXIT_PROG - {"exit_prog", (PyCFunction)thread_PyThread_exit_prog, - METH_VARARGS}, -#endif {NULL, NULL} /* sentinel */ };