Setup.in: added tkinter; rearranged the definition of PYTHONPATH so

that the module-specific components are in the section for that
module.

cursesmodule.c: patched it so it actually works.

tkintermodule.c: call Py_AtExit instead of atexit().

signalmodule.c: converted to new naming style; added
BGN/END SAVE around pause() call.

socketmodule.c: added setblocking() after Tommy Burnette.

diff --git a/Modules/Setup.in b/Modules/Setup.in
index 61bbc5ed0f145c3ecc850dcf93927f714f97fa8f..d657e9e8e0ce1160df13fa99e56ec38438bc8144 100644 (file)
--- a/Modules/Setup.in
+++ b/Modules/Setup.in
@@ -53,10 +53,7 @@ TESTPATH=:$(DESTLIB)/test
 # Enable this for Sun systems
 #ARCHPATH=:$(DESTLIB)/sun4
 
-# Enable this if stdwin installed
-#STDWINPATH=:$(DESTLIB)/stdwin
-
-PYTHONPATH=.:$(DESTLIB)$(TESTPATH)$(ARCHPATH)$(STDWINPATH)
+PYTHONPATH=.:$(DESTLIB)$(TESTPATH)$(ARCHPATH)$(STDWINPATH)$(TKPATH)
 
 
 # Modules that should always be present (non UNIX dependent)
@@ -104,12 +101,13 @@ rgbimg rgbimgmodule.c   # Read SGI RGB image files (but coded portably)
 # ftp://ftp.cwi.nl/pub/stdwin.  The STDWIN variable must point to the
 # STDWIN toplevel directory.  The ARCH variable must be set to the
 # architecture identifier used to build STDWIN.  NB if you combine this
-# with the gl module on an SGI machine, you should replace "-lX11" with
-# "-lX11_s".
+# with the gl module on an SGI IRIX 4 machine, you should replace
+"-lX11" with "-lX11_s".
 
 #STDWIN=/ufs/guido/src/stdwin
 #ARCH=???
 #stdwin stdwinmodule.c -I$(STDWIN)/H $(STDWIN)/Build/$(ARCH)/x11/lib/lib.a -lX11
+#STDWINPATH=:$(DESTLIB)/stdwin
 
 
 # The md5 module implements the RSA Data Security, Inc. MD5
@@ -174,8 +172,18 @@ md5 md5module.c md5c.c
 # timing timingmodule.c
 
 
+# Steen Lumholt's tkinter module.  For use with plain Tk, use the
+# first line.  For use with extended Tk, edit tkappinit.c, add
+# appropriate -DWITH_... and libraries/objects to the second line, and
+# use that.  In all cases also enable the last line (TKPATH).
+
+#tkinter tkintermodule.c -I/usr/local/include -L/usr/local/lib -ltk -ltcl -lX11
+#tkinter tkintermodule.c tkappinit.c -DWITH_APPINIT -I/usr/local/include -L/usr/local/lib -ltk -ltcl -lX11
+#TKPATH=:$(DESTLIB)/tkinter
+
+
 # Lance Ellinghouse's modules
-rotor rotormodule.c            # enigma-inspired en-, decryption
+rotor rotormodule.c            # enigma-inspired encryption
 # syslog syslogmodule.c                # syslog daemon interface
 # curses cursesmodule.c -lcurses -ltermcap     # guess what?
 

diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index e485936d4f69dbaa87006226af4a55ebf150fb63..9f0bec9c65121c89484c8c46a07b3328df59b481 100644 (file)
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -1033,6 +1033,8 @@ static PyTypeObject PyCursesPad_Type = {
 
 /* -------------------------------------------------------*/
 
+static PyObject *ModDict;
+
 static PyObject * 
 PyCurses_InitScr(self, args)
      PyObject * self;
@@ -1052,7 +1054,7 @@ PyCurses_InitScr(self, args)
 
 /* This was moved from initcurses() because core dumped on SGI */
 #define SetDictChar(string,ch) \
-       PyDict_SetItemString(d,string,PyInt_FromLong(ch));
+       PyDict_SetItemString(ModDict,string,PyInt_FromLong(ch));
  
        /* Here are some graphic symbols you can use */
         SetDictChar("ACS_ULCORNER",(ACS_ULCORNER));
@@ -1387,6 +1389,7 @@ initcurses()
        Py_INCREF(PyCurses_ERR);
        /* Add some symbolic constants to the module */
        d = PyModule_GetDict(m);
+       ModDict = d; /* For PyCurses_InitScr */
 
        /* Make the version available */
        PyDict_SetItemString(d,"version",

diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index 1f702d39d9a553b519ba140ab5ca895ab3f9b361..63a3bf96c9f880a3051aace02554b1d903d7a34a 100644 (file)
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -1092,8 +1092,9 @@ PyInit_tkinter ()
   if (!inited)
     {
       inited = 1;
-      if (atexit (Tkinter_Cleanup))
-       PyErr_SetFromErrno (Tkinter_TclError);
+      if (Py_AtExit (Tkinter_Cleanup) != 0)
+       fprintf(stderr,
+               "Tkinter: warning: cleanup procedure not registered\n");
     }
 
   if (PyErr_Occurred ())

diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c
index 309af8e0cb719ac7c666240d7b9b23ea9b0e87b2..ed441fd5a288ad6c41d793293d5749886d15fb7c 100644 (file)
--- a/Modules/signalmodule.c
+++ b/Modules/signalmodule.c
@@ -32,6 +32,8 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <signal.h>
 #include <errno.h>
 
+#include "rename1.h"
+
 #ifndef SIG_ERR
 #define SIG_ERR ((RETSIGTYPE (*)())-1)
 #endif
@@ -68,147 +70,150 @@ static long main_thread;
 static pid_t main_pid;
 #endif
 
-struct signalhandler_list {
+struct PySignal_SignalArrayStruct {
        int     tripped;
-       object *func;
+       PyObject *func;
 };
 
-static struct signalhandler_list sig_list[NSIG];
-static int tripped = 0;                /* Speed up sigcheck() when none tripped */
+static struct PySignal_SignalArrayStruct PySignal_SignalHandlerArray[NSIG];
+static int PySignal_IsTripped = 0; /* Speed up sigcheck() when none tripped */
 
-static object *sig_dfl_object;
-static object *sig_ign_object;
-static object *default_int_handler_object;
+static PyObject *PySignal_SignalDefaultHandler;
+static PyObject *PySignal_SignalIgnoreHandler;
+static PyObject *PySignal_DefaultIntHandler;
 
-static object *
-default_int_handler(self, arg)
-     object *self;
-     object *arg;
+static PyObject *
+PySignal_CDefaultIntHandler(self, arg)
+       PyObject *self;
+       PyObject *arg;
 {
-       err_set(KeyboardInterrupt);
-       return NULL;
+       PyErr_SetNone(PyExc_KeyboardInterrupt);
+       return (PyObject *)NULL;
 }
 
 static RETSIGTYPE
-signal_handler(sig_num)
-     int sig_num;
+PySignal_Handler(sig_num)
+       int sig_num;
 {
 #ifdef WITH_THREAD
        /* See NOTES section above */
        if (getpid() == main_pid) {
 #endif
-               tripped++;
-               sig_list[sig_num].tripped = 1;
+               PySignal_IsTripped++;
+               PySignal_SignalHandlerArray[sig_num].tripped = 1;
 #ifdef WITH_THREAD
        }
 #endif
-       (void *)signal(sig_num, &signal_handler);
+       (void *)signal(sig_num, &PySignal_Handler);
 }
  
-static object *
-signal_alarm(self, args)
-       object *self; /* Not used */
-       object *args;
+
+static PyObject *
+PySignal_Alarm(self, args)
+       PyObject *self; /* Not used */
+       PyObject *args;
 {
        int t;
-       if (!getargs(args, "i", &t))
-               return NULL;
-       alarm(t);
-       INCREF(None);
-       return None;
+       int rtn;
+       if (!PyArg_Parse(args, "i", &t))
+               return (PyObject *)NULL;
+       /* alarm() returns the number of seconds remaining */
+       return PyInt_FromLong(alarm(t));
 }
- 
+
 static object *
-signal_pause(self, args)
-       object *self; /* Not used */
-       object *args;
+PySignal_Pause(self, args)
+       PyObject *self; /* Not used */
+       PyObject *args;
 {
-       if (!getnoarg(args))
+       if (!PyArg_NoArgs(args))
                return NULL;
+       BGN_SAVE
        pause();
-       INCREF(None);
-       return None;
+       END_SAVE
+       Py_INCREF(Py_None);
+       return Py_None;
 }
 
-static object *
-signal_signal(self, args)
-       object *self; /* Not used */
-       object *args;
+static PyObject *
+PySignal_Signal(self, args)
+       PyObject *self; /* Not used */
+       PyObject *args;
 {
-        object *obj;
+       PyObject *obj;
        int sig_num;
-       object *old_handler;
+       PyObject *old_handler;
        RETSIGTYPE (*func)();
-       if (!getargs(args, "(iO)", &sig_num, &obj))
-               return NULL;
+       if (!PyArg_Parse(args, "(iO)", &sig_num, &obj))
+               return (PyObject *)NULL;
 #ifdef WITH_THREAD
        if (get_thread_ident() != main_thread) {
-               err_setstr(ValueError, "signal only works in main thread");
-               return NULL;
+               PyErr_SetString(PyExc_ValueError, "signal only works in main thread");
+               return (PyObject *)NULL;
        }
 #endif
        if (sig_num < 1 || sig_num >= NSIG) {
-               err_setstr(ValueError, "signal number out of range");
-               return NULL;
+               PyErr_SetString(PyExc_ValueError, "signal number out of range");
+               return (PyObject *)NULL;
        }
-       if (obj == sig_ign_object)
+       if (obj == PySignal_SignalIgnoreHandler)
                func = SIG_IGN;
-       else if (obj == sig_dfl_object)
+       else if (obj == PySignal_SignalDefaultHandler)
                func = SIG_DFL;
-       else if (!is_methodobject(obj) &&
-                !is_funcobject(obj) &&
-                !is_instancemethodobject(obj)) {
-               err_setstr(TypeError,
+       else if (!PyCFunction_Check(obj) &&
+                !PyFunction_Check(obj) &&
+                !PyMethod_Check(obj)) {
+               PyErr_SetString(PyExc_TypeError,
 "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object");
-               return NULL;
+               return (PyObject *)NULL;
        }
        else
-               func = signal_handler;
+               func = PySignal_Handler;
        if (signal(sig_num, func) == SIG_ERR) {
-               err_errno(RuntimeError);
-               return NULL;
+               PyErr_SetFromErrno(PyExc_RuntimeError);
+               return (PyObject *)NULL;
        }
-       old_handler = sig_list[sig_num].func;
-       sig_list[sig_num].tripped = 0;
-       INCREF(obj);
-       sig_list[sig_num].func = obj;
+       old_handler = PySignal_SignalHandlerArray[sig_num].func;
+       PySignal_SignalHandlerArray[sig_num].tripped = 0;
+       Py_INCREF(obj);
+       PySignal_SignalHandlerArray[sig_num].func = obj;
        return old_handler;
 }
 
-static object *
-signal_getsignal(self, args)
-       object *self; /* Not used */
-       object *args;
+static PyObject *
+PySignal_GetSignal(self, args)
+       PyObject *self; /* Not used */
+       PyObject *args;
 {
        int sig_num;
-       object *old_handler;
-       if (!getargs(args, "i", &sig_num))
-               return NULL;
+       PyObject *old_handler;
+       if (!PyArg_Parse(args, "i", &sig_num))
+               return (PyObject *)NULL;
        if (sig_num < 1 || sig_num >= NSIG) {
-               err_setstr(ValueError, "signal number out of range");
-               return NULL;
+               PyErr_SetString(PyExc_ValueError, "signal number out of range");
+               return (PyObject *)NULL;
        }
-       old_handler = sig_list[sig_num].func;
-       INCREF(old_handler);
+       old_handler = PySignal_SignalHandlerArray[sig_num].func;
+       Py_INCREF(old_handler);
        return old_handler;
 }
 
 
 /* List of functions defined in the module */
 
-static struct methodlist signal_methods[] = {
-       {"alarm",       signal_alarm},
-        {"signal",     signal_signal},
-        {"getsignal",  signal_getsignal},
-       {"pause",       signal_pause},
+static PyMethodDef PySignal_methods[] = {
+       {"alarm",       PySignal_Alarm},
+       {"signal",      PySignal_Signal},
+       {"getsignal",   PySignal_GetSignal},
+       {"pause",       PySignal_Pause},
        {NULL,          NULL}           /* sentinel */
 };
 
 void
 initsignal()
 {
-       object *m, *d, *x;
-       object *b_dict;
+       PyObject *m, *d, *x;
+       PyObject *b_dict;
        int i;
 
 #ifdef WITH_THREAD
@@ -217,218 +222,218 @@ initsignal()
 #endif
 
        /* Create the module and add the functions */
-       m = initmodule("signal", signal_methods);
+       m = Py_InitModule("signal", PySignal_methods);
 
        /* Add some symbolic constants to the module */
-       d = getmoduledict(m);
-
-       sig_dfl_object = newintobject((long)SIG_DFL);
-       dictinsert(d, "SIG_DFL", sig_dfl_object);
-       sig_ign_object = newintobject((long)SIG_IGN);
-       dictinsert(d, "SIG_IGN", sig_ign_object);
-       dictinsert(d, "NSIG", newintobject((long)NSIG));
-       default_int_handler_object = newmethodobject("default_int_handler",
-                                                    default_int_handler,
-                                                    (object *)NULL,
+       d = PyModule_GetDict(m);
+
+       PySignal_SignalDefaultHandler = PyInt_FromLong((long)SIG_DFL);
+       PyDict_SetItemString(d, "SIG_DFL", PySignal_SignalDefaultHandler);
+       PySignal_SignalIgnoreHandler = PyInt_FromLong((long)SIG_IGN);
+       PyDict_SetItemString(d, "SIG_IGN", PySignal_SignalIgnoreHandler);
+       PyDict_SetItemString(d, "NSIG", PyInt_FromLong((long)NSIG));
+       PySignal_DefaultIntHandler = PyCFunction_New("default_int_handler",
+                                                    PySignal_CDefaultIntHandler,
+                                                    (PyObject *)NULL,
                                                     0);
-       dictinsert(d, "default_int_handler", default_int_handler_object);
+       PyDict_SetItemString(d, "default_int_handler", PySignal_DefaultIntHandler);
 
-       sig_list[0].tripped = 0;
+       PySignal_SignalHandlerArray[0].tripped = 0;
        for (i = 1; i < NSIG; i++) {
                RETSIGTYPE (*t)();
                t = signal(i, SIG_IGN);
                signal(i, t);
-               sig_list[i].tripped = 0;
+               PySignal_SignalHandlerArray[i].tripped = 0;
                if (t == SIG_DFL)
-                       sig_list[i].func = sig_dfl_object;
+                       PySignal_SignalHandlerArray[i].func = PySignal_SignalDefaultHandler;
                else if (t == SIG_IGN)
-                       sig_list[i].func = sig_ign_object;
+                       PySignal_SignalHandlerArray[i].func = PySignal_SignalIgnoreHandler;
                else
-                       sig_list[i].func = None; /* None of our business */
-               INCREF(sig_list[i].func);
+                       PySignal_SignalHandlerArray[i].func = Py_None; /* None of our business */
+               Py_INCREF(PySignal_SignalHandlerArray[i].func);
        }
-       if (sig_list[SIGINT].func == sig_dfl_object) {
+       if (PySignal_SignalHandlerArray[SIGINT].func == PySignal_SignalDefaultHandler) {
                /* Install default int handler */
-               DECREF(sig_list[SIGINT].func);
-               sig_list[SIGINT].func = default_int_handler_object;
-               INCREF(default_int_handler_object);
-               signal(SIGINT, &signal_handler);
+               Py_DECREF(PySignal_SignalHandlerArray[SIGINT].func);
+               PySignal_SignalHandlerArray[SIGINT].func = PySignal_DefaultIntHandler;
+               Py_INCREF(PySignal_DefaultIntHandler);
+               signal(SIGINT, &PySignal_Handler);
        }
 
 #ifdef SIGHUP
-       x = newintobject(SIGHUP);
-       dictinsert(d, "SIGHUP", x);
+       x = PyInt_FromLong(SIGHUP);
+       PyDict_SetItemString(d, "SIGHUP", x);
 #endif
 #ifdef SIGINT
-       x = newintobject(SIGINT);
-       dictinsert(d, "SIGINT", x);
+       x = PyInt_FromLong(SIGINT);
+       PyDict_SetItemString(d, "SIGINT", x);
 #endif
 #ifdef SIGQUIT
-       x = newintobject(SIGQUIT);
-       dictinsert(d, "SIGQUIT", x);
+       x = PyInt_FromLong(SIGQUIT);
+       PyDict_SetItemString(d, "SIGQUIT", x);
 #endif
 #ifdef SIGILL
-       x = newintobject(SIGILL);
-       dictinsert(d, "SIGILL", x);
+       x = PyInt_FromLong(SIGILL);
+       PyDict_SetItemString(d, "SIGILL", x);
 #endif
 #ifdef SIGTRAP
-       x = newintobject(SIGTRAP);
-       dictinsert(d, "SIGTRAP", x);
+       x = PyInt_FromLong(SIGTRAP);
+       PyDict_SetItemString(d, "SIGTRAP", x);
 #endif
 #ifdef SIGIOT
-       x = newintobject(SIGIOT);
-       dictinsert(d, "SIGIOT", x);
+       x = PyInt_FromLong(SIGIOT);
+       PyDict_SetItemString(d, "SIGIOT", x);
 #endif
 #ifdef SIGABRT
-       x = newintobject(SIGABRT);
-       dictinsert(d, "SIGABRT", x);
+       x = PyInt_FromLong(SIGABRT);
+       PyDict_SetItemString(d, "SIGABRT", x);
 #endif
 #ifdef SIGEMT
-       x = newintobject(SIGEMT);
-       dictinsert(d, "SIGEMT", x);
+       x = PyInt_FromLong(SIGEMT);
+       PyDict_SetItemString(d, "SIGEMT", x);
 #endif
 #ifdef SIGFPE
-       x = newintobject(SIGFPE);
-       dictinsert(d, "SIGFPE", x);
+       x = PyInt_FromLong(SIGFPE);
+       PyDict_SetItemString(d, "SIGFPE", x);
 #endif
 #ifdef SIGKILL
-       x = newintobject(SIGKILL);
-       dictinsert(d, "SIGKILL", x);
+       x = PyInt_FromLong(SIGKILL);
+       PyDict_SetItemString(d, "SIGKILL", x);
 #endif
 #ifdef SIGBUS
-       x = newintobject(SIGBUS);
-       dictinsert(d, "SIGBUS", x);
+       x = PyInt_FromLong(SIGBUS);
+       PyDict_SetItemString(d, "SIGBUS", x);
 #endif
 #ifdef SIGSEGV
-       x = newintobject(SIGSEGV);
-       dictinsert(d, "SIGSEGV", x);
+       x = PyInt_FromLong(SIGSEGV);
+       PyDict_SetItemString(d, "SIGSEGV", x);
 #endif
 #ifdef SIGSYS
-       x = newintobject(SIGSYS);
-       dictinsert(d, "SIGSYS", x);
+       x = PyInt_FromLong(SIGSYS);
+       PyDict_SetItemString(d, "SIGSYS", x);
 #endif
 #ifdef SIGPIPE
-       x = newintobject(SIGPIPE);
-       dictinsert(d, "SIGPIPE", x);
+       x = PyInt_FromLong(SIGPIPE);
+       PyDict_SetItemString(d, "SIGPIPE", x);
 #endif
 #ifdef SIGALRM
-       x = newintobject(SIGALRM);
-       dictinsert(d, "SIGALRM", x);
+       x = PyInt_FromLong(SIGALRM);
+       PyDict_SetItemString(d, "SIGALRM", x);
 #endif
 #ifdef SIGTERM
-       x = newintobject(SIGTERM);
-       dictinsert(d, "SIGTERM", x);
+       x = PyInt_FromLong(SIGTERM);
+       PyDict_SetItemString(d, "SIGTERM", x);
 #endif
 #ifdef SIGUSR1
-       x = newintobject(SIGUSR1);
-       dictinsert(d, "SIGUSR1", x);
+       x = PyInt_FromLong(SIGUSR1);
+       PyDict_SetItemString(d, "SIGUSR1", x);
 #endif
 #ifdef SIGUSR2
-       x = newintobject(SIGUSR2);
-       dictinsert(d, "SIGUSR2", x);
+       x = PyInt_FromLong(SIGUSR2);
+       PyDict_SetItemString(d, "SIGUSR2", x);
 #endif
 #ifdef SIGCLD
-       x = newintobject(SIGCLD);
-       dictinsert(d, "SIGCLD", x);
+       x = PyInt_FromLong(SIGCLD);
+       PyDict_SetItemString(d, "SIGCLD", x);
 #endif
 #ifdef SIGCHLD
-       x = newintobject(SIGCHLD);
-       dictinsert(d, "SIGCHLD", x);
+       x = PyInt_FromLong(SIGCHLD);
+       PyDict_SetItemString(d, "SIGCHLD", x);
 #endif
 #ifdef SIGPWR
-       x = newintobject(SIGPWR);
-       dictinsert(d, "SIGPWR", x);
+       x = PyInt_FromLong(SIGPWR);
+       PyDict_SetItemString(d, "SIGPWR", x);
 #endif
 #ifdef SIGIO
-       x = newintobject(SIGIO);
-       dictinsert(d, "SIGIO", x);
+       x = PyInt_FromLong(SIGIO);
+       PyDict_SetItemString(d, "SIGIO", x);
 #endif
 #ifdef SIGURG
-       x = newintobject(SIGURG);
-       dictinsert(d, "SIGURG", x);
+       x = PyInt_FromLong(SIGURG);
+       PyDict_SetItemString(d, "SIGURG", x);
 #endif
 #ifdef SIGWINCH
-       x = newintobject(SIGWINCH);
-       dictinsert(d, "SIGWINCH", x);
+       x = PyInt_FromLong(SIGWINCH);
+       PyDict_SetItemString(d, "SIGWINCH", x);
 #endif
 #ifdef SIGPOLL
-       x = newintobject(SIGPOLL);
-       dictinsert(d, "SIGPOLL", x);
+       x = PyInt_FromLong(SIGPOLL);
+       PyDict_SetItemString(d, "SIGPOLL", x);
 #endif
 #ifdef SIGSTOP
-       x = newintobject(SIGSTOP);
-       dictinsert(d, "SIGSTOP", x);
+       x = PyInt_FromLong(SIGSTOP);
+       PyDict_SetItemString(d, "SIGSTOP", x);
 #endif
 #ifdef SIGTSTP
-       x = newintobject(SIGTSTP);
-       dictinsert(d, "SIGTSTP", x);
+       x = PyInt_FromLong(SIGTSTP);
+       PyDict_SetItemString(d, "SIGTSTP", x);
 #endif
 #ifdef SIGCONT
-       x = newintobject(SIGCONT);
-       dictinsert(d, "SIGCONT", x);
+       x = PyInt_FromLong(SIGCONT);
+       PyDict_SetItemString(d, "SIGCONT", x);
 #endif
 #ifdef SIGTTIN
-       x = newintobject(SIGTTIN);
-       dictinsert(d, "SIGTTIN", x);
+       x = PyInt_FromLong(SIGTTIN);
+       PyDict_SetItemString(d, "SIGTTIN", x);
 #endif
 #ifdef SIGTTOU
-       x = newintobject(SIGTTOU);
-       dictinsert(d, "SIGTTOU", x);
+       x = PyInt_FromLong(SIGTTOU);
+       PyDict_SetItemString(d, "SIGTTOU", x);
 #endif
 #ifdef SIGVTALRM
-       x = newintobject(SIGVTALRM);
-       dictinsert(d, "SIGVTALRM", x);
+       x = PyInt_FromLong(SIGVTALRM);
+       PyDict_SetItemString(d, "SIGVTALRM", x);
 #endif
 #ifdef SIGPROF
-       x = newintobject(SIGPROF);
-       dictinsert(d, "SIGPROF", x);
+       x = PyInt_FromLong(SIGPROF);
+       PyDict_SetItemString(d, "SIGPROF", x);
 #endif
 #ifdef SIGCPU
-       x = newintobject(SIGCPU);
-       dictinsert(d, "SIGCPU", x);
+       x = PyInt_FromLong(SIGCPU);
+       PyDict_SetItemString(d, "SIGCPU", x);
 #endif
 #ifdef SIGFSZ
-       x = newintobject(SIGFSZ);
-       dictinsert(d, "SIGFSZ", x);
+       x = PyInt_FromLong(SIGFSZ);
+       PyDict_SetItemString(d, "SIGFSZ", x);
 #endif
        /* Check for errors */
-       if (err_occurred())
-               fatal("can't initialize module signal");
+       if (PyErr_Occurred())
+               Py_FatalError("can't initialize module signal");
 }
 
 int
 sigcheck()
 {
        int i;
-       object *f;
-       if (!tripped)
+       PyObject *f;
+       if (!PySignal_IsTripped)
                return 0;
 #ifdef WITH_THREAD
        if (get_thread_ident() != main_thread)
                return 0;
 #endif
        f = getframe();
-       if (f == NULL)
-               f = None;
+       if (f == (PyObject *)NULL)
+               f = Py_None;
        for (i = 1; i < NSIG; i++) {
-               if (sig_list[i].tripped) {
-                       object *arglist, *result;
-                       sig_list[i].tripped = 0;
-                       arglist = mkvalue("(iO)", i, f);
-                       if (arglist == NULL)
-                               result = NULL;
+               if (PySignal_SignalHandlerArray[i].tripped) {
+                       PyObject *arglist, *result;
+                       PySignal_SignalHandlerArray[i].tripped = 0;
+                       arglist = Py_BuildValue("(iO)", i, f);
+                       if (arglist == (PyObject *)NULL)
+                               result = (PyObject *)NULL;
                        else {
-                               result = call_object(sig_list[i].func,arglist);
-                               DECREF(arglist);
+                               result = PyEval_CallObject(PySignal_SignalHandlerArray[i].func,arglist);
+                               Py_DECREF(arglist);
                        }
-                       if (result == NULL) {
+                       if (result == (PyObject *)NULL) {
                                return 1;
                        } else {
-                               DECREF(result);
+                               Py_DECREF(result);
                        }
                }
        }
-       tripped = 0;
+       PySignal_IsTripped = 0;
        return 0;
 }
 
@@ -443,12 +448,12 @@ initintr()
 int
 intrcheck()
 {
-       if (sig_list[SIGINT].tripped) {
+       if (PySignal_SignalHandlerArray[SIGINT].tripped) {
 #ifdef WITH_THREAD
                if (get_thread_ident() != main_thread)
                        return 0;
 #endif
-               sig_list[SIGINT].tripped = 0;
+               PySignal_SignalHandlerArray[SIGINT].tripped = 0;
                return 1;
        }
        return 0;

diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 8cacfb2793ff5b6f573ca79d0b27768c841cf6af..6f50fc3cca298c77eacd3d95b64f9581fc829edc 100644 (file)
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -63,6 +63,7 @@ Socket methods:
 - s.recvfrom(nbytes [,flags]) --> string, sockaddr
 - s.send(string [,flags]) --> nbytes
 - s.sendto(string, [flags,] sockaddr) --> nbytes
+- s.setblocking(1 | 0) --> None
 - s.shutdown(how) --> None
 - s.close() --> None
 
@@ -80,6 +81,7 @@ Socket methods:
 #include <netdb.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <fcntl.h>
 #else
 #include <winsock.h>
 #endif
@@ -441,6 +443,34 @@ BUILD_FUNC_DEF_2(sock_allowbroadcast,sockobject *,s, object *,args)
 #endif
 
 
+#ifndef NT
+
+/* s.setblocking(1 | 0) method */
+
+static object *
+sock_setblocking(s, args)
+       sockobject *s;
+       object *args;
+{
+       int block;
+       int delay_flag;
+       if (!getintarg(args, &block))
+               return NULL;
+       BGN_SAVE
+       delay_flag = fcntl (s->sock_fd, F_GETFL, 0);
+       if (block)
+               delay_flag &= (~O_NDELAY);
+       else
+               delay_flag |= O_NDELAY;
+       fcntl (s->sock_fd, F_SETFL, delay_flag);
+       END_SAVE
+
+       INCREF(None);
+       return None;
+}
+#endif
+
+
 /* s.setsockopt() method.
    With an integer third argument, sets an integer option.
    With a string third argument, sets an option from a buffer;
@@ -812,6 +842,9 @@ static struct methodlist sock_methods[] = {
        {"accept",              (method)sock_accept},
 #if 0
        {"allowbroadcast",      (method)sock_allowbroadcast},
+#endif
+#ifndef NT
+       {"setblocking",         (method)sock_setblocking},
 #endif
        {"setsockopt",          (method)sock_setsockopt},
        {"getsockopt",          (method)sock_getsockopt},