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 61bbc5e..d657e9e 100644
--- a/Modules/Setup.in
+++ b/Modules/Setup.in
@@ -53,10 +53,7 @@
# 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 @@
# 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 @@
# 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 e485936..9f0bec9 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -1033,6 +1033,8 @@
/* -------------------------------------------------------*/
+static PyObject *ModDict;
+
static PyObject *
PyCurses_InitScr(self, args)
PyObject * self;
@@ -1052,7 +1054,7 @@
/* 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 @@
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 1f702d3..63a3bf9 100644
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -1092,8 +1092,9 @@
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 309af8e..ed441fd 100644
--- a/Modules/signalmodule.c
+++ b/Modules/signalmodule.c
@@ -32,6 +32,8 @@
#include <signal.h>
#include <errno.h>
+#include "rename1.h"
+
#ifndef SIG_ERR
#define SIG_ERR ((RETSIGTYPE (*)())-1)
#endif
@@ -68,147 +70,150 @@
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;
-}
-
-static object *
-signal_pause(self, args)
- object *self; /* Not used */
- object *args;
-{
- if (!getnoarg(args))
- return NULL;
- pause();
- 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_signal(self, args)
- object *self; /* Not used */
- object *args;
+PySignal_Pause(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
{
- object *obj;
- int sig_num;
- object *old_handler;
- RETSIGTYPE (*func)();
- if (!getargs(args, "(iO)", &sig_num, &obj))
+ if (!PyArg_NoArgs(args))
return NULL;
+ BGN_SAVE
+ pause();
+ END_SAVE
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *
+PySignal_Signal(self, args)
+ PyObject *self; /* Not used */
+ PyObject *args;
+{
+ PyObject *obj;
+ int sig_num;
+ PyObject *old_handler;
+ RETSIGTYPE (*func)();
+ 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 @@
#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);
+ d = PyModule_GetDict(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,
+ 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 @@
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 8cacfb2..6f50fc3 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -63,6 +63,7 @@
- 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 @@
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
+#include <fcntl.h>
#else
#include <winsock.h>
#endif
@@ -441,6 +443,34 @@
#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;
@@ -813,6 +843,9 @@
#if 0
{"allowbroadcast", (method)sock_allowbroadcast},
#endif
+#ifndef NT
+ {"setblocking", (method)sock_setblocking},
+#endif
{"setsockopt", (method)sock_setsockopt},
{"getsockopt", (method)sock_getsockopt},
{"bind", (method)sock_bind},