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

directly.

Modules/selectmodule.c

@@ -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 */
 }

Modules/socketmodule.c

@@ -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 */

Modules/stropmodule.c

@@ -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);
 }

Modules/syslogmodule.c

@@ -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);
 }

Modules/zlibmodule.c

@@ -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();