Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Use the PyModule_Add*() APIs instead of manipulating the module dict 

directly.
This commit is contained in:
Fred Drake 2002-04-01 14:53:37 +00:00
parent 9bb7432114
commit 4baedc1d9b
5 changed files with 280 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
Modules/selectmodule.c
View File

@ -657,34 +657,35 @@ insint(PyObject *d, char *name, int value)
DL_EXPORT(void)
initselect(void)
{
PyObject *m, *d;
PyObject *m;
m = Py_InitModule3("select", select_methods, module_doc);
d = PyModule_GetDict(m);
SelectError = PyErr_NewException("select.error", NULL, NULL);
PyDict_SetItemString(d, "error", SelectError);
Py_INCREF(SelectError);
PyModule_AddObject(m, "error", SelectError);
#ifdef HAVE_POLL
poll_Type.ob_type = &PyType_Type;
insint(d, "POLLIN", POLLIN);
insint(d, "POLLPRI", POLLPRI);
insint(d, "POLLOUT", POLLOUT);
insint(d, "POLLERR", POLLERR);
insint(d, "POLLHUP", POLLHUP);
insint(d, "POLLNVAL", POLLNVAL);
PyModule_AddIntConstant(m, "POLLIN", POLLIN);
PyModule_AddIntConstant(m, "POLLPRI", POLLPRI);
PyModule_AddIntConstant(m, "POLLOUT", POLLOUT);
PyModule_AddIntConstant(m, "POLLERR", POLLERR);
PyModule_AddIntConstant(m, "POLLHUP", POLLHUP);
PyModule_AddIntConstant(m, "POLLNVAL", POLLNVAL);
#ifdef POLLRDNORM
insint(d, "POLLRDNORM", POLLRDNORM);
PyModule_AddIntConstant(m, "POLLRDNORM", POLLRDNORM);
#endif
#ifdef POLLRDBAND
insint(d, "POLLRDBAND", POLLRDBAND);
PyModule_AddIntConstant(m, "POLLRDBAND", POLLRDBAND);
#endif
#ifdef POLLWRNORM
insint(d, "POLLWRNORM", POLLWRNORM);
PyModule_AddIntConstant(m, "POLLWRNORM", POLLWRNORM);
#endif
#ifdef POLLWRBAND
insint(d, "POLLWRBAND", POLLWRBAND);
PyModule_AddIntConstant(m, "POLLWRBAND", POLLWRBAND);
#endif
#ifdef POLLMSG
insint(d, "POLLMSG", POLLMSG);
PyModule_AddIntConstant(m, "POLLMSG", POLLMSG);
#endif
#endif /* HAVE_POLL */
}

418
Modules/socketmodule.c
View File

@ -2694,7 +2694,7 @@ for documentation.";
DL_EXPORT(void)
init_socket(void)
{
PyObject *m, *d;
PyObject *m;
#ifdef RISCOS
_kernel_swi_regs r;
r.r[0]=0;
@ -2718,588 +2718,604 @@ init_socket(void)
m = Py_InitModule3(PySocket_MODULE_NAME,
PySocket_methods,
module_doc);
d = PyModule_GetDict(m);
PySocket_Error = PyErr_NewException("socket.error", NULL, NULL);
if (PySocket_Error == NULL)
return;
PyDict_SetItemString(d, "error", PySocket_Error);
Py_INCREF(PySocket_Error);
PyModule_AddObject(m, "error", PySocket_Error);
PyH_Error = PyErr_NewException("socket.herror", PySocket_Error, NULL);
if (PyH_Error == NULL)
return;
PyDict_SetItemString(d, "herror", PyH_Error);
Py_INCREF(PyH_Error);
PyModule_AddObject(m, "herror", PyH_Error);
PyGAI_Error = PyErr_NewException("socket.gaierror", PySocket_Error,
NULL);
if (PyGAI_Error == NULL)
return;
PyDict_SetItemString(d, "gaierror", PyGAI_Error);
if (PyDict_SetItemString(d, "SocketType",
(PyObject *)&PySocketSock_Type) != 0)
Py_INCREF(PyGAI_Error);
PyModule_AddObject(m, "gaierror", PyGAI_Error);
Py_INCREF((PyObject *)&PySocketSock_Type);
if (PyModule_AddObject(m, "SocketType",
(PyObject *)&PySocketSock_Type) != 0)
return;
if (PyDict_SetItemString(d, "socket",
(PyObject *)&PySocketSock_Type) != 0)
Py_INCREF((PyObject *)&PySocketSock_Type);
if (PyModule_AddObject(m, "socket",
(PyObject *)&PySocketSock_Type) != 0)
return;
/* Export C API */
if (PyDict_SetItemString(d, PySocket_CAPI_NAME,
if (PyModule_AddObject(m, PySocket_CAPI_NAME,
PyCObject_FromVoidPtr((void *)&PySocketModuleAPI, NULL)
) != 0)
return;
/* Address families (we only support AF_INET and AF_UNIX) */
#ifdef AF_UNSPEC
insint(d, "AF_UNSPEC", AF_UNSPEC);
PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
#endif
insint(d, "AF_INET", AF_INET);
PyModule_AddIntConstant(m, "AF_INET", AF_INET);
#ifdef AF_INET6
insint(d, "AF_INET6", AF_INET6);
PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
#endif /* AF_INET6 */
#ifdef AF_UNIX
insint(d, "AF_UNIX", AF_UNIX);
PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
#endif /* AF_UNIX */
#ifdef AF_AX25
insint(d, "AF_AX25", AF_AX25); /* Amateur Radio AX.25 */
/* Amateur Radio AX.25 */
PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
#endif
#ifdef AF_IPX
insint(d, "AF_IPX", AF_IPX); /* Novell IPX */
PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
#endif
#ifdef AF_APPLETALK
insint(d, "AF_APPLETALK", AF_APPLETALK); /* Appletalk DDP */
/* Appletalk DDP */
PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
#endif
#ifdef AF_NETROM
insint(d, "AF_NETROM", AF_NETROM); /* Amateur radio NetROM */
/* Amateur radio NetROM */
PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
#endif
#ifdef AF_BRIDGE
insint(d, "AF_BRIDGE", AF_BRIDGE); /* Multiprotocol bridge */
/* Multiprotocol bridge */
PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
#endif
#ifdef AF_AAL5
insint(d, "AF_AAL5", AF_AAL5); /* Reserved for Werner's ATM */
/* Reserved for Werner's ATM */
PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
#endif
#ifdef AF_X25
insint(d, "AF_X25", AF_X25); /* Reserved for X.25 project */
/* Reserved for X.25 project */
PyModule_AddIntConstant(m, "AF_X25", AF_X25);
#endif
#ifdef AF_INET6
insint(d, "AF_INET6", AF_INET6); /* IP version 6 */
PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
#endif
#ifdef AF_ROSE
insint(d, "AF_ROSE", AF_ROSE); /* Amateur Radio X.25 PLP */
/* Amateur Radio X.25 PLP */
PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
#endif
#ifdef HAVE_NETPACKET_PACKET_H
insint(d, "AF_PACKET", AF_PACKET);
insint(d, "PF_PACKET", PF_PACKET);
insint(d, "PACKET_HOST", PACKET_HOST);
insint(d, "PACKET_BROADCAST", PACKET_BROADCAST);
insint(d, "PACKET_MULTICAST", PACKET_MULTICAST);
insint(d, "PACKET_OTHERHOST", PACKET_OTHERHOST);
insint(d, "PACKET_OUTGOING", PACKET_OUTGOING);
insint(d, "PACKET_LOOPBACK", PACKET_LOOPBACK);
insint(d, "PACKET_FASTROUTE", PACKET_FASTROUTE);
PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET);
PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
#endif
/* Socket types */
insint(d, "SOCK_STREAM", SOCK_STREAM);
insint(d, "SOCK_DGRAM", SOCK_DGRAM);
PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
#ifndef __BEOS__
/* We have incomplete socket support. */
insint(d, "SOCK_RAW", SOCK_RAW);
insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
insint(d, "SOCK_RDM", SOCK_RDM);
PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
#endif
#ifdef SO_DEBUG
insint(d, "SO_DEBUG", SO_DEBUG);
PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
#endif
#ifdef SO_ACCEPTCONN
insint(d, "SO_ACCEPTCONN", SO_ACCEPTCONN);
PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
#endif
#ifdef SO_REUSEADDR
insint(d, "SO_REUSEADDR", SO_REUSEADDR);
PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
#endif
#ifdef SO_KEEPALIVE
insint(d, "SO_KEEPALIVE", SO_KEEPALIVE);
PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
#endif
#ifdef SO_DONTROUTE
insint(d, "SO_DONTROUTE", SO_DONTROUTE);
PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
#endif
#ifdef SO_BROADCAST
insint(d, "SO_BROADCAST", SO_BROADCAST);
PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
#endif
#ifdef SO_USELOOPBACK
insint(d, "SO_USELOOPBACK", SO_USELOOPBACK);
PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
#endif
#ifdef SO_LINGER
insint(d, "SO_LINGER", SO_LINGER);
PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
#endif
#ifdef SO_OOBINLINE
insint(d, "SO_OOBINLINE", SO_OOBINLINE);
PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
#endif
#ifdef SO_REUSEPORT
insint(d, "SO_REUSEPORT", SO_REUSEPORT);
PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
#endif
#ifdef SO_SNDBUF
insint(d, "SO_SNDBUF", SO_SNDBUF);
PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
#endif
#ifdef SO_RCVBUF
insint(d, "SO_RCVBUF", SO_RCVBUF);
PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
#endif
#ifdef SO_SNDLOWAT
insint(d, "SO_SNDLOWAT", SO_SNDLOWAT);
PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
#endif
#ifdef SO_RCVLOWAT
insint(d, "SO_RCVLOWAT", SO_RCVLOWAT);
PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
#endif
#ifdef SO_SNDTIMEO
insint(d, "SO_SNDTIMEO", SO_SNDTIMEO);
PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
#endif
#ifdef SO_RCVTIMEO
insint(d, "SO_RCVTIMEO", SO_RCVTIMEO);
PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
#endif
#ifdef SO_ERROR
insint(d, "SO_ERROR", SO_ERROR);
PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
#endif
#ifdef SO_TYPE
insint(d, "SO_TYPE", SO_TYPE);
PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
#endif
/* Maximum number of connections for "listen" */
#ifdef SOMAXCONN
insint(d, "SOMAXCONN", SOMAXCONN);
PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
#else
insint(d, "SOMAXCONN", 5); /* Common value */
PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
#endif
/* Flags for send, recv */
#ifdef MSG_OOB
insint(d, "MSG_OOB", MSG_OOB);
PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
#endif
#ifdef MSG_PEEK
insint(d, "MSG_PEEK", MSG_PEEK);
PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
#endif
#ifdef MSG_DONTROUTE
insint(d, "MSG_DONTROUTE", MSG_DONTROUTE);
PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
#endif
#ifdef MSG_DONTWAIT
insint(d, "MSG_DONTWAIT", MSG_DONTWAIT);
PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
#endif
#ifdef MSG_EOR
insint(d, "MSG_EOR", MSG_EOR);
PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
#endif
#ifdef MSG_TRUNC
insint(d, "MSG_TRUNC", MSG_TRUNC);
PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
#endif
#ifdef MSG_CTRUNC
insint(d, "MSG_CTRUNC", MSG_CTRUNC);
PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
#endif
#ifdef MSG_WAITALL
insint(d, "MSG_WAITALL", MSG_WAITALL);
PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
#endif
#ifdef MSG_BTAG
insint(d, "MSG_BTAG", MSG_BTAG);
PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
#endif
#ifdef MSG_ETAG
insint(d, "MSG_ETAG", MSG_ETAG);
PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
#endif
/* Protocol level and numbers, usable for [gs]etsockopt */
#ifdef SOL_SOCKET
insint(d, "SOL_SOCKET", SOL_SOCKET);
PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
#endif
#ifdef SOL_IP
insint(d, "SOL_IP", SOL_IP);
PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
#else
insint(d, "SOL_IP", 0);
PyModule_AddIntConstant(m, "SOL_IP", 0);
#endif
#ifdef SOL_IPX
insint(d, "SOL_IPX", SOL_IPX);
PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
#endif
#ifdef SOL_AX25
insint(d, "SOL_AX25", SOL_AX25);
PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
#endif
#ifdef SOL_ATALK
insint(d, "SOL_ATALK", SOL_ATALK);
PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
#endif
#ifdef SOL_NETROM
insint(d, "SOL_NETROM", SOL_NETROM);
PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
#endif
#ifdef SOL_ROSE
insint(d, "SOL_ROSE", SOL_ROSE);
PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
#endif
#ifdef SOL_TCP
insint(d, "SOL_TCP", SOL_TCP);
PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
#else
insint(d, "SOL_TCP", 6);
PyModule_AddIntConstant(m, "SOL_TCP", 6);
#endif
#ifdef SOL_UDP
insint(d, "SOL_UDP", SOL_UDP);
PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
#else
insint(d, "SOL_UDP", 17);
PyModule_AddIntConstant(m, "SOL_UDP", 17);
#endif
#ifdef IPPROTO_IP
insint(d, "IPPROTO_IP", IPPROTO_IP);
PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
#else
insint(d, "IPPROTO_IP", 0);
PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
#endif
#ifdef IPPROTO_HOPOPTS
insint(d, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
#endif
#ifdef IPPROTO_ICMP
insint(d, "IPPROTO_ICMP", IPPROTO_ICMP);
PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
#else
insint(d, "IPPROTO_ICMP", 1);
PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
#endif
#ifdef IPPROTO_IGMP
insint(d, "IPPROTO_IGMP", IPPROTO_IGMP);
PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
#endif
#ifdef IPPROTO_GGP
insint(d, "IPPROTO_GGP", IPPROTO_GGP);
PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
#endif
#ifdef IPPROTO_IPV4
insint(d, "IPPROTO_IPV4", IPPROTO_IPV4);
PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
#endif
#ifdef IPPROTO_IPIP
insint(d, "IPPROTO_IPIP", IPPROTO_IPIP);
PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
#endif
#ifdef IPPROTO_TCP
insint(d, "IPPROTO_TCP", IPPROTO_TCP);
PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
#else
insint(d, "IPPROTO_TCP", 6);
PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
#endif
#ifdef IPPROTO_EGP
insint(d, "IPPROTO_EGP", IPPROTO_EGP);
PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
#endif
#ifdef IPPROTO_PUP
insint(d, "IPPROTO_PUP", IPPROTO_PUP);
PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
#endif
#ifdef IPPROTO_UDP
insint(d, "IPPROTO_UDP", IPPROTO_UDP);
PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
#else
insint(d, "IPPROTO_UDP", 17);
PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
#endif
#ifdef IPPROTO_IDP
insint(d, "IPPROTO_IDP", IPPROTO_IDP);
PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
#endif
#ifdef IPPROTO_HELLO
insint(d, "IPPROTO_HELLO", IPPROTO_HELLO);
PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
#endif
#ifdef IPPROTO_ND
insint(d, "IPPROTO_ND", IPPROTO_ND);
PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
#endif
#ifdef IPPROTO_TP
insint(d, "IPPROTO_TP", IPPROTO_TP);
PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
#endif
#ifdef IPPROTO_IPV6
insint(d, "IPPROTO_IPV6", IPPROTO_IPV6);
PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
#endif
#ifdef IPPROTO_ROUTING
insint(d, "IPPROTO_ROUTING", IPPROTO_ROUTING);
PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
#endif
#ifdef IPPROTO_FRAGMENT
insint(d, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
#endif
#ifdef IPPROTO_RSVP
insint(d, "IPPROTO_RSVP", IPPROTO_RSVP);
PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
#endif
#ifdef IPPROTO_GRE
insint(d, "IPPROTO_GRE", IPPROTO_GRE);
PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
#endif
#ifdef IPPROTO_ESP
insint(d, "IPPROTO_ESP", IPPROTO_ESP);
PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
#endif
#ifdef IPPROTO_AH
insint(d, "IPPROTO_AH", IPPROTO_AH);
PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
#endif
#ifdef IPPROTO_MOBILE
insint(d, "IPPROTO_MOBILE", IPPROTO_MOBILE);
PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
#endif
#ifdef IPPROTO_ICMPV6
insint(d, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
#endif
#ifdef IPPROTO_NONE
insint(d, "IPPROTO_NONE", IPPROTO_NONE);
PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
#endif
#ifdef IPPROTO_DSTOPTS
insint(d, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
#endif
#ifdef IPPROTO_XTP
insint(d, "IPPROTO_XTP", IPPROTO_XTP);
PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
#endif
#ifdef IPPROTO_EON
insint(d, "IPPROTO_EON", IPPROTO_EON);
PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
#endif
#ifdef IPPROTO_PIM
insint(d, "IPPROTO_PIM", IPPROTO_PIM);
PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
#endif
#ifdef IPPROTO_IPCOMP
insint(d, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
#endif
#ifdef IPPROTO_VRRP
insint(d, "IPPROTO_VRRP", IPPROTO_VRRP);
PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
#endif
#ifdef IPPROTO_BIP
insint(d, "IPPROTO_BIP", IPPROTO_BIP);
PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
#endif
/**/
#ifdef IPPROTO_RAW
insint(d, "IPPROTO_RAW", IPPROTO_RAW);
PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
#else
insint(d, "IPPROTO_RAW", 255);
PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
#endif
#ifdef IPPROTO_MAX
insint(d, "IPPROTO_MAX", IPPROTO_MAX);
PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
#endif
/* Some port configuration */
#ifdef IPPORT_RESERVED
insint(d, "IPPORT_RESERVED", IPPORT_RESERVED);
PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
#else
insint(d, "IPPORT_RESERVED", 1024);
PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
#endif
#ifdef IPPORT_USERRESERVED
insint(d, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
#else
insint(d, "IPPORT_USERRESERVED", 5000);
PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
#endif
/* Some reserved IP v.4 addresses */
#ifdef INADDR_ANY
insint(d, "INADDR_ANY", INADDR_ANY);
PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
#else
insint(d, "INADDR_ANY", 0x00000000);
PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
#endif
#ifdef INADDR_BROADCAST
insint(d, "INADDR_BROADCAST", INADDR_BROADCAST);
PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
#else
insint(d, "INADDR_BROADCAST", 0xffffffff);
PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
#endif
#ifdef INADDR_LOOPBACK
insint(d, "INADDR_LOOPBACK", INADDR_LOOPBACK);
PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
#else
insint(d, "INADDR_LOOPBACK", 0x7F000001);
PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
#endif
#ifdef INADDR_UNSPEC_GROUP
insint(d, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
#else
insint(d, "INADDR_UNSPEC_GROUP", 0xe0000000);
PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
#endif
#ifdef INADDR_ALLHOSTS_GROUP
insint(d, "INADDR_ALLHOSTS_GROUP", INADDR_ALLHOSTS_GROUP);
PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
INADDR_ALLHOSTS_GROUP);
#else
insint(d, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
#endif
#ifdef INADDR_MAX_LOCAL_GROUP
insint(d, "INADDR_MAX_LOCAL_GROUP", INADDR_MAX_LOCAL_GROUP);
PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
INADDR_MAX_LOCAL_GROUP);
#else
insint(d, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
#endif
#ifdef INADDR_NONE
insint(d, "INADDR_NONE", INADDR_NONE);
PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
#else
insint(d, "INADDR_NONE", 0xffffffff);
PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
#endif
/* IPv4 [gs]etsockopt options */
#ifdef IP_OPTIONS
insint(d, "IP_OPTIONS", IP_OPTIONS);
PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
#endif
#ifdef IP_HDRINCL
insint(d, "IP_HDRINCL", IP_HDRINCL);
PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
#endif
#ifdef IP_TOS
insint(d, "IP_TOS", IP_TOS);
PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
#endif
#ifdef IP_TTL
insint(d, "IP_TTL", IP_TTL);
PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
#endif
#ifdef IP_RECVOPTS
insint(d, "IP_RECVOPTS", IP_RECVOPTS);
PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
#endif
#ifdef IP_RECVRETOPTS
insint(d, "IP_RECVRETOPTS", IP_RECVRETOPTS);
PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
#endif
#ifdef IP_RECVDSTADDR
insint(d, "IP_RECVDSTADDR", IP_RECVDSTADDR);
PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
#endif
#ifdef IP_RETOPTS
insint(d, "IP_RETOPTS", IP_RETOPTS);
PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
#endif
#ifdef IP_MULTICAST_IF
insint(d, "IP_MULTICAST_IF", IP_MULTICAST_IF);
PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
#endif
#ifdef IP_MULTICAST_TTL
insint(d, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
#endif
#ifdef IP_MULTICAST_LOOP
insint(d, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
#endif
#ifdef IP_ADD_MEMBERSHIP
insint(d, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
#endif
#ifdef IP_DROP_MEMBERSHIP
insint(d, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
#endif
#ifdef IP_DEFAULT_MULTICAST_TTL
insint(d, "IP_DEFAULT_MULTICAST_TTL", IP_DEFAULT_MULTICAST_TTL);
PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
IP_DEFAULT_MULTICAST_TTL);
#endif
#ifdef IP_DEFAULT_MULTICAST_LOOP
insint(d, "IP_DEFAULT_MULTICAST_LOOP", IP_DEFAULT_MULTICAST_LOOP);
PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
IP_DEFAULT_MULTICAST_LOOP);
#endif
#ifdef IP_MAX_MEMBERSHIPS
insint(d, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
#endif
/* IPv6 [gs]etsockopt options, defined in RFC2553 */
#ifdef IPV6_JOIN_GROUP
insint(d, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
#endif
#ifdef IPV6_LEAVE_GROUP
insint(d, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
#endif
#ifdef IPV6_MULTICAST_HOPS
insint(d, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
#endif
#ifdef IPV6_MULTICAST_IF
insint(d, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
#endif
#ifdef IPV6_MULTICAST_LOOP
insint(d, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
#endif
#ifdef IPV6_UNICAST_HOPS
insint(d, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
#endif
/* TCP options */
#ifdef TCP_NODELAY
insint(d, "TCP_NODELAY", TCP_NODELAY);
PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
#endif
#ifdef TCP_MAXSEG
insint(d, "TCP_MAXSEG", TCP_MAXSEG);
PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
#endif
#ifdef TCP_CORK
insint(d, "TCP_CORK", TCP_CORK);
PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
#endif
#ifdef TCP_KEEPIDLE
insint(d, "TCP_KEEPIDLE", TCP_KEEPIDLE);
PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
#endif
#ifdef TCP_KEEPINTVL
insint(d, "TCP_KEEPINTVL", TCP_KEEPINTVL);
PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
#endif
#ifdef TCP_KEEPCNT
insint(d, "TCP_KEEPCNT", TCP_KEEPCNT);
PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
#endif
#ifdef TCP_SYNCNT
insint(d, "TCP_SYNCNT", TCP_SYNCNT);
PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
#endif
#ifdef TCP_LINGER2
insint(d, "TCP_LINGER2", TCP_LINGER2);
PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
#endif
#ifdef TCP_DEFER_ACCEPT
insint(d, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
#endif
#ifdef TCP_WINDOW_CLAMP
insint(d, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
#endif
#ifdef TCP_INFO
insint(d, "TCP_INFO", TCP_INFO);
PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
#endif
#ifdef TCP_QUICKACK
insint(d, "TCP_QUICKACK", TCP_QUICKACK);
PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
#endif
/* IPX options */
#ifdef IPX_TYPE
insint(d, "IPX_TYPE", IPX_TYPE);
PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
#endif
/* get{addr,name}info parameters */
#ifdef EAI_ADDRFAMILY
insint(d, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
#endif
#ifdef EAI_AGAIN
insint(d, "EAI_AGAIN", EAI_AGAIN);
PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
#endif
#ifdef EAI_BADFLAGS
insint(d, "EAI_BADFLAGS", EAI_BADFLAGS);
PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
#endif
#ifdef EAI_FAIL
insint(d, "EAI_FAIL", EAI_FAIL);
PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
#endif
#ifdef EAI_FAMILY
insint(d, "EAI_FAMILY", EAI_FAMILY);
PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
#endif
#ifdef EAI_MEMORY
insint(d, "EAI_MEMORY", EAI_MEMORY);
PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
#endif
#ifdef EAI_NODATA
insint(d, "EAI_NODATA", EAI_NODATA);
PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
#endif
#ifdef EAI_NONAME
insint(d, "EAI_NONAME", EAI_NONAME);
PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
#endif
#ifdef EAI_SERVICE
insint(d, "EAI_SERVICE", EAI_SERVICE);
PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
#endif
#ifdef EAI_SOCKTYPE
insint(d, "EAI_SOCKTYPE", EAI_SOCKTYPE);
PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
#endif
#ifdef EAI_SYSTEM
insint(d, "EAI_SYSTEM", EAI_SYSTEM);
PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
#endif
#ifdef EAI_BADHINTS
insint(d, "EAI_BADHINTS", EAI_BADHINTS);
PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
#endif
#ifdef EAI_PROTOCOL
insint(d, "EAI_PROTOCOL", EAI_PROTOCOL);
PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
#endif
#ifdef EAI_MAX
insint(d, "EAI_MAX", EAI_MAX);
PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
#endif
#ifdef AI_PASSIVE
insint(d, "AI_PASSIVE", AI_PASSIVE);
PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
#endif
#ifdef AI_CANONNAME
insint(d, "AI_CANONNAME", AI_CANONNAME);
PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
#endif
#ifdef AI_NUMERICHOST
insint(d, "AI_NUMERICHOST", AI_NUMERICHOST);
PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
#endif
#ifdef AI_MASK
insint(d, "AI_MASK", AI_MASK);
PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
#endif
#ifdef AI_ALL
insint(d, "AI_ALL", AI_ALL);
PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
#endif
#ifdef AI_V4MAPPED_CFG
insint(d, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
#endif
#ifdef AI_ADDRCONFIG
insint(d, "AI_ADDRCONFIG", AI_ADDRCONFIG);
PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
#endif
#ifdef AI_V4MAPPED
insint(d, "AI_V4MAPPED", AI_V4MAPPED);
PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
#endif
#ifdef AI_DEFAULT
insint(d, "AI_DEFAULT", AI_DEFAULT);
PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
#endif
#ifdef NI_MAXHOST
insint(d, "NI_MAXHOST", NI_MAXHOST);
PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
#endif
#ifdef NI_MAXSERV
insint(d, "NI_MAXSERV", NI_MAXSERV);
PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
#endif
#ifdef NI_NOFQDN
insint(d, "NI_NOFQDN", NI_NOFQDN);
PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
#endif
#ifdef NI_NUMERICHOST
insint(d, "NI_NUMERICHOST", NI_NUMERICHOST);
PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
#endif
#ifdef NI_NAMEREQD
insint(d, "NI_NAMEREQD", NI_NAMEREQD);
PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
#endif
#ifdef NI_NUMERICSERV
insint(d, "NI_NUMERICSERV", NI_NUMERICSERV);
PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
#endif
#ifdef NI_DGRAM
insint(d, "NI_DGRAM", NI_DGRAM);
PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
#endif
/* Initialize gethostbyname lock */

22
Modules/stropmodule.c
View File

@ -1215,12 +1215,11 @@ strop_methods[] = {
DL_EXPORT(void)
initstrop(void)
{
PyObject *m, *d, *s;
PyObject *m, *s;
char buf[256];
int c, n;
m = Py_InitModule4("strop", strop_methods, strop_module__doc__,
(PyObject*)NULL, PYTHON_API_VERSION);
d = PyModule_GetDict(m);
/* Create 'whitespace' object */
n = 0;
@ -1229,10 +1228,9 @@ initstrop(void)
buf[n++] = c;
}
s = PyString_FromStringAndSize(buf, n);
if (s) {
PyDict_SetItemString(d, "whitespace", s);
Py_DECREF(s);
}
if (s)
PyModule_AddObject(m, "whitespace", s);
/* Create 'lowercase' object */
n = 0;
for (c = 0; c < 256; c++) {
@ -1240,10 +1238,8 @@ initstrop(void)
buf[n++] = c;
}
s = PyString_FromStringAndSize(buf, n);
if (s) {
PyDict_SetItemString(d, "lowercase", s);
Py_DECREF(s);
}
if (s)
PyModule_AddObject(m, "lowercase", s);
/* Create 'uppercase' object */
n = 0;
@ -1252,8 +1248,6 @@ initstrop(void)
buf[n++] = c;
}
s = PyString_FromStringAndSize(buf, n);
if (s) {
PyDict_SetItemString(d, "uppercase", s);
Py_DECREF(s);
}
if (s)
PyModule_AddObject(m, "uppercase", s);
}

77
Modules/syslogmodule.c
View File

@ -153,67 +153,54 @@ static PyMethodDef syslog_methods[] = {
{NULL, NULL, 0}
};
/* helper function for initialization function */
static void
ins(PyObject *d, char *s, long x)
{
PyObject *v = PyInt_FromLong(x);
if (v) {
PyDict_SetItemString(d, s, v);
Py_DECREF(v);
}
}
/* Initialization function for the module */
DL_EXPORT(void)
initsyslog(void)
{
PyObject *m, *d;
PyObject *m;
/* Create the module and add the functions */
m = Py_InitModule("syslog", syslog_methods);
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
/* Priorities */
ins(d, "LOG_EMERG", LOG_EMERG);
ins(d, "LOG_ALERT", LOG_ALERT);
ins(d, "LOG_CRIT", LOG_CRIT);
ins(d, "LOG_ERR", LOG_ERR);
ins(d, "LOG_WARNING", LOG_WARNING);
ins(d, "LOG_NOTICE", LOG_NOTICE);
ins(d, "LOG_INFO", LOG_INFO);
ins(d, "LOG_DEBUG", LOG_DEBUG);
PyModule_AddIntConstant(m, "LOG_EMERG", LOG_EMERG);
PyModule_AddIntConstant(m, "LOG_ALERT", LOG_ALERT);
PyModule_AddIntConstant(m, "LOG_CRIT", LOG_CRIT);
PyModule_AddIntConstant(m, "LOG_ERR", LOG_ERR);
PyModule_AddIntConstant(m, "LOG_WARNING", LOG_WARNING);
PyModule_AddIntConstant(m, "LOG_NOTICE", LOG_NOTICE);
PyModule_AddIntConstant(m, "LOG_INFO", LOG_INFO);
PyModule_AddIntConstant(m, "LOG_DEBUG", LOG_DEBUG);
/* openlog() option flags */
ins(d, "LOG_PID", LOG_PID);
ins(d, "LOG_CONS", LOG_CONS);
ins(d, "LOG_NDELAY", LOG_NDELAY);
PyModule_AddIntConstant(m, "LOG_PID", LOG_PID);
PyModule_AddIntConstant(m, "LOG_CONS", LOG_CONS);
PyModule_AddIntConstant(m, "LOG_NDELAY", LOG_NDELAY);
#ifdef LOG_NOWAIT
ins(d, "LOG_NOWAIT", LOG_NOWAIT);
PyModule_AddIntConstant(m, "LOG_NOWAIT", LOG_NOWAIT);
#endif
#ifdef LOG_PERROR
ins(d, "LOG_PERROR", LOG_PERROR);
PyModule_AddIntConstant(m, "LOG_PERROR", LOG_PERROR);
#endif
/* Facilities */
ins(d, "LOG_KERN", LOG_KERN);
ins(d, "LOG_USER", LOG_USER);
ins(d, "LOG_MAIL", LOG_MAIL);
ins(d, "LOG_DAEMON", LOG_DAEMON);
ins(d, "LOG_AUTH", LOG_AUTH);
ins(d, "LOG_LPR", LOG_LPR);
ins(d, "LOG_LOCAL0", LOG_LOCAL0);
ins(d, "LOG_LOCAL1", LOG_LOCAL1);
ins(d, "LOG_LOCAL2", LOG_LOCAL2);
ins(d, "LOG_LOCAL3", LOG_LOCAL3);
ins(d, "LOG_LOCAL4", LOG_LOCAL4);
ins(d, "LOG_LOCAL5", LOG_LOCAL5);
ins(d, "LOG_LOCAL6", LOG_LOCAL6);
ins(d, "LOG_LOCAL7", LOG_LOCAL7);
PyModule_AddIntConstant(m, "LOG_KERN", LOG_KERN);
PyModule_AddIntConstant(m, "LOG_USER", LOG_USER);
PyModule_AddIntConstant(m, "LOG_MAIL", LOG_MAIL);
PyModule_AddIntConstant(m, "LOG_DAEMON", LOG_DAEMON);
PyModule_AddIntConstant(m, "LOG_AUTH", LOG_AUTH);
PyModule_AddIntConstant(m, "LOG_LPR", LOG_LPR);
PyModule_AddIntConstant(m, "LOG_LOCAL0", LOG_LOCAL0);
PyModule_AddIntConstant(m, "LOG_LOCAL1", LOG_LOCAL1);
PyModule_AddIntConstant(m, "LOG_LOCAL2", LOG_LOCAL2);
PyModule_AddIntConstant(m, "LOG_LOCAL3", LOG_LOCAL3);
PyModule_AddIntConstant(m, "LOG_LOCAL4", LOG_LOCAL4);
PyModule_AddIntConstant(m, "LOG_LOCAL5", LOG_LOCAL5);
PyModule_AddIntConstant(m, "LOG_LOCAL6", LOG_LOCAL6);
PyModule_AddIntConstant(m, "LOG_LOCAL7", LOG_LOCAL7);
#ifndef LOG_SYSLOG
#define LOG_SYSLOG LOG_DAEMON
@ -228,8 +215,8 @@ initsyslog(void)
#define LOG_CRON LOG_DAEMON
#endif
ins(d, "LOG_SYSLOG", LOG_SYSLOG);
ins(d, "LOG_CRON", LOG_CRON);
ins(d, "LOG_UUCP", LOG_UUCP);
ins(d, "LOG_NEWS", LOG_NEWS);
PyModule_AddIntConstant(m, "LOG_SYSLOG", LOG_SYSLOG);
PyModule_AddIntConstant(m, "LOG_CRON", LOG_CRON);
PyModule_AddIntConstant(m, "LOG_UUCP", LOG_UUCP);
PyModule_AddIntConstant(m, "LOG_NEWS", LOG_NEWS);
}

17
Modules/zlibmodule.c
View File

@ -847,17 +847,18 @@ static char zlib_module_documentation[]=
DL_EXPORT(void)
PyInit_zlib(void)
{
PyObject *m, *d, *ver;
PyObject *m, *ver;
Comptype.ob_type = &PyType_Type;
Decomptype.ob_type = &PyType_Type;
m = Py_InitModule4("zlib", zlib_methods,
zlib_module_documentation,
(PyObject*)NULL,PYTHON_API_VERSION);
d = PyModule_GetDict(m);
ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
if (ZlibError != NULL)
PyDict_SetItemString(d, "error", ZlibError);
ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
if (ZlibError != NULL) {
Py_INCREF(ZlibError);
PyModule_AddObject(m, "error", ZlibError);
}
PyModule_AddIntConstant(m, "MAX_WBITS", MAX_WBITS);
PyModule_AddIntConstant(m, "DEFLATED", DEFLATED);
PyModule_AddIntConstant(m, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
@ -874,10 +875,8 @@ PyInit_zlib(void)
PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
ver = PyString_FromString(ZLIB_VERSION);
if (ver != NULL) {
PyDict_SetItemString(d, "ZLIB_VERSION", ver);
Py_DECREF(ver);
}
if (ver != NULL)
PyModule_AddObject(m, "ZLIB_VERSION", ver);
#ifdef WITH_THREAD
zlib_lock = PyThread_allocate_lock();