gh-83004: Harden _socket init (GH-103261)

Automerge-Triggered-By: GH:erlend-aasland

1 files changed, 581 insertions, 537 deletions

diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index c2b8283..49342b3 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -7338,1394 +7338,1427 @@ static struct PyModuleDef socketmodule = {
 PyMODINIT_FUNC
 PyInit__socket(void)
 {
-    PyObject *m, *has_ipv6;
+    PyObject *m = NULL;
 
-    if (!os_init())
-        return NULL;
+    if (!os_init()) {
+        goto error;
+    }
 
     Py_SET_TYPE(&sock_type, &PyType_Type);
     m = PyModule_Create(&socketmodule);
-    if (m == NULL)
-        return NULL;
+    if (m == NULL) {
+        goto error;
+    }
 
-    PyModule_AddObject(m, "error", Py_NewRef(PyExc_OSError));
-    socket_herror = PyErr_NewException("socket.herror",
-                                       PyExc_OSError, NULL);
-    if (socket_herror == NULL)
-        return NULL;
-    PyModule_AddObject(m, "herror", Py_NewRef(socket_herror));
-    socket_gaierror = PyErr_NewException("socket.gaierror", PyExc_OSError,
-        NULL);
-    if (socket_gaierror == NULL)
-        return NULL;
-    PyModule_AddObject(m, "gaierror", Py_NewRef(socket_gaierror));
-    PyModule_AddObjectRef(m, "timeout", PyExc_TimeoutError);
+#define ADD_EXC(MOD, NAME, VAR, BASE) do {                  \
+    VAR = PyErr_NewException("socket." NAME, BASE, NULL);   \
+    if (VAR == NULL) {                                      \
+        goto error;                                         \
+    }                                                       \
+    int rc = PyModule_AddObjectRef(MOD, NAME, VAR);         \
+    Py_DECREF(VAR);                                         \
+    if (rc < 0) {                                           \
+        goto error;                                         \
+    }                                                       \
+} while (0)
 
-    if (PyModule_AddObject(m, "SocketType", Py_NewRef(&sock_type)) != 0)
-        return NULL;
-    if (PyModule_AddObject(m, "socket", Py_NewRef(&sock_type)) != 0)
-        return NULL;
+    ADD_EXC(m, "herror", socket_herror, PyExc_OSError);
+    ADD_EXC(m, "gaierror", socket_gaierror, PyExc_OSError);
 
+#undef ADD_EXC
+
+    if (PyModule_AddObjectRef(m, "error", PyExc_OSError) < 0) {
+        goto error;
+    }
+    if (PyModule_AddObjectRef(m, "timeout", PyExc_TimeoutError) < 0) {
+        goto error;
+    }
+    if (PyModule_AddObjectRef(m, "SocketType", (PyObject *)&sock_type) < 0) {
+        goto error;
+    }
+    if (PyModule_AddType(m, &sock_type) < 0) {
+        goto error;
+    }
+
+    PyObject *has_ipv6;
 #ifdef ENABLE_IPV6
     has_ipv6 = Py_True;
 #else
     has_ipv6 = Py_False;
 #endif
-    PyModule_AddObject(m, "has_ipv6", Py_NewRef(has_ipv6));
+    if (PyModule_AddObjectRef(m, "has_ipv6", has_ipv6) < 0) {
+        goto error;
+    }
 
     /* Export C API */
     PySocketModule_APIObject *capi = sock_get_api();
     if (capi == NULL) {
-        Py_DECREF(m);
-        return NULL;
+        goto error;
     }
     PyObject *capsule = PyCapsule_New(capi,
                                       PySocket_CAPSULE_NAME,
                                       sock_destroy_api);
     if (capsule == NULL) {
         sock_free_api(capi);
-        Py_DECREF(m);
-        return NULL;
+        goto error;
     }
-    if (PyModule_AddObject(m, PySocket_CAPI_NAME, capsule) < 0) {
-        Py_DECREF(capsule);
-        Py_DECREF(m);
-        return NULL;
+    int rc = PyModule_AddObjectRef(m, PySocket_CAPI_NAME, capsule);
+    Py_DECREF(capsule);
+    if (rc < 0) {
+        goto error;
     }
 
+#define ADD_INT_MACRO(MOD, INT) do {                    \
+    if (PyModule_AddIntConstant(MOD, #INT, INT) < 0) {  \
+        goto error;                                     \
+    }                                                   \
+} while (0)
+
+#define ADD_INT_CONST(MOD, NAME, INT) do {              \
+    if (PyModule_AddIntConstant(MOD, NAME, INT) < 0) {  \
+        goto error;                                     \
+    }                                                   \
+} while (0)
+
+#define ADD_STR_CONST(MOD, NAME, STR) do {                  \
+    if (PyModule_AddStringConstant(MOD, NAME, STR) < 0) {   \
+        goto error;                                         \
+    }                                                       \
+} while (0)
+
     /* Address families (we only support AF_INET and AF_UNIX) */
 #ifdef AF_UNSPEC
-    PyModule_AddIntMacro(m, AF_UNSPEC);
+    ADD_INT_MACRO(m, AF_UNSPEC);
 #endif
-    PyModule_AddIntMacro(m, AF_INET);
+    ADD_INT_MACRO(m, AF_INET);
 #if defined(AF_UNIX)
-    PyModule_AddIntMacro(m, AF_UNIX);
+    ADD_INT_MACRO(m, AF_UNIX);
 #endif /* AF_UNIX */
 #ifdef AF_AX25
     /* Amateur Radio AX.25 */
-    PyModule_AddIntMacro(m, AF_AX25);
+    ADD_INT_MACRO(m, AF_AX25);
 #endif
 #ifdef AF_IPX
-    PyModule_AddIntMacro(m, AF_IPX); /* Novell IPX */
+    ADD_INT_MACRO(m, AF_IPX); /* Novell IPX */
 #endif
 #ifdef AF_APPLETALK
     /* Appletalk DDP */
-    PyModule_AddIntMacro(m, AF_APPLETALK);
+    ADD_INT_MACRO(m, AF_APPLETALK);
 #endif
 #ifdef AF_NETROM
     /* Amateur radio NetROM */
-    PyModule_AddIntMacro(m, AF_NETROM);
+    ADD_INT_MACRO(m, AF_NETROM);
 #endif
 #ifdef AF_BRIDGE
     /* Multiprotocol bridge */
-    PyModule_AddIntMacro(m, AF_BRIDGE);
+    ADD_INT_MACRO(m, AF_BRIDGE);
 #endif
 #ifdef AF_ATMPVC
     /* ATM PVCs */
-    PyModule_AddIntMacro(m, AF_ATMPVC);
+    ADD_INT_MACRO(m, AF_ATMPVC);
 #endif
 #ifdef AF_AAL5
     /* Reserved for Werner's ATM */
-    PyModule_AddIntMacro(m, AF_AAL5);
+    ADD_INT_MACRO(m, AF_AAL5);
 #endif
 #ifdef HAVE_SOCKADDR_ALG
-    PyModule_AddIntMacro(m, AF_ALG); /* Linux crypto */
+    ADD_INT_MACRO(m, AF_ALG); /* Linux crypto */
 #endif
 #ifdef AF_X25
     /* Reserved for X.25 project */
-    PyModule_AddIntMacro(m, AF_X25);
+    ADD_INT_MACRO(m, AF_X25);
 #endif
 #ifdef AF_INET6
-    PyModule_AddIntMacro(m, AF_INET6); /* IP version 6 */
+    ADD_INT_MACRO(m, AF_INET6); /* IP version 6 */
 #endif
 #ifdef AF_ROSE
     /* Amateur Radio X.25 PLP */
-    PyModule_AddIntMacro(m, AF_ROSE);
+    ADD_INT_MACRO(m, AF_ROSE);
 #endif
 #ifdef AF_DECnet
     /* Reserved for DECnet project */
-    PyModule_AddIntMacro(m, AF_DECnet);
+    ADD_INT_MACRO(m, AF_DECnet);
 #endif
 #ifdef AF_NETBEUI
     /* Reserved for 802.2LLC project */
-    PyModule_AddIntMacro(m, AF_NETBEUI);
+    ADD_INT_MACRO(m, AF_NETBEUI);
 #endif
 #ifdef AF_SECURITY
     /* Security callback pseudo AF */
-    PyModule_AddIntMacro(m, AF_SECURITY);
+    ADD_INT_MACRO(m, AF_SECURITY);
 #endif
 #ifdef AF_KEY
     /* PF_KEY key management API */
-    PyModule_AddIntMacro(m, AF_KEY);
+    ADD_INT_MACRO(m, AF_KEY);
 #endif
 #ifdef AF_NETLINK
     /*  */
-    PyModule_AddIntMacro(m, AF_NETLINK);
-    PyModule_AddIntMacro(m, NETLINK_ROUTE);
+    ADD_INT_MACRO(m, AF_NETLINK);
+    ADD_INT_MACRO(m, NETLINK_ROUTE);
 #ifdef NETLINK_SKIP
-    PyModule_AddIntMacro(m, NETLINK_SKIP);
+    ADD_INT_MACRO(m, NETLINK_SKIP);
 #endif
 #ifdef NETLINK_W1
-    PyModule_AddIntMacro(m, NETLINK_W1);
+    ADD_INT_MACRO(m, NETLINK_W1);
 #endif
-    PyModule_AddIntMacro(m, NETLINK_USERSOCK);
-    PyModule_AddIntMacro(m, NETLINK_FIREWALL);
+    ADD_INT_MACRO(m, NETLINK_USERSOCK);
+    ADD_INT_MACRO(m, NETLINK_FIREWALL);
 #ifdef NETLINK_TCPDIAG
-    PyModule_AddIntMacro(m, NETLINK_TCPDIAG);
+    ADD_INT_MACRO(m, NETLINK_TCPDIAG);
 #endif
 #ifdef NETLINK_NFLOG
-    PyModule_AddIntMacro(m, NETLINK_NFLOG);
+    ADD_INT_MACRO(m, NETLINK_NFLOG);
 #endif
 #ifdef NETLINK_XFRM
-    PyModule_AddIntMacro(m, NETLINK_XFRM);
+    ADD_INT_MACRO(m, NETLINK_XFRM);
 #endif
 #ifdef NETLINK_ARPD
-    PyModule_AddIntMacro(m, NETLINK_ARPD);
+    ADD_INT_MACRO(m, NETLINK_ARPD);
 #endif
 #ifdef NETLINK_ROUTE6
-    PyModule_AddIntMacro(m, NETLINK_ROUTE6);
+    ADD_INT_MACRO(m, NETLINK_ROUTE6);
 #endif
-    PyModule_AddIntMacro(m, NETLINK_IP6_FW);
+    ADD_INT_MACRO(m, NETLINK_IP6_FW);
 #ifdef NETLINK_DNRTMSG
-    PyModule_AddIntMacro(m, NETLINK_DNRTMSG);
+    ADD_INT_MACRO(m, NETLINK_DNRTMSG);
 #endif
 #ifdef NETLINK_TAPBASE
-    PyModule_AddIntMacro(m, NETLINK_TAPBASE);
+    ADD_INT_MACRO(m, NETLINK_TAPBASE);
 #endif
 #ifdef NETLINK_CRYPTO
-    PyModule_AddIntMacro(m, NETLINK_CRYPTO);
+    ADD_INT_MACRO(m, NETLINK_CRYPTO);
 #endif
 #endif /* AF_NETLINK */
 
 #ifdef AF_QIPCRTR
     /* Qualcomm IPCROUTER */
-    PyModule_AddIntMacro(m, AF_QIPCRTR);
+    ADD_INT_MACRO(m, AF_QIPCRTR);
 #endif
 
 #ifdef AF_VSOCK
-    PyModule_AddIntConstant(m, "AF_VSOCK", AF_VSOCK);
-    PyModule_AddIntConstant(m, "SO_VM_SOCKETS_BUFFER_SIZE", 0);
-    PyModule_AddIntConstant(m, "SO_VM_SOCKETS_BUFFER_MIN_SIZE", 1);
-    PyModule_AddIntConstant(m, "SO_VM_SOCKETS_BUFFER_MAX_SIZE", 2);
-    PyModule_AddIntConstant(m, "VMADDR_CID_ANY", 0xffffffff);
-    PyModule_AddIntConstant(m, "VMADDR_PORT_ANY", 0xffffffff);
-    PyModule_AddIntConstant(m, "VMADDR_CID_HOST", 2);
-    PyModule_AddIntConstant(m, "VM_SOCKETS_INVALID_VERSION", 0xffffffff);
-    PyModule_AddIntConstant(m, "IOCTL_VM_SOCKETS_GET_LOCAL_CID",  _IO(7, 0xb9));
+    ADD_INT_CONST(m, "AF_VSOCK", AF_VSOCK);
+    ADD_INT_CONST(m, "SO_VM_SOCKETS_BUFFER_SIZE", 0);
+    ADD_INT_CONST(m, "SO_VM_SOCKETS_BUFFER_MIN_SIZE", 1);
+    ADD_INT_CONST(m, "SO_VM_SOCKETS_BUFFER_MAX_SIZE", 2);
+    ADD_INT_CONST(m, "VMADDR_CID_ANY", 0xffffffff);
+    ADD_INT_CONST(m, "VMADDR_PORT_ANY", 0xffffffff);
+    ADD_INT_CONST(m, "VMADDR_CID_HOST", 2);
+    ADD_INT_CONST(m, "VM_SOCKETS_INVALID_VERSION", 0xffffffff);
+    ADD_INT_CONST(m, "IOCTL_VM_SOCKETS_GET_LOCAL_CID",  _IO(7, 0xb9));
 #endif
 
 #ifdef AF_ROUTE
     /* Alias to emulate 4.4BSD */
-    PyModule_AddIntMacro(m, AF_ROUTE);
+    ADD_INT_MACRO(m, AF_ROUTE);
 #endif
 #ifdef AF_LINK
-    PyModule_AddIntMacro(m, AF_LINK);
+    ADD_INT_MACRO(m, AF_LINK);
 #endif
 #ifdef AF_ASH
     /* Ash */
-    PyModule_AddIntMacro(m, AF_ASH);
+    ADD_INT_MACRO(m, AF_ASH);
 #endif
 #ifdef AF_ECONET
     /* Acorn Econet */
-    PyModule_AddIntMacro(m, AF_ECONET);
+    ADD_INT_MACRO(m, AF_ECONET);
 #endif
 #ifdef AF_ATMSVC
     /* ATM SVCs */
-    PyModule_AddIntMacro(m, AF_ATMSVC);
+    ADD_INT_MACRO(m, AF_ATMSVC);
 #endif
 #ifdef AF_SNA
     /* Linux SNA Project (nutters!) */
-    PyModule_AddIntMacro(m, AF_SNA);
+    ADD_INT_MACRO(m, AF_SNA);
 #endif
 #ifdef AF_IRDA
     /* IRDA sockets */
-    PyModule_AddIntMacro(m, AF_IRDA);
+    ADD_INT_MACRO(m, AF_IRDA);
 #endif
 #ifdef AF_PPPOX
     /* PPPoX sockets */
-    PyModule_AddIntMacro(m, AF_PPPOX);
+    ADD_INT_MACRO(m, AF_PPPOX);
 #endif
 #ifdef AF_WANPIPE
     /* Wanpipe API Sockets */
-    PyModule_AddIntMacro(m, AF_WANPIPE);
+    ADD_INT_MACRO(m, AF_WANPIPE);
 #endif
 #ifdef AF_LLC
     /* Linux LLC */
-    PyModule_AddIntMacro(m, AF_LLC);
+    ADD_INT_MACRO(m, AF_LLC);
 #endif
 #ifdef HAVE_AF_HYPERV
     /* Hyper-V sockets */
-    PyModule_AddIntMacro(m, AF_HYPERV);
+    ADD_INT_MACRO(m, AF_HYPERV);
 
     /* for proto */
-    PyModule_AddIntMacro(m, HV_PROTOCOL_RAW);
+    ADD_INT_MACRO(m, HV_PROTOCOL_RAW);
 
     /* for setsockopt() */
-    PyModule_AddIntMacro(m, HVSOCKET_CONNECT_TIMEOUT);
-    PyModule_AddIntMacro(m, HVSOCKET_CONNECT_TIMEOUT_MAX);
-    PyModule_AddIntMacro(m, HVSOCKET_CONNECTED_SUSPEND);
-    PyModule_AddIntMacro(m, HVSOCKET_ADDRESS_FLAG_PASSTHRU);
+    ADD_INT_MACRO(m, HVSOCKET_CONNECT_TIMEOUT);
+    ADD_INT_MACRO(m, HVSOCKET_CONNECT_TIMEOUT_MAX);
+    ADD_INT_MACRO(m, HVSOCKET_CONNECTED_SUSPEND);
+    ADD_INT_MACRO(m, HVSOCKET_ADDRESS_FLAG_PASSTHRU);
 
     /* for bind() or connect() */
-    PyModule_AddStringConstant(m, "HV_GUID_ZERO", "00000000-0000-0000-0000-000000000000");
-    PyModule_AddStringConstant(m, "HV_GUID_WILDCARD", "00000000-0000-0000-0000-000000000000");
-    PyModule_AddStringConstant(m, "HV_GUID_BROADCAST", "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
-    PyModule_AddStringConstant(m, "HV_GUID_CHILDREN", "90DB8B89-0D35-4F79-8CE9-49EA0AC8B7CD");
-    PyModule_AddStringConstant(m, "HV_GUID_LOOPBACK", "E0E16197-DD56-4A10-9195-5EE7A155A838");
-    PyModule_AddStringConstant(m, "HV_GUID_PARENT", "A42E7CDA-D03F-480C-9CC2-A4DE20ABB878");
+    ADD_STR_CONST(m, "HV_GUID_ZERO", "00000000-0000-0000-0000-000000000000");
+    ADD_STR_CONST(m, "HV_GUID_WILDCARD", "00000000-0000-0000-0000-000000000000");
+    ADD_STR_CONST(m, "HV_GUID_BROADCAST", "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
+    ADD_STR_CONST(m, "HV_GUID_CHILDREN", "90DB8B89-0D35-4F79-8CE9-49EA0AC8B7CD");
+    ADD_STR_CONST(m, "HV_GUID_LOOPBACK", "E0E16197-DD56-4A10-9195-5EE7A155A838");
+    ADD_STR_CONST(m, "HV_GUID_PARENT", "A42E7CDA-D03F-480C-9CC2-A4DE20ABB878");
 #endif /* HAVE_AF_HYPERV */
 
 #ifdef USE_BLUETOOTH
-    PyModule_AddIntMacro(m, AF_BLUETOOTH);
+    ADD_INT_MACRO(m, AF_BLUETOOTH);
 #ifdef BTPROTO_L2CAP
-    PyModule_AddIntMacro(m, BTPROTO_L2CAP);
+    ADD_INT_MACRO(m, BTPROTO_L2CAP);
 #endif /* BTPROTO_L2CAP */
 #ifdef BTPROTO_HCI
-    PyModule_AddIntMacro(m, BTPROTO_HCI);
-    PyModule_AddIntMacro(m, SOL_HCI);
+    ADD_INT_MACRO(m, BTPROTO_HCI);
+    ADD_INT_MACRO(m, SOL_HCI);
 #if !defined(__NetBSD__) && !defined(__DragonFly__)
-    PyModule_AddIntMacro(m, HCI_FILTER);
+    ADD_INT_MACRO(m, HCI_FILTER);
 #if !defined(__FreeBSD__)
-    PyModule_AddIntMacro(m, HCI_TIME_STAMP);
-    PyModule_AddIntMacro(m, HCI_DATA_DIR);
+    ADD_INT_MACRO(m, HCI_TIME_STAMP);
+    ADD_INT_MACRO(m, HCI_DATA_DIR);
 #endif /* !__FreeBSD__ */
 #endif /* !__NetBSD__ && !__DragonFly__ */
 #endif /* BTPROTO_HCI */
 #ifdef BTPROTO_RFCOMM
-    PyModule_AddIntMacro(m, BTPROTO_RFCOMM);
+    ADD_INT_MACRO(m, BTPROTO_RFCOMM);
 #endif /* BTPROTO_RFCOMM */
-    PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
-    PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
+    ADD_STR_CONST(m, "BDADDR_ANY", "00:00:00:00:00:00");
+    ADD_STR_CONST(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
 #ifdef BTPROTO_SCO
-    PyModule_AddIntMacro(m, BTPROTO_SCO);
+    ADD_INT_MACRO(m, BTPROTO_SCO);
 #endif /* BTPROTO_SCO */
 #endif /* USE_BLUETOOTH */
 
 #ifdef AF_CAN
     /* Controller Area Network */
-    PyModule_AddIntMacro(m, AF_CAN);
+    ADD_INT_MACRO(m, AF_CAN);
 #endif
 #ifdef PF_CAN
     /* Controller Area Network */
-    PyModule_AddIntMacro(m, PF_CAN);
+    ADD_INT_MACRO(m, PF_CAN);
 #endif
 
 /* Reliable Datagram Sockets */
 #ifdef AF_RDS
-    PyModule_AddIntMacro(m, AF_RDS);
+    ADD_INT_MACRO(m, AF_RDS);
 #endif
 #ifdef PF_RDS
-    PyModule_AddIntMacro(m, PF_RDS);
+    ADD_INT_MACRO(m, PF_RDS);
 #endif
 
 /* Kernel event messages */
 #ifdef PF_SYSTEM
-    PyModule_AddIntMacro(m, PF_SYSTEM);
+    ADD_INT_MACRO(m, PF_SYSTEM);
 #endif
 #ifdef AF_SYSTEM
-    PyModule_AddIntMacro(m, AF_SYSTEM);
+    ADD_INT_MACRO(m, AF_SYSTEM);
 #endif
 
 #ifdef AF_PACKET
-    PyModule_AddIntMacro(m, AF_PACKET);
+    ADD_INT_MACRO(m, AF_PACKET);
 #endif
 #ifdef PF_PACKET
-    PyModule_AddIntMacro(m, PF_PACKET);
+    ADD_INT_MACRO(m, PF_PACKET);
 #endif
 #ifdef PACKET_HOST
-    PyModule_AddIntMacro(m, PACKET_HOST);
+    ADD_INT_MACRO(m, PACKET_HOST);
 #endif
 #ifdef PACKET_BROADCAST
-    PyModule_AddIntMacro(m, PACKET_BROADCAST);
+    ADD_INT_MACRO(m, PACKET_BROADCAST);
 #endif
 #ifdef PACKET_MULTICAST
-    PyModule_AddIntMacro(m, PACKET_MULTICAST);
+    ADD_INT_MACRO(m, PACKET_MULTICAST);
 #endif
 #ifdef PACKET_OTHERHOST
-    PyModule_AddIntMacro(m, PACKET_OTHERHOST);
+    ADD_INT_MACRO(m, PACKET_OTHERHOST);
 #endif
 #ifdef PACKET_OUTGOING
-    PyModule_AddIntMacro(m, PACKET_OUTGOING);
+    ADD_INT_MACRO(m, PACKET_OUTGOING);
 #endif
 #ifdef PACKET_LOOPBACK
-    PyModule_AddIntMacro(m, PACKET_LOOPBACK);
+    ADD_INT_MACRO(m, PACKET_LOOPBACK);
 #endif
 #ifdef PACKET_FASTROUTE
-    PyModule_AddIntMacro(m, PACKET_FASTROUTE);
+    ADD_INT_MACRO(m, PACKET_FASTROUTE);
 #endif
 
 #ifdef HAVE_LINUX_TIPC_H
-    PyModule_AddIntMacro(m, AF_TIPC);
+    ADD_INT_MACRO(m, AF_TIPC);
 
     /* for addresses */
-    PyModule_AddIntMacro(m, TIPC_ADDR_NAMESEQ);
-    PyModule_AddIntMacro(m, TIPC_ADDR_NAME);
-    PyModule_AddIntMacro(m, TIPC_ADDR_ID);
+    ADD_INT_MACRO(m, TIPC_ADDR_NAMESEQ);
+    ADD_INT_MACRO(m, TIPC_ADDR_NAME);
+    ADD_INT_MACRO(m, TIPC_ADDR_ID);
 
-    PyModule_AddIntMacro(m, TIPC_ZONE_SCOPE);
-    PyModule_AddIntMacro(m, TIPC_CLUSTER_SCOPE);
-    PyModule_AddIntMacro(m, TIPC_NODE_SCOPE);
+    ADD_INT_MACRO(m, TIPC_ZONE_SCOPE);
+    ADD_INT_MACRO(m, TIPC_CLUSTER_SCOPE);
+    ADD_INT_MACRO(m, TIPC_NODE_SCOPE);
 
     /* for setsockopt() */
-    PyModule_AddIntMacro(m, SOL_TIPC);
-    PyModule_AddIntMacro(m, TIPC_IMPORTANCE);
-    PyModule_AddIntMacro(m, TIPC_SRC_DROPPABLE);
-    PyModule_AddIntMacro(m, TIPC_DEST_DROPPABLE);
-    PyModule_AddIntMacro(m, TIPC_CONN_TIMEOUT);
+    ADD_INT_MACRO(m, SOL_TIPC);
+    ADD_INT_MACRO(m, TIPC_IMPORTANCE);
+    ADD_INT_MACRO(m, TIPC_SRC_DROPPABLE);
+    ADD_INT_MACRO(m, TIPC_DEST_DROPPABLE);
+    ADD_INT_MACRO(m, TIPC_CONN_TIMEOUT);
 
-    PyModule_AddIntMacro(m, TIPC_LOW_IMPORTANCE);
-    PyModule_AddIntMacro(m, TIPC_MEDIUM_IMPORTANCE);
-    PyModule_AddIntMacro(m, TIPC_HIGH_IMPORTANCE);
-    PyModule_AddIntMacro(m, TIPC_CRITICAL_IMPORTANCE);
+    ADD_INT_MACRO(m, TIPC_LOW_IMPORTANCE);
+    ADD_INT_MACRO(m, TIPC_MEDIUM_IMPORTANCE);
+    ADD_INT_MACRO(m, TIPC_HIGH_IMPORTANCE);
+    ADD_INT_MACRO(m, TIPC_CRITICAL_IMPORTANCE);
 
     /* for subscriptions */
-    PyModule_AddIntMacro(m, TIPC_SUB_PORTS);
-    PyModule_AddIntMacro(m, TIPC_SUB_SERVICE);
+    ADD_INT_MACRO(m, TIPC_SUB_PORTS);
+    ADD_INT_MACRO(m, TIPC_SUB_SERVICE);
 #ifdef TIPC_SUB_CANCEL
     /* doesn't seem to be available everywhere */
-    PyModule_AddIntMacro(m, TIPC_SUB_CANCEL);
+    ADD_INT_MACRO(m, TIPC_SUB_CANCEL);
 #endif
-    PyModule_AddIntMacro(m, TIPC_WAIT_FOREVER);
-    PyModule_AddIntMacro(m, TIPC_PUBLISHED);
-    PyModule_AddIntMacro(m, TIPC_WITHDRAWN);
-    PyModule_AddIntMacro(m, TIPC_SUBSCR_TIMEOUT);
-    PyModule_AddIntMacro(m, TIPC_CFG_SRV);
-    PyModule_AddIntMacro(m, TIPC_TOP_SRV);
+    ADD_INT_MACRO(m, TIPC_WAIT_FOREVER);
+    ADD_INT_MACRO(m, TIPC_PUBLISHED);
+    ADD_INT_MACRO(m, TIPC_WITHDRAWN);
+    ADD_INT_MACRO(m, TIPC_SUBSCR_TIMEOUT);
+    ADD_INT_MACRO(m, TIPC_CFG_SRV);
+    ADD_INT_MACRO(m, TIPC_TOP_SRV);
 #endif
 
 #ifdef HAVE_SOCKADDR_ALG
     /* Socket options */
-    PyModule_AddIntMacro(m, ALG_SET_KEY);
-    PyModule_AddIntMacro(m, ALG_SET_IV);
-    PyModule_AddIntMacro(m, ALG_SET_OP);
-    PyModule_AddIntMacro(m, ALG_SET_AEAD_ASSOCLEN);
-    PyModule_AddIntMacro(m, ALG_SET_AEAD_AUTHSIZE);
-    PyModule_AddIntMacro(m, ALG_SET_PUBKEY);
+    ADD_INT_MACRO(m, ALG_SET_KEY);
+    ADD_INT_MACRO(m, ALG_SET_IV);
+    ADD_INT_MACRO(m, ALG_SET_OP);
+    ADD_INT_MACRO(m, ALG_SET_AEAD_ASSOCLEN);
+    ADD_INT_MACRO(m, ALG_SET_AEAD_AUTHSIZE);
+    ADD_INT_MACRO(m, ALG_SET_PUBKEY);
 
     /* Operations */
-    PyModule_AddIntMacro(m, ALG_OP_DECRYPT);
-    PyModule_AddIntMacro(m, ALG_OP_ENCRYPT);
-    PyModule_AddIntMacro(m, ALG_OP_SIGN);
-    PyModule_AddIntMacro(m, ALG_OP_VERIFY);
+    ADD_INT_MACRO(m, ALG_OP_DECRYPT);
+    ADD_INT_MACRO(m, ALG_OP_ENCRYPT);
+    ADD_INT_MACRO(m, ALG_OP_SIGN);
+    ADD_INT_MACRO(m, ALG_OP_VERIFY);
 #endif
 
 /* IEEE 802.3 protocol numbers required for a standard TCP/IP network stack */
 #ifdef ETHERTYPE_ARP
-    PyModule_AddIntMacro(m, ETHERTYPE_ARP);
+    ADD_INT_MACRO(m, ETHERTYPE_ARP);
 #endif
 #ifdef ETHERTYPE_IP
-    PyModule_AddIntMacro(m, ETHERTYPE_IP);
+    ADD_INT_MACRO(m, ETHERTYPE_IP);
 #endif
 #ifdef ETHERTYPE_IPV6
-    PyModule_AddIntMacro(m, ETHERTYPE_IPV6);
+    ADD_INT_MACRO(m, ETHERTYPE_IPV6);
 #endif
 #ifdef ETHERTYPE_VLAN
-    PyModule_AddIntMacro(m, ETHERTYPE_VLAN);
+    ADD_INT_MACRO(m, ETHERTYPE_VLAN);
 #endif
 
 /* Linux pseudo-protocol for sniffing every packet */
 #ifdef ETH_P_ALL
-    PyModule_AddIntMacro(m, ETH_P_ALL);
+    ADD_INT_MACRO(m, ETH_P_ALL);
 #endif
 
     /* Socket types */
-    PyModule_AddIntMacro(m, SOCK_STREAM);
-    PyModule_AddIntMacro(m, SOCK_DGRAM);
+    ADD_INT_MACRO(m, SOCK_STREAM);
+    ADD_INT_MACRO(m, SOCK_DGRAM);
 /* We have incomplete socket support. */
 #ifdef SOCK_RAW
     /* SOCK_RAW is marked as optional in the POSIX specification */
-    PyModule_AddIntMacro(m, SOCK_RAW);
+    ADD_INT_MACRO(m, SOCK_RAW);
 #endif
 #ifdef SOCK_SEQPACKET
-    PyModule_AddIntMacro(m, SOCK_SEQPACKET);
+    ADD_INT_MACRO(m, SOCK_SEQPACKET);
 #endif
 #if defined(SOCK_RDM)
-    PyModule_AddIntMacro(m, SOCK_RDM);
+    ADD_INT_MACRO(m, SOCK_RDM);
 #endif
 #ifdef SOCK_CLOEXEC
-    PyModule_AddIntMacro(m, SOCK_CLOEXEC);
+    ADD_INT_MACRO(m, SOCK_CLOEXEC);
 #endif
 #ifdef SOCK_NONBLOCK
-    PyModule_AddIntMacro(m, SOCK_NONBLOCK);
+    ADD_INT_MACRO(m, SOCK_NONBLOCK);
 #endif
 
 #ifdef  SO_DEBUG
-    PyModule_AddIntMacro(m, SO_DEBUG);
+    ADD_INT_MACRO(m, SO_DEBUG);
 #endif
 #ifdef  SO_ACCEPTCONN
-    PyModule_AddIntMacro(m, SO_ACCEPTCONN);
+    ADD_INT_MACRO(m, SO_ACCEPTCONN);
 #endif
 #ifdef  SO_REUSEADDR
-    PyModule_AddIntMacro(m, SO_REUSEADDR);
+    ADD_INT_MACRO(m, SO_REUSEADDR);
 #endif
 #ifdef SO_EXCLUSIVEADDRUSE
-    PyModule_AddIntMacro(m, SO_EXCLUSIVEADDRUSE);
+    ADD_INT_MACRO(m, SO_EXCLUSIVEADDRUSE);
 #endif
 #ifdef SO_INCOMING_CPU
-    PyModule_AddIntMacro(m, SO_INCOMING_CPU);
+    ADD_INT_MACRO(m, SO_INCOMING_CPU);
 #endif
 
 #ifdef  SO_KEEPALIVE
-    PyModule_AddIntMacro(m, SO_KEEPALIVE);
+    ADD_INT_MACRO(m, SO_KEEPALIVE);
 #endif
 #ifdef  SO_DONTROUTE
-    PyModule_AddIntMacro(m, SO_DONTROUTE);
+    ADD_INT_MACRO(m, SO_DONTROUTE);
 #endif
 #ifdef  SO_BROADCAST
-    PyModule_AddIntMacro(m, SO_BROADCAST);
+    ADD_INT_MACRO(m, SO_BROADCAST);
 #endif
 #ifdef  SO_USELOOPBACK
-    PyModule_AddIntMacro(m, SO_USELOOPBACK);
+    ADD_INT_MACRO(m, SO_USELOOPBACK);
 #endif
 #ifdef  SO_LINGER
-    PyModule_AddIntMacro(m, SO_LINGER);
+    ADD_INT_MACRO(m, SO_LINGER);
 #endif
 #ifdef  SO_OOBINLINE
-    PyModule_AddIntMacro(m, SO_OOBINLINE);
+    ADD_INT_MACRO(m, SO_OOBINLINE);
 #endif
 #ifndef __GNU__
 #ifdef  SO_REUSEPORT
-    PyModule_AddIntMacro(m, SO_REUSEPORT);
+    ADD_INT_MACRO(m, SO_REUSEPORT);
 #endif
 #endif
 #ifdef  SO_SNDBUF
-    PyModule_AddIntMacro(m, SO_SNDBUF);
+    ADD_INT_MACRO(m, SO_SNDBUF);
 #endif
 #ifdef  SO_RCVBUF
-    PyModule_AddIntMacro(m, SO_RCVBUF);
+    ADD_INT_MACRO(m, SO_RCVBUF);
 #endif
 #ifdef  SO_SNDLOWAT
-    PyModule_AddIntMacro(m, SO_SNDLOWAT);
+    ADD_INT_MACRO(m, SO_SNDLOWAT);
 #endif
 #ifdef  SO_RCVLOWAT
-    PyModule_AddIntMacro(m, SO_RCVLOWAT);
+    ADD_INT_MACRO(m, SO_RCVLOWAT);
 #endif
 #ifdef  SO_SNDTIMEO
-    PyModule_AddIntMacro(m, SO_SNDTIMEO);
+    ADD_INT_MACRO(m, SO_SNDTIMEO);
 #endif
 #ifdef  SO_RCVTIMEO
-    PyModule_AddIntMacro(m, SO_RCVTIMEO);
+    ADD_INT_MACRO(m, SO_RCVTIMEO);
 #endif
 #ifdef  SO_ERROR
-    PyModule_AddIntMacro(m, SO_ERROR);
+    ADD_INT_MACRO(m, SO_ERROR);
 #endif
 #ifdef  SO_TYPE
-    PyModule_AddIntMacro(m, SO_TYPE);
+    ADD_INT_MACRO(m, SO_TYPE);
 #endif
 #ifdef  SO_SETFIB
-    PyModule_AddIntMacro(m, SO_SETFIB);
+    ADD_INT_MACRO(m, SO_SETFIB);
 #endif
 #ifdef  SO_PASSCRED
-    PyModule_AddIntMacro(m, SO_PASSCRED);
+    ADD_INT_MACRO(m, SO_PASSCRED);
 #endif
 #ifdef  SO_PEERCRED
-    PyModule_AddIntMacro(m, SO_PEERCRED);
+    ADD_INT_MACRO(m, SO_PEERCRED);
 #endif
 #ifdef  LOCAL_PEERCRED
-    PyModule_AddIntMacro(m, LOCAL_PEERCRED);
+    ADD_INT_MACRO(m, LOCAL_PEERCRED);
 #endif
 #ifdef  SO_PASSSEC
-    PyModule_AddIntMacro(m, SO_PASSSEC);
+    ADD_INT_MACRO(m, SO_PASSSEC);
 #endif
 #ifdef  SO_PEERSEC
-    PyModule_AddIntMacro(m, SO_PEERSEC);
+    ADD_INT_MACRO(m, SO_PEERSEC);
 #endif
 #ifdef  SO_BINDTODEVICE
-    PyModule_AddIntMacro(m, SO_BINDTODEVICE);
+    ADD_INT_MACRO(m, SO_BINDTODEVICE);
 #endif
 #ifdef  SO_PRIORITY
-    PyModule_AddIntMacro(m, SO_PRIORITY);
+    ADD_INT_MACRO(m, SO_PRIORITY);
 #endif
 #ifdef  SO_MARK
-    PyModule_AddIntMacro(m, SO_MARK);
+    ADD_INT_MACRO(m, SO_MARK);
 #endif
 #ifdef  SO_USER_COOKIE
-    PyModule_AddIntMacro(m, SO_USER_COOKIE);
+    ADD_INT_MACRO(m, SO_USER_COOKIE);
 #endif
 #ifdef  SO_RTABLE
-    PyModule_AddIntMacro(m, SO_RTABLE);
+    ADD_INT_MACRO(m, SO_RTABLE);
 #endif
 #ifdef SO_DOMAIN
-    PyModule_AddIntMacro(m, SO_DOMAIN);
+    ADD_INT_MACRO(m, SO_DOMAIN);
 #endif
 #ifdef SO_PROTOCOL
-    PyModule_AddIntMacro(m, SO_PROTOCOL);
+    ADD_INT_MACRO(m, SO_PROTOCOL);
 #endif
 #ifdef LOCAL_CREDS
-    PyModule_AddIntMacro(m, LOCAL_CREDS);
+    ADD_INT_MACRO(m, LOCAL_CREDS);
 #endif
 #ifdef LOCAL_CREDS_PERSISTENT
-    PyModule_AddIntMacro(m, LOCAL_CREDS_PERSISTENT);
+    ADD_INT_MACRO(m, LOCAL_CREDS_PERSISTENT);
 #endif
 
     /* Maximum number of connections for "listen" */
 #ifdef  SOMAXCONN
-    PyModule_AddIntMacro(m, SOMAXCONN);
+    ADD_INT_MACRO(m, SOMAXCONN);
 #else
-    PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
+    ADD_INT_CONST(m, "SOMAXCONN", 5); /* Common value */
 #endif
 
     /* Ancillary message types */
 #ifdef  SCM_RIGHTS
-    PyModule_AddIntMacro(m, SCM_RIGHTS);
+    ADD_INT_MACRO(m, SCM_RIGHTS);
 #endif
 #ifdef  SCM_CREDENTIALS
-    PyModule_AddIntMacro(m, SCM_CREDENTIALS);
+    ADD_INT_MACRO(m, SCM_CREDENTIALS);
 #endif
 #ifdef  SCM_CREDS
-    PyModule_AddIntMacro(m, SCM_CREDS);
+    ADD_INT_MACRO(m, SCM_CREDS);
 #endif
 #ifdef  SCM_CREDS2
-    PyModule_AddIntMacro(m, SCM_CREDS2);
+    ADD_INT_MACRO(m, SCM_CREDS2);
 #endif
 
     /* Flags for send, recv */
 #ifdef  MSG_OOB
-    PyModule_AddIntMacro(m, MSG_OOB);
+    ADD_INT_MACRO(m, MSG_OOB);
 #endif
 #ifdef  MSG_PEEK
-    PyModule_AddIntMacro(m, MSG_PEEK);
+    ADD_INT_MACRO(m, MSG_PEEK);
 #endif
 #ifdef  MSG_DONTROUTE
-    PyModule_AddIntMacro(m, MSG_DONTROUTE);
+    ADD_INT_MACRO(m, MSG_DONTROUTE);
 #endif
 #ifdef  MSG_DONTWAIT
-    PyModule_AddIntMacro(m, MSG_DONTWAIT);
+    ADD_INT_MACRO(m, MSG_DONTWAIT);
 #endif
 #ifdef  MSG_EOR
-    PyModule_AddIntMacro(m, MSG_EOR);
+    ADD_INT_MACRO(m, MSG_EOR);
 #endif
 #ifdef  MSG_TRUNC
     // workaround for https://github.com/WebAssembly/wasi-libc/issues/305
     #if defined(__wasi__) && !defined(__WASI_RIFLAGS_RECV_DATA_TRUNCATED)
     #  define __WASI_RIFLAGS_RECV_DATA_TRUNCATED 2
     #endif
-    PyModule_AddIntMacro(m, MSG_TRUNC);
+    ADD_INT_MACRO(m, MSG_TRUNC);
 #endif
 #ifdef  MSG_CTRUNC
-    PyModule_AddIntMacro(m, MSG_CTRUNC);
+    ADD_INT_MACRO(m, MSG_CTRUNC);
 #endif
 #ifdef  MSG_WAITALL
-    PyModule_AddIntMacro(m, MSG_WAITALL);
+    ADD_INT_MACRO(m, MSG_WAITALL);
 #endif
 #ifdef  MSG_BTAG
-    PyModule_AddIntMacro(m, MSG_BTAG);
+    ADD_INT_MACRO(m, MSG_BTAG);
 #endif
 #ifdef  MSG_ETAG
-    PyModule_AddIntMacro(m, MSG_ETAG);
+    ADD_INT_MACRO(m, MSG_ETAG);
 #endif
 #ifdef  MSG_NOSIGNAL
-    PyModule_AddIntMacro(m, MSG_NOSIGNAL);
+    ADD_INT_MACRO(m, MSG_NOSIGNAL);
 #endif
 #ifdef  MSG_NOTIFICATION
-    PyModule_AddIntMacro(m, MSG_NOTIFICATION);
+    ADD_INT_MACRO(m, MSG_NOTIFICATION);
 #endif
 #ifdef  MSG_CMSG_CLOEXEC
-    PyModule_AddIntMacro(m, MSG_CMSG_CLOEXEC);
+    ADD_INT_MACRO(m, MSG_CMSG_CLOEXEC);
 #endif
 #ifdef  MSG_ERRQUEUE
-    PyModule_AddIntMacro(m, MSG_ERRQUEUE);
+    ADD_INT_MACRO(m, MSG_ERRQUEUE);
 #endif
 #ifdef  MSG_CONFIRM
-    PyModule_AddIntMacro(m, MSG_CONFIRM);
+    ADD_INT_MACRO(m, MSG_CONFIRM);
 #endif
 #ifdef  MSG_MORE
-    PyModule_AddIntMacro(m, MSG_MORE);
+    ADD_INT_MACRO(m, MSG_MORE);
 #endif
 #ifdef  MSG_EOF
-    PyModule_AddIntMacro(m, MSG_EOF);
+    ADD_INT_MACRO(m, MSG_EOF);
 #endif
 #ifdef  MSG_BCAST
-    PyModule_AddIntMacro(m, MSG_BCAST);
+    ADD_INT_MACRO(m, MSG_BCAST);
 #endif
 #ifdef  MSG_MCAST
-    PyModule_AddIntMacro(m, MSG_MCAST);
+    ADD_INT_MACRO(m, MSG_MCAST);
 #endif
 #ifdef MSG_FASTOPEN
-    PyModule_AddIntMacro(m, MSG_FASTOPEN);
+    ADD_INT_MACRO(m, MSG_FASTOPEN);
 #endif
 
     /* Protocol level and numbers, usable for [gs]etsockopt */
 #ifdef  SOL_SOCKET
-    PyModule_AddIntMacro(m, SOL_SOCKET);
+    ADD_INT_MACRO(m, SOL_SOCKET);
 #endif
 #ifdef  SOL_IP
-    PyModule_AddIntMacro(m, SOL_IP);
+    ADD_INT_MACRO(m, SOL_IP);
 #else
-    PyModule_AddIntConstant(m, "SOL_IP", 0);
+    ADD_INT_CONST(m, "SOL_IP", 0);
 #endif
 #ifdef  SOL_IPX
-    PyModule_AddIntMacro(m, SOL_IPX);
+    ADD_INT_MACRO(m, SOL_IPX);
 #endif
 #ifdef  SOL_AX25
-    PyModule_AddIntMacro(m, SOL_AX25);
+    ADD_INT_MACRO(m, SOL_AX25);
 #endif
 #ifdef  SOL_ATALK
-    PyModule_AddIntMacro(m, SOL_ATALK);
+    ADD_INT_MACRO(m, SOL_ATALK);
 #endif
 #ifdef  SOL_NETROM
-    PyModule_AddIntMacro(m, SOL_NETROM);
+    ADD_INT_MACRO(m, SOL_NETROM);
 #endif
 #ifdef  SOL_ROSE
-    PyModule_AddIntMacro(m, SOL_ROSE);
+    ADD_INT_MACRO(m, SOL_ROSE);
 #endif
 #ifdef  SOL_TCP
-    PyModule_AddIntMacro(m, SOL_TCP);
+    ADD_INT_MACRO(m, SOL_TCP);
 #else
-    PyModule_AddIntConstant(m, "SOL_TCP", 6);
+    ADD_INT_CONST(m, "SOL_TCP", 6);
 #endif
 #ifdef  SOL_UDP
-    PyModule_AddIntMacro(m, SOL_UDP);
+    ADD_INT_MACRO(m, SOL_UDP);
 #else
-    PyModule_AddIntConstant(m, "SOL_UDP", 17);
+    ADD_INT_CONST(m, "SOL_UDP", 17);
 #endif
 #ifdef SOL_CAN_BASE
-    PyModule_AddIntMacro(m, SOL_CAN_BASE);
+    ADD_INT_MACRO(m, SOL_CAN_BASE);
 #endif
 #ifdef SOL_CAN_RAW
-    PyModule_AddIntMacro(m, SOL_CAN_RAW);
-    PyModule_AddIntMacro(m, CAN_RAW);
+    ADD_INT_MACRO(m, SOL_CAN_RAW);
+    ADD_INT_MACRO(m, CAN_RAW);
 #endif
 #if defined(HAVE_LINUX_CAN_H) || defined(HAVE_NETCAN_CAN_H)
-    PyModule_AddIntMacro(m, CAN_EFF_FLAG);
-    PyModule_AddIntMacro(m, CAN_RTR_FLAG);
-    PyModule_AddIntMacro(m, CAN_ERR_FLAG);
+    ADD_INT_MACRO(m, CAN_EFF_FLAG);
+    ADD_INT_MACRO(m, CAN_RTR_FLAG);
+    ADD_INT_MACRO(m, CAN_ERR_FLAG);
 
-    PyModule_AddIntMacro(m, CAN_SFF_MASK);
-    PyModule_AddIntMacro(m, CAN_EFF_MASK);
-    PyModule_AddIntMacro(m, CAN_ERR_MASK);
+    ADD_INT_MACRO(m, CAN_SFF_MASK);
+    ADD_INT_MACRO(m, CAN_EFF_MASK);
+    ADD_INT_MACRO(m, CAN_ERR_MASK);
 #ifdef CAN_ISOTP
-    PyModule_AddIntMacro(m, CAN_ISOTP);
+    ADD_INT_MACRO(m, CAN_ISOTP);
 #endif
 #ifdef CAN_J1939
-    PyModule_AddIntMacro(m, CAN_J1939);
+    ADD_INT_MACRO(m, CAN_J1939);
 #endif
 #endif
 #if defined(HAVE_LINUX_CAN_RAW_H) || defined(HAVE_NETCAN_CAN_H)
-    PyModule_AddIntMacro(m, CAN_RAW_FILTER);
+    ADD_INT_MACRO(m, CAN_RAW_FILTER);
 #ifdef CAN_RAW_ERR_FILTER
-    PyModule_AddIntMacro(m, CAN_RAW_ERR_FILTER);
+    ADD_INT_MACRO(m, CAN_RAW_ERR_FILTER);
 #endif
-    PyModule_AddIntMacro(m, CAN_RAW_LOOPBACK);
-    PyModule_AddIntMacro(m, CAN_RAW_RECV_OWN_MSGS);
+    ADD_INT_MACRO(m, CAN_RAW_LOOPBACK);
+    ADD_INT_MACRO(m, CAN_RAW_RECV_OWN_MSGS);
 #endif
 #ifdef HAVE_LINUX_CAN_RAW_FD_FRAMES
-    PyModule_AddIntMacro(m, CAN_RAW_FD_FRAMES);
+    ADD_INT_MACRO(m, CAN_RAW_FD_FRAMES);
 #endif
 #ifdef HAVE_LINUX_CAN_RAW_JOIN_FILTERS
-    PyModule_AddIntMacro(m, CAN_RAW_JOIN_FILTERS);
+    ADD_INT_MACRO(m, CAN_RAW_JOIN_FILTERS);
 #endif
 #ifdef HAVE_LINUX_CAN_BCM_H
-    PyModule_AddIntMacro(m, CAN_BCM);
+    ADD_INT_MACRO(m, CAN_BCM);
 
     /* BCM opcodes */
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_SETUP", TX_SETUP);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_DELETE", TX_DELETE);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_READ", TX_READ);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_SEND", TX_SEND);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_SETUP", RX_SETUP);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_DELETE", RX_DELETE);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_READ", RX_READ);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_STATUS", TX_STATUS);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_EXPIRED", TX_EXPIRED);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_STATUS", RX_STATUS);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_TIMEOUT", RX_TIMEOUT);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_CHANGED", RX_CHANGED);
+    ADD_INT_CONST(m, "CAN_BCM_TX_SETUP", TX_SETUP);
+    ADD_INT_CONST(m, "CAN_BCM_TX_DELETE", TX_DELETE);
+    ADD_INT_CONST(m, "CAN_BCM_TX_READ", TX_READ);
+    ADD_INT_CONST(m, "CAN_BCM_TX_SEND", TX_SEND);
+    ADD_INT_CONST(m, "CAN_BCM_RX_SETUP", RX_SETUP);
+    ADD_INT_CONST(m, "CAN_BCM_RX_DELETE", RX_DELETE);
+    ADD_INT_CONST(m, "CAN_BCM_RX_READ", RX_READ);
+    ADD_INT_CONST(m, "CAN_BCM_TX_STATUS", TX_STATUS);
+    ADD_INT_CONST(m, "CAN_BCM_TX_EXPIRED", TX_EXPIRED);
+    ADD_INT_CONST(m, "CAN_BCM_RX_STATUS", RX_STATUS);
+    ADD_INT_CONST(m, "CAN_BCM_RX_TIMEOUT", RX_TIMEOUT);
+    ADD_INT_CONST(m, "CAN_BCM_RX_CHANGED", RX_CHANGED);
 
     /* BCM flags */
-    PyModule_AddIntConstant(m, "CAN_BCM_SETTIMER", SETTIMER);
-    PyModule_AddIntConstant(m, "CAN_BCM_STARTTIMER", STARTTIMER);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_COUNTEVT", TX_COUNTEVT);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_ANNOUNCE", TX_ANNOUNCE);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_CP_CAN_ID", TX_CP_CAN_ID);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_FILTER_ID", RX_FILTER_ID);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_CHECK_DLC", RX_CHECK_DLC);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_NO_AUTOTIMER", RX_NO_AUTOTIMER);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_ANNOUNCE_RESUME", RX_ANNOUNCE_RESUME);
-    PyModule_AddIntConstant(m, "CAN_BCM_TX_RESET_MULTI_IDX", TX_RESET_MULTI_IDX);
-    PyModule_AddIntConstant(m, "CAN_BCM_RX_RTR_FRAME", RX_RTR_FRAME);
+    ADD_INT_CONST(m, "CAN_BCM_SETTIMER", SETTIMER);
+    ADD_INT_CONST(m, "CAN_BCM_STARTTIMER", STARTTIMER);
+    ADD_INT_CONST(m, "CAN_BCM_TX_COUNTEVT", TX_COUNTEVT);
+    ADD_INT_CONST(m, "CAN_BCM_TX_ANNOUNCE", TX_ANNOUNCE);
+    ADD_INT_CONST(m, "CAN_BCM_TX_CP_CAN_ID", TX_CP_CAN_ID);
+    ADD_INT_CONST(m, "CAN_BCM_RX_FILTER_ID", RX_FILTER_ID);
+    ADD_INT_CONST(m, "CAN_BCM_RX_CHECK_DLC", RX_CHECK_DLC);
+    ADD_INT_CONST(m, "CAN_BCM_RX_NO_AUTOTIMER", RX_NO_AUTOTIMER);
+    ADD_INT_CONST(m, "CAN_BCM_RX_ANNOUNCE_RESUME", RX_ANNOUNCE_RESUME);
+    ADD_INT_CONST(m, "CAN_BCM_TX_RESET_MULTI_IDX", TX_RESET_MULTI_IDX);
+    ADD_INT_CONST(m, "CAN_BCM_RX_RTR_FRAME", RX_RTR_FRAME);
 #ifdef CAN_FD_FRAME
     /* CAN_FD_FRAME was only introduced in the 4.8.x kernel series */
-    PyModule_AddIntConstant(m, "CAN_BCM_CAN_FD_FRAME", CAN_FD_FRAME);
+    ADD_INT_CONST(m, "CAN_BCM_CAN_FD_FRAME", CAN_FD_FRAME);
 #endif
 #endif
 #ifdef HAVE_LINUX_CAN_J1939_H
-    PyModule_AddIntMacro(m, J1939_MAX_UNICAST_ADDR);
-    PyModule_AddIntMacro(m, J1939_IDLE_ADDR);
-    PyModule_AddIntMacro(m, J1939_NO_ADDR);
-    PyModule_AddIntMacro(m, J1939_NO_NAME);
-    PyModule_AddIntMacro(m, J1939_PGN_REQUEST);
-    PyModule_AddIntMacro(m, J1939_PGN_ADDRESS_CLAIMED);
-    PyModule_AddIntMacro(m, J1939_PGN_ADDRESS_COMMANDED);
-    PyModule_AddIntMacro(m, J1939_PGN_PDU1_MAX);
-    PyModule_AddIntMacro(m, J1939_PGN_MAX);
-    PyModule_AddIntMacro(m, J1939_NO_PGN);
+    ADD_INT_MACRO(m, J1939_MAX_UNICAST_ADDR);
+    ADD_INT_MACRO(m, J1939_IDLE_ADDR);
+    ADD_INT_MACRO(m, J1939_NO_ADDR);
+    ADD_INT_MACRO(m, J1939_NO_NAME);
+    ADD_INT_MACRO(m, J1939_PGN_REQUEST);
+    ADD_INT_MACRO(m, J1939_PGN_ADDRESS_CLAIMED);
+    ADD_INT_MACRO(m, J1939_PGN_ADDRESS_COMMANDED);
+    ADD_INT_MACRO(m, J1939_PGN_PDU1_MAX);
+    ADD_INT_MACRO(m, J1939_PGN_MAX);
+    ADD_INT_MACRO(m, J1939_NO_PGN);
 
     /* J1939 socket options */
-    PyModule_AddIntMacro(m, SO_J1939_FILTER);
-    PyModule_AddIntMacro(m, SO_J1939_PROMISC);
-    PyModule_AddIntMacro(m, SO_J1939_SEND_PRIO);
-    PyModule_AddIntMacro(m, SO_J1939_ERRQUEUE);
+    ADD_INT_MACRO(m, SO_J1939_FILTER);
+    ADD_INT_MACRO(m, SO_J1939_PROMISC);
+    ADD_INT_MACRO(m, SO_J1939_SEND_PRIO);
+    ADD_INT_MACRO(m, SO_J1939_ERRQUEUE);
 
-    PyModule_AddIntMacro(m, SCM_J1939_DEST_ADDR);
-    PyModule_AddIntMacro(m, SCM_J1939_DEST_NAME);
-    PyModule_AddIntMacro(m, SCM_J1939_PRIO);
-    PyModule_AddIntMacro(m, SCM_J1939_ERRQUEUE);
+    ADD_INT_MACRO(m, SCM_J1939_DEST_ADDR);
+    ADD_INT_MACRO(m, SCM_J1939_DEST_NAME);
+    ADD_INT_MACRO(m, SCM_J1939_PRIO);
+    ADD_INT_MACRO(m, SCM_J1939_ERRQUEUE);
 
-    PyModule_AddIntMacro(m, J1939_NLA_PAD);
-    PyModule_AddIntMacro(m, J1939_NLA_BYTES_ACKED);
+    ADD_INT_MACRO(m, J1939_NLA_PAD);
+    ADD_INT_MACRO(m, J1939_NLA_BYTES_ACKED);
 
-    PyModule_AddIntMacro(m, J1939_EE_INFO_NONE);
-    PyModule_AddIntMacro(m, J1939_EE_INFO_TX_ABORT);
+    ADD_INT_MACRO(m, J1939_EE_INFO_NONE);
+    ADD_INT_MACRO(m, J1939_EE_INFO_TX_ABORT);
 
-    PyModule_AddIntMacro(m, J1939_FILTER_MAX);
+    ADD_INT_MACRO(m, J1939_FILTER_MAX);
 #endif
 #ifdef SOL_RDS
-    PyModule_AddIntMacro(m, SOL_RDS);
+    ADD_INT_MACRO(m, SOL_RDS);
 #endif
 #ifdef HAVE_SOCKADDR_ALG
-    PyModule_AddIntMacro(m, SOL_ALG);
+    ADD_INT_MACRO(m, SOL_ALG);
 #endif
 #ifdef RDS_CANCEL_SENT_TO
-    PyModule_AddIntMacro(m, RDS_CANCEL_SENT_TO);
+    ADD_INT_MACRO(m, RDS_CANCEL_SENT_TO);
 #endif
 #ifdef RDS_GET_MR
-    PyModule_AddIntMacro(m, RDS_GET_MR);
+    ADD_INT_MACRO(m, RDS_GET_MR);
 #endif
 #ifdef RDS_FREE_MR
-    PyModule_AddIntMacro(m, RDS_FREE_MR);
+    ADD_INT_MACRO(m, RDS_FREE_MR);
 #endif
 #ifdef RDS_RECVERR
-    PyModule_AddIntMacro(m, RDS_RECVERR);
+    ADD_INT_MACRO(m, RDS_RECVERR);
 #endif
 #ifdef RDS_CONG_MONITOR
-    PyModule_AddIntMacro(m, RDS_CONG_MONITOR);
+    ADD_INT_MACRO(m, RDS_CONG_MONITOR);
 #endif
 #ifdef RDS_GET_MR_FOR_DEST
-    PyModule_AddIntMacro(m, RDS_GET_MR_FOR_DEST);
+    ADD_INT_MACRO(m, RDS_GET_MR_FOR_DEST);
 #endif
 #ifdef  IPPROTO_IP
-    PyModule_AddIntMacro(m, IPPROTO_IP);
+    ADD_INT_MACRO(m, IPPROTO_IP);
 #else
-    PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
+    ADD_INT_CONST(m, "IPPROTO_IP", 0);
 #endif
 #ifdef  IPPROTO_HOPOPTS
-    PyModule_AddIntMacro(m, IPPROTO_HOPOPTS);
+    ADD_INT_MACRO(m, IPPROTO_HOPOPTS);
 #endif
 #ifdef  IPPROTO_ICMP
-    PyModule_AddIntMacro(m, IPPROTO_ICMP);
+    ADD_INT_MACRO(m, IPPROTO_ICMP);
 #else
-    PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
+    ADD_INT_CONST(m, "IPPROTO_ICMP", 1);
 #endif
 #ifdef  IPPROTO_IGMP
-    PyModule_AddIntMacro(m, IPPROTO_IGMP);
+    ADD_INT_MACRO(m, IPPROTO_IGMP);
 #endif
 #ifdef  IPPROTO_GGP
-    PyModule_AddIntMacro(m, IPPROTO_GGP);
+    ADD_INT_MACRO(m, IPPROTO_GGP);
 #endif
 #ifdef  IPPROTO_IPV4
-    PyModule_AddIntMacro(m, IPPROTO_IPV4);
+    ADD_INT_MACRO(m, IPPROTO_IPV4);
 #endif
 #ifdef  IPPROTO_IPV6
-    PyModule_AddIntMacro(m, IPPROTO_IPV6);
+    ADD_INT_MACRO(m, IPPROTO_IPV6);
 #endif
 #ifdef  IPPROTO_IPIP
-    PyModule_AddIntMacro(m, IPPROTO_IPIP);
+    ADD_INT_MACRO(m, IPPROTO_IPIP);
 #endif
 #ifdef  IPPROTO_TCP
-    PyModule_AddIntMacro(m, IPPROTO_TCP);
+    ADD_INT_MACRO(m, IPPROTO_TCP);
 #else
-    PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
+    ADD_INT_CONST(m, "IPPROTO_TCP", 6);
 #endif
 #ifdef  IPPROTO_EGP
-    PyModule_AddIntMacro(m, IPPROTO_EGP);
+    ADD_INT_MACRO(m, IPPROTO_EGP);
 #endif
 #ifdef  IPPROTO_PUP
-    PyModule_AddIntMacro(m, IPPROTO_PUP);
+    ADD_INT_MACRO(m, IPPROTO_PUP);
 #endif
 #ifdef  IPPROTO_UDP
-    PyModule_AddIntMacro(m, IPPROTO_UDP);
+    ADD_INT_MACRO(m, IPPROTO_UDP);
 #else
-    PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
+    ADD_INT_CONST(m, "IPPROTO_UDP", 17);
 #endif
 #ifdef  IPPROTO_UDPLITE
-    PyModule_AddIntMacro(m, IPPROTO_UDPLITE);
+    ADD_INT_MACRO(m, IPPROTO_UDPLITE);
     #ifndef UDPLITE_SEND_CSCOV
         #define UDPLITE_SEND_CSCOV 10
     #endif
-    PyModule_AddIntMacro(m, UDPLITE_SEND_CSCOV);
+    ADD_INT_MACRO(m, UDPLITE_SEND_CSCOV);
     #ifndef UDPLITE_RECV_CSCOV
         #define UDPLITE_RECV_CSCOV 11
     #endif
-    PyModule_AddIntMacro(m, UDPLITE_RECV_CSCOV);
+    ADD_INT_MACRO(m, UDPLITE_RECV_CSCOV);
 #endif
 #ifdef  IPPROTO_IDP
-    PyModule_AddIntMacro(m, IPPROTO_IDP);
+    ADD_INT_MACRO(m, IPPROTO_IDP);
 #endif
 #ifdef  IPPROTO_HELLO
-    PyModule_AddIntMacro(m, IPPROTO_HELLO);
+    ADD_INT_MACRO(m, IPPROTO_HELLO);
 #endif
 #ifdef  IPPROTO_ND
-    PyModule_AddIntMacro(m, IPPROTO_ND);
+    ADD_INT_MACRO(m, IPPROTO_ND);
 #endif
 #ifdef  IPPROTO_TP
-    PyModule_AddIntMacro(m, IPPROTO_TP);
+    ADD_INT_MACRO(m, IPPROTO_TP);
 #endif
 #ifdef  IPPROTO_ROUTING
-    PyModule_AddIntMacro(m, IPPROTO_ROUTING);
+    ADD_INT_MACRO(m, IPPROTO_ROUTING);
 #endif
 #ifdef  IPPROTO_FRAGMENT
-    PyModule_AddIntMacro(m, IPPROTO_FRAGMENT);
+    ADD_INT_MACRO(m, IPPROTO_FRAGMENT);
 #endif
 #ifdef  IPPROTO_RSVP
-    PyModule_AddIntMacro(m, IPPROTO_RSVP);
+    ADD_INT_MACRO(m, IPPROTO_RSVP);
 #endif
 #ifdef  IPPROTO_GRE
-    PyModule_AddIntMacro(m, IPPROTO_GRE);
+    ADD_INT_MACRO(m, IPPROTO_GRE);
 #endif
 #ifdef  IPPROTO_ESP
-    PyModule_AddIntMacro(m, IPPROTO_ESP);
+    ADD_INT_MACRO(m, IPPROTO_ESP);
 #endif
 #ifdef  IPPROTO_AH
-    PyModule_AddIntMacro(m, IPPROTO_AH);
+    ADD_INT_MACRO(m, IPPROTO_AH);
 #endif
 #ifdef  IPPROTO_MOBILE
-    PyModule_AddIntMacro(m, IPPROTO_MOBILE);
+    ADD_INT_MACRO(m, IPPROTO_MOBILE);
 #endif
 #ifdef  IPPROTO_ICMPV6
-    PyModule_AddIntMacro(m, IPPROTO_ICMPV6);
+    ADD_INT_MACRO(m, IPPROTO_ICMPV6);
 #endif
 #ifdef  IPPROTO_NONE
-    PyModule_AddIntMacro(m, IPPROTO_NONE);
+    ADD_INT_MACRO(m, IPPROTO_NONE);
 #endif
 #ifdef  IPPROTO_DSTOPTS
-    PyModule_AddIntMacro(m, IPPROTO_DSTOPTS);
+    ADD_INT_MACRO(m, IPPROTO_DSTOPTS);
 #endif
 #ifdef  IPPROTO_XTP
-    PyModule_AddIntMacro(m, IPPROTO_XTP);
+    ADD_INT_MACRO(m, IPPROTO_XTP);
 #endif
 #ifdef  IPPROTO_EON
-    PyModule_AddIntMacro(m, IPPROTO_EON);
+    ADD_INT_MACRO(m, IPPROTO_EON);
 #endif
 #ifdef  IPPROTO_PIM
-    PyModule_AddIntMacro(m, IPPROTO_PIM);
+    ADD_INT_MACRO(m, IPPROTO_PIM);
 #endif
 #ifdef  IPPROTO_IPCOMP
-    PyModule_AddIntMacro(m, IPPROTO_IPCOMP);
+    ADD_INT_MACRO(m, IPPROTO_IPCOMP);
 #endif
 #ifdef  IPPROTO_VRRP
-    PyModule_AddIntMacro(m, IPPROTO_VRRP);
+    ADD_INT_MACRO(m, IPPROTO_VRRP);
 #endif
 #ifdef  IPPROTO_SCTP
-    PyModule_AddIntMacro(m, IPPROTO_SCTP);
+    ADD_INT_MACRO(m, IPPROTO_SCTP);
 #endif
 #ifdef  IPPROTO_BIP
-    PyModule_AddIntMacro(m, IPPROTO_BIP);
+    ADD_INT_MACRO(m, IPPROTO_BIP);
 #endif
 #ifdef  IPPROTO_MPTCP
-    PyModule_AddIntMacro(m, IPPROTO_MPTCP);
+    ADD_INT_MACRO(m, IPPROTO_MPTCP);
 #endif
 /**/
 #ifdef  IPPROTO_RAW
-    PyModule_AddIntMacro(m, IPPROTO_RAW);
+    ADD_INT_MACRO(m, IPPROTO_RAW);
 #else
-    PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
+    ADD_INT_CONST(m, "IPPROTO_RAW", 255);
 #endif
 #ifdef  IPPROTO_MAX
-    PyModule_AddIntMacro(m, IPPROTO_MAX);
+    ADD_INT_MACRO(m, IPPROTO_MAX);
 #endif
 
 #ifdef  MS_WINDOWS
-    PyModule_AddIntMacro(m, IPPROTO_ICLFXBM);
-    PyModule_AddIntMacro(m, IPPROTO_ST);
-    PyModule_AddIntMacro(m, IPPROTO_CBT);
-    PyModule_AddIntMacro(m, IPPROTO_IGP);
-    PyModule_AddIntMacro(m, IPPROTO_RDP);
-    PyModule_AddIntMacro(m, IPPROTO_PGM);
-    PyModule_AddIntMacro(m, IPPROTO_L2TP);
-    PyModule_AddIntMacro(m, IPPROTO_SCTP);
+    ADD_INT_MACRO(m, IPPROTO_ICLFXBM);
+    ADD_INT_MACRO(m, IPPROTO_ST);
+    ADD_INT_MACRO(m, IPPROTO_CBT);
+    ADD_INT_MACRO(m, IPPROTO_IGP);
+    ADD_INT_MACRO(m, IPPROTO_RDP);
+    ADD_INT_MACRO(m, IPPROTO_PGM);
+    ADD_INT_MACRO(m, IPPROTO_L2TP);
+    ADD_INT_MACRO(m, IPPROTO_SCTP);
 #endif
 
 #ifdef  SYSPROTO_CONTROL
-    PyModule_AddIntMacro(m, SYSPROTO_CONTROL);
+    ADD_INT_MACRO(m, SYSPROTO_CONTROL);
 #endif
 
     /* Some port configuration */
 #ifdef  IPPORT_RESERVED
-    PyModule_AddIntMacro(m, IPPORT_RESERVED);
+    ADD_INT_MACRO(m, IPPORT_RESERVED);
 #else
-    PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
+    ADD_INT_CONST(m, "IPPORT_RESERVED", 1024);
 #endif
 #ifdef  IPPORT_USERRESERVED
-    PyModule_AddIntMacro(m, IPPORT_USERRESERVED);
+    ADD_INT_MACRO(m, IPPORT_USERRESERVED);
 #else
-    PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
+    ADD_INT_CONST(m, "IPPORT_USERRESERVED", 5000);
 #endif
 
     /* Some reserved IP v.4 addresses */
 #ifdef  INADDR_ANY
-    PyModule_AddIntMacro(m, INADDR_ANY);
+    ADD_INT_MACRO(m, INADDR_ANY);
 #else
-    PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
+    ADD_INT_CONST(m, "INADDR_ANY", 0x00000000);
 #endif
 #ifdef  INADDR_BROADCAST
-    PyModule_AddIntMacro(m, INADDR_BROADCAST);
+    ADD_INT_MACRO(m, INADDR_BROADCAST);
 #else
-    PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
+    ADD_INT_CONST(m, "INADDR_BROADCAST", 0xffffffff);
 #endif
 #ifdef  INADDR_LOOPBACK
-    PyModule_AddIntMacro(m, INADDR_LOOPBACK);
+    ADD_INT_MACRO(m, INADDR_LOOPBACK);
 #else
-    PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
+    ADD_INT_CONST(m, "INADDR_LOOPBACK", 0x7F000001);
 #endif
 #ifdef  INADDR_UNSPEC_GROUP
-    PyModule_AddIntMacro(m, INADDR_UNSPEC_GROUP);
+    ADD_INT_MACRO(m, INADDR_UNSPEC_GROUP);
 #else
-    PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
+    ADD_INT_CONST(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
 #endif
 #ifdef  INADDR_ALLHOSTS_GROUP
-    PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
+    ADD_INT_CONST(m, "INADDR_ALLHOSTS_GROUP",
                             INADDR_ALLHOSTS_GROUP);
 #else
-    PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
+    ADD_INT_CONST(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
 #endif
 #ifdef  INADDR_MAX_LOCAL_GROUP
-    PyModule_AddIntMacro(m, INADDR_MAX_LOCAL_GROUP);
+    ADD_INT_MACRO(m, INADDR_MAX_LOCAL_GROUP);
 #else
-    PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
+    ADD_INT_CONST(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
 #endif
 #ifdef  INADDR_NONE
-    PyModule_AddIntMacro(m, INADDR_NONE);
+    ADD_INT_MACRO(m, INADDR_NONE);
 #else
-    PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
+    ADD_INT_CONST(m, "INADDR_NONE", 0xffffffff);
 #endif
 
     /* IPv4 [gs]etsockopt options */
 #ifdef  IP_OPTIONS
-    PyModule_AddIntMacro(m, IP_OPTIONS);
+    ADD_INT_MACRO(m, IP_OPTIONS);
 #endif
 #ifdef  IP_HDRINCL
-    PyModule_AddIntMacro(m, IP_HDRINCL);
+    ADD_INT_MACRO(m, IP_HDRINCL);
 #endif
 #ifdef  IP_TOS
-    PyModule_AddIntMacro(m, IP_TOS);
+    ADD_INT_MACRO(m, IP_TOS);
 #endif
 #ifdef  IP_TTL
-    PyModule_AddIntMacro(m, IP_TTL);
+    ADD_INT_MACRO(m, IP_TTL);
 #endif
 #ifdef  IP_RECVOPTS
-    PyModule_AddIntMacro(m, IP_RECVOPTS);
+    ADD_INT_MACRO(m, IP_RECVOPTS);
 #endif
 #ifdef  IP_RECVRETOPTS
-    PyModule_AddIntMacro(m, IP_RECVRETOPTS);
+    ADD_INT_MACRO(m, IP_RECVRETOPTS);
 #endif
 #ifdef  IP_RECVTOS
-    PyModule_AddIntMacro(m, IP_RECVTOS);
+    ADD_INT_MACRO(m, IP_RECVTOS);
 #endif
 #ifdef  IP_RECVDSTADDR
-    PyModule_AddIntMacro(m, IP_RECVDSTADDR);
+    ADD_INT_MACRO(m, IP_RECVDSTADDR);
 #endif
 #ifdef  IP_RETOPTS
-    PyModule_AddIntMacro(m, IP_RETOPTS);
+    ADD_INT_MACRO(m, IP_RETOPTS);
 #endif
 #ifdef  IP_MULTICAST_IF
-    PyModule_AddIntMacro(m, IP_MULTICAST_IF);
+    ADD_INT_MACRO(m, IP_MULTICAST_IF);
 #endif
 #ifdef  IP_MULTICAST_TTL
-    PyModule_AddIntMacro(m, IP_MULTICAST_TTL);
+    ADD_INT_MACRO(m, IP_MULTICAST_TTL);
 #endif
 #ifdef  IP_MULTICAST_LOOP
-    PyModule_AddIntMacro(m, IP_MULTICAST_LOOP);
+    ADD_INT_MACRO(m, IP_MULTICAST_LOOP);
 #endif
 #ifdef  IP_ADD_MEMBERSHIP
-    PyModule_AddIntMacro(m, IP_ADD_MEMBERSHIP);
+    ADD_INT_MACRO(m, IP_ADD_MEMBERSHIP);
 #endif
 #ifdef  IP_DROP_MEMBERSHIP
-    PyModule_AddIntMacro(m, IP_DROP_MEMBERSHIP);
+    ADD_INT_MACRO(m, IP_DROP_MEMBERSHIP);
 #endif
 #ifdef  IP_DEFAULT_MULTICAST_TTL
-    PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_TTL);
+    ADD_INT_MACRO(m, IP_DEFAULT_MULTICAST_TTL);
 #endif
 #ifdef  IP_DEFAULT_MULTICAST_LOOP
-    PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_LOOP);
+    ADD_INT_MACRO(m, IP_DEFAULT_MULTICAST_LOOP);
 #endif
 #ifdef  IP_MAX_MEMBERSHIPS
-    PyModule_AddIntMacro(m, IP_MAX_MEMBERSHIPS);
+    ADD_INT_MACRO(m, IP_MAX_MEMBERSHIPS);
 #endif
 #ifdef  IP_TRANSPARENT
-    PyModule_AddIntMacro(m, IP_TRANSPARENT);
+    ADD_INT_MACRO(m, IP_TRANSPARENT);
 #endif
 #ifdef  IP_PKTINFO
-    PyModule_AddIntMacro(m, IP_PKTINFO);
+    ADD_INT_MACRO(m, IP_PKTINFO);
 #endif
 #ifdef IP_BIND_ADDRESS_NO_PORT
-    PyModule_AddIntMacro(m, IP_BIND_ADDRESS_NO_PORT);
+    ADD_INT_MACRO(m, IP_BIND_ADDRESS_NO_PORT);
 #endif
 
     /* IPv6 [gs]etsockopt options, defined in RFC2553 */
 #ifdef  IPV6_JOIN_GROUP
-    PyModule_AddIntMacro(m, IPV6_JOIN_GROUP);
+    ADD_INT_MACRO(m, IPV6_JOIN_GROUP);
 #endif
 #ifdef  IPV6_LEAVE_GROUP
-    PyModule_AddIntMacro(m, IPV6_LEAVE_GROUP);
+    ADD_INT_MACRO(m, IPV6_LEAVE_GROUP);
 #endif
 #ifdef  IPV6_MULTICAST_HOPS
-    PyModule_AddIntMacro(m, IPV6_MULTICAST_HOPS);
+    ADD_INT_MACRO(m, IPV6_MULTICAST_HOPS);
 #endif
 #ifdef  IPV6_MULTICAST_IF
-    PyModule_AddIntMacro(m, IPV6_MULTICAST_IF);
+    ADD_INT_MACRO(m, IPV6_MULTICAST_IF);
 #endif
 #ifdef  IPV6_MULTICAST_LOOP
-    PyModule_AddIntMacro(m, IPV6_MULTICAST_LOOP);
+    ADD_INT_MACRO(m, IPV6_MULTICAST_LOOP);
 #endif
 #ifdef  IPV6_UNICAST_HOPS
-    PyModule_AddIntMacro(m, IPV6_UNICAST_HOPS);
+    ADD_INT_MACRO(m, IPV6_UNICAST_HOPS);
 #endif
     /* Additional IPV6 socket options, defined in RFC 3493 */
 #ifdef IPV6_V6ONLY
-    PyModule_AddIntMacro(m, IPV6_V6ONLY);
+    ADD_INT_MACRO(m, IPV6_V6ONLY);
 #endif
     /* Advanced IPV6 socket options, from RFC 3542 */
 #ifdef IPV6_CHECKSUM
-    PyModule_AddIntMacro(m, IPV6_CHECKSUM);
+    ADD_INT_MACRO(m, IPV6_CHECKSUM);
 #endif
 #ifdef IPV6_DONTFRAG
-    PyModule_AddIntMacro(m, IPV6_DONTFRAG);
+    ADD_INT_MACRO(m, IPV6_DONTFRAG);
 #endif
 #ifdef IPV6_DSTOPTS
-    PyModule_AddIntMacro(m, IPV6_DSTOPTS);
+    ADD_INT_MACRO(m, IPV6_DSTOPTS);
 #endif
 #ifdef IPV6_HOPLIMIT
-    PyModule_AddIntMacro(m, IPV6_HOPLIMIT);
+    ADD_INT_MACRO(m, IPV6_HOPLIMIT);
 #endif
 #ifdef IPV6_HOPOPTS
-    PyModule_AddIntMacro(m, IPV6_HOPOPTS);
+    ADD_INT_MACRO(m, IPV6_HOPOPTS);
 #endif
 #ifdef IPV6_NEXTHOP
-    PyModule_AddIntMacro(m, IPV6_NEXTHOP);
+    ADD_INT_MACRO(m, IPV6_NEXTHOP);
 #endif
 #ifdef IPV6_PATHMTU
-    PyModule_AddIntMacro(m, IPV6_PATHMTU);
+    ADD_INT_MACRO(m, IPV6_PATHMTU);
 #endif
 #ifdef IPV6_PKTINFO
-    PyModule_AddIntMacro(m, IPV6_PKTINFO);
+    ADD_INT_MACRO(m, IPV6_PKTINFO);
 #endif
 #ifdef IPV6_RECVDSTOPTS
-    PyModule_AddIntMacro(m, IPV6_RECVDSTOPTS);
+    ADD_INT_MACRO(m, IPV6_RECVDSTOPTS);
 #endif
 #ifdef IPV6_RECVHOPLIMIT
-    PyModule_AddIntMacro(m, IPV6_RECVHOPLIMIT);
+    ADD_INT_MACRO(m, IPV6_RECVHOPLIMIT);
 #endif
 #ifdef IPV6_RECVHOPOPTS
-    PyModule_AddIntMacro(m, IPV6_RECVHOPOPTS);
+    ADD_INT_MACRO(m, IPV6_RECVHOPOPTS);
 #endif
 #ifdef IPV6_RECVPKTINFO
-    PyModule_AddIntMacro(m, IPV6_RECVPKTINFO);
+    ADD_INT_MACRO(m, IPV6_RECVPKTINFO);
 #endif
 #ifdef IPV6_RECVRTHDR
-    PyModule_AddIntMacro(m, IPV6_RECVRTHDR);
+    ADD_INT_MACRO(m, IPV6_RECVRTHDR);
 #endif
 #ifdef IPV6_RECVTCLASS
-    PyModule_AddIntMacro(m, IPV6_RECVTCLASS);
+    ADD_INT_MACRO(m, IPV6_RECVTCLASS);
 #endif
 #ifdef IPV6_RTHDR
-    PyModule_AddIntMacro(m, IPV6_RTHDR);
+    ADD_INT_MACRO(m, IPV6_RTHDR);
 #endif
 #ifdef IPV6_RTHDRDSTOPTS
-    PyModule_AddIntMacro(m, IPV6_RTHDRDSTOPTS);
+    ADD_INT_MACRO(m, IPV6_RTHDRDSTOPTS);
 #endif
 #ifdef IPV6_RTHDR_TYPE_0
-    PyModule_AddIntMacro(m, IPV6_RTHDR_TYPE_0);
+    ADD_INT_MACRO(m, IPV6_RTHDR_TYPE_0);
 #endif
 #ifdef IPV6_RECVPATHMTU
-    PyModule_AddIntMacro(m, IPV6_RECVPATHMTU);
+    ADD_INT_MACRO(m, IPV6_RECVPATHMTU);
 #endif
 #ifdef IPV6_TCLASS
-    PyModule_AddIntMacro(m, IPV6_TCLASS);
+    ADD_INT_MACRO(m, IPV6_TCLASS);
 #endif
 #ifdef IPV6_USE_MIN_MTU
-    PyModule_AddIntMacro(m, IPV6_USE_MIN_MTU);
+    ADD_INT_MACRO(m, IPV6_USE_MIN_MTU);
 #endif
 
     /* TCP options */
 #ifdef  TCP_NODELAY
-    PyModule_AddIntMacro(m, TCP_NODELAY);
+    ADD_INT_MACRO(m, TCP_NODELAY);
 #endif
 #ifdef  TCP_MAXSEG
-    PyModule_AddIntMacro(m, TCP_MAXSEG);
+    ADD_INT_MACRO(m, TCP_MAXSEG);
 #endif
 #ifdef  TCP_CORK
-    PyModule_AddIntMacro(m, TCP_CORK);
+    ADD_INT_MACRO(m, TCP_CORK);
 #endif
 #ifdef  TCP_KEEPIDLE
-    PyModule_AddIntMacro(m, TCP_KEEPIDLE);
+    ADD_INT_MACRO(m, TCP_KEEPIDLE);
 #endif
     /* TCP_KEEPALIVE is OSX's TCP_KEEPIDLE equivalent */
 #if defined(__APPLE__) && defined(TCP_KEEPALIVE)
-    PyModule_AddIntMacro(m, TCP_KEEPALIVE);
+    ADD_INT_MACRO(m, TCP_KEEPALIVE);
 #endif
 #ifdef  TCP_KEEPINTVL
-    PyModule_AddIntMacro(m, TCP_KEEPINTVL);
+    ADD_INT_MACRO(m, TCP_KEEPINTVL);
 #endif
 #ifdef  TCP_KEEPCNT
-    PyModule_AddIntMacro(m, TCP_KEEPCNT);
+    ADD_INT_MACRO(m, TCP_KEEPCNT);
 #endif
 #ifdef  TCP_SYNCNT
-    PyModule_AddIntMacro(m, TCP_SYNCNT);
+    ADD_INT_MACRO(m, TCP_SYNCNT);
 #endif
 #ifdef  TCP_LINGER2
-    PyModule_AddIntMacro(m, TCP_LINGER2);
+    ADD_INT_MACRO(m, TCP_LINGER2);
 #endif
 #ifdef  TCP_DEFER_ACCEPT
-    PyModule_AddIntMacro(m, TCP_DEFER_ACCEPT);
+    ADD_INT_MACRO(m, TCP_DEFER_ACCEPT);
 #endif
 #ifdef  TCP_WINDOW_CLAMP
-    PyModule_AddIntMacro(m, TCP_WINDOW_CLAMP);
+    ADD_INT_MACRO(m, TCP_WINDOW_CLAMP);
 #endif
 #ifdef  TCP_INFO
-    PyModule_AddIntMacro(m, TCP_INFO);
+    ADD_INT_MACRO(m, TCP_INFO);
 #endif
 #ifdef  TCP_CONNECTION_INFO
-    PyModule_AddIntMacro(m, TCP_CONNECTION_INFO);
+    ADD_INT_MACRO(m, TCP_CONNECTION_INFO);
 #endif
 #ifdef  TCP_QUICKACK
-    PyModule_AddIntMacro(m, TCP_QUICKACK);
+    ADD_INT_MACRO(m, TCP_QUICKACK);
 #endif
 #ifdef  TCP_CONGESTION
-    PyModule_AddIntMacro(m, TCP_CONGESTION);
+    ADD_INT_MACRO(m, TCP_CONGESTION);
 #endif
 #ifdef  TCP_MD5SIG
-    PyModule_AddIntMacro(m, TCP_MD5SIG);
+    ADD_INT_MACRO(m, TCP_MD5SIG);
 #endif
 #ifdef  TCP_THIN_LINEAR_TIMEOUTS
-    PyModule_AddIntMacro(m, TCP_THIN_LINEAR_TIMEOUTS);
+    ADD_INT_MACRO(m, TCP_THIN_LINEAR_TIMEOUTS);
 #endif
 #ifdef  TCP_THIN_DUPACK
-    PyModule_AddIntMacro(m, TCP_THIN_DUPACK);
+    ADD_INT_MACRO(m, TCP_THIN_DUPACK);
 #endif
 #ifdef  TCP_USER_TIMEOUT
-    PyModule_AddIntMacro(m, TCP_USER_TIMEOUT);
+    ADD_INT_MACRO(m, TCP_USER_TIMEOUT);
 #endif
 #ifdef  TCP_REPAIR
-    PyModule_AddIntMacro(m, TCP_REPAIR);
+    ADD_INT_MACRO(m, TCP_REPAIR);
 #endif
 #ifdef  TCP_REPAIR_QUEUE
-    PyModule_AddIntMacro(m, TCP_REPAIR_QUEUE);
+    ADD_INT_MACRO(m, TCP_REPAIR_QUEUE);
 #endif
 #ifdef  TCP_QUEUE_SEQ
-    PyModule_AddIntMacro(m, TCP_QUEUE_SEQ);
+    ADD_INT_MACRO(m, TCP_QUEUE_SEQ);
 #endif
 #ifdef  TCP_REPAIR_OPTIONS
-    PyModule_AddIntMacro(m, TCP_REPAIR_OPTIONS);
+    ADD_INT_MACRO(m, TCP_REPAIR_OPTIONS);
 #endif
 #ifdef  TCP_FASTOPEN
-    PyModule_AddIntMacro(m, TCP_FASTOPEN);
+    ADD_INT_MACRO(m, TCP_FASTOPEN);
 #endif
 #ifdef  TCP_TIMESTAMP
-    PyModule_AddIntMacro(m, TCP_TIMESTAMP);
+    ADD_INT_MACRO(m, TCP_TIMESTAMP);
 #endif
 #ifdef  TCP_NOTSENT_LOWAT
-    PyModule_AddIntMacro(m, TCP_NOTSENT_LOWAT);
+    ADD_INT_MACRO(m, TCP_NOTSENT_LOWAT);
 #endif
 #ifdef  TCP_CC_INFO
-    PyModule_AddIntMacro(m, TCP_CC_INFO);
+    ADD_INT_MACRO(m, TCP_CC_INFO);
 #endif
 #ifdef  TCP_SAVE_SYN
-    PyModule_AddIntMacro(m, TCP_SAVE_SYN);
+    ADD_INT_MACRO(m, TCP_SAVE_SYN);
 #endif
 #ifdef  TCP_SAVED_SYN
-    PyModule_AddIntMacro(m, TCP_SAVED_SYN);
+    ADD_INT_MACRO(m, TCP_SAVED_SYN);
 #endif
 #ifdef  TCP_REPAIR_WINDOW
-    PyModule_AddIntMacro(m, TCP_REPAIR_WINDOW);
+    ADD_INT_MACRO(m, TCP_REPAIR_WINDOW);
 #endif
 #ifdef  TCP_FASTOPEN_CONNECT
-    PyModule_AddIntMacro(m, TCP_FASTOPEN_CONNECT);
+    ADD_INT_MACRO(m, TCP_FASTOPEN_CONNECT);
 #endif
 #ifdef  TCP_ULP
-    PyModule_AddIntMacro(m, TCP_ULP);
+    ADD_INT_MACRO(m, TCP_ULP);
 #endif
 #ifdef  TCP_MD5SIG_EXT
-    PyModule_AddIntMacro(m, TCP_MD5SIG_EXT);
+    ADD_INT_MACRO(m, TCP_MD5SIG_EXT);
 #endif
 #ifdef  TCP_FASTOPEN_KEY
-    PyModule_AddIntMacro(m, TCP_FASTOPEN_KEY);
+    ADD_INT_MACRO(m, TCP_FASTOPEN_KEY);
 #endif
 #ifdef  TCP_FASTOPEN_NO_COOKIE
-    PyModule_AddIntMacro(m, TCP_FASTOPEN_NO_COOKIE);
+    ADD_INT_MACRO(m, TCP_FASTOPEN_NO_COOKIE);
 #endif
 #ifdef  TCP_ZEROCOPY_RECEIVE
-    PyModule_AddIntMacro(m, TCP_ZEROCOPY_RECEIVE);
+    ADD_INT_MACRO(m, TCP_ZEROCOPY_RECEIVE);
 #endif
 #ifdef  TCP_INQ
-    PyModule_AddIntMacro(m, TCP_INQ);
+    ADD_INT_MACRO(m, TCP_INQ);
 #endif
 #ifdef  TCP_TX_DELAY
-    PyModule_AddIntMacro(m, TCP_TX_DELAY);
+    ADD_INT_MACRO(m, TCP_TX_DELAY);
 #endif
 
     /* IPX options */
 #ifdef  IPX_TYPE
-    PyModule_AddIntMacro(m, IPX_TYPE);
+    ADD_INT_MACRO(m, IPX_TYPE);
 #endif
 
 /* Reliable Datagram Sockets */
 #ifdef RDS_CMSG_RDMA_ARGS
-    PyModule_AddIntMacro(m, RDS_CMSG_RDMA_ARGS);
+    ADD_INT_MACRO(m, RDS_CMSG_RDMA_ARGS);
 #endif
 #ifdef RDS_CMSG_RDMA_DEST
-    PyModule_AddIntMacro(m, RDS_CMSG_RDMA_DEST);
+    ADD_INT_MACRO(m, RDS_CMSG_RDMA_DEST);
 #endif
 #ifdef RDS_CMSG_RDMA_MAP
-    PyModule_AddIntMacro(m, RDS_CMSG_RDMA_MAP);
+    ADD_INT_MACRO(m, RDS_CMSG_RDMA_MAP);
 #endif
 #ifdef RDS_CMSG_RDMA_STATUS
-    PyModule_AddIntMacro(m, RDS_CMSG_RDMA_STATUS);
+    ADD_INT_MACRO(m, RDS_CMSG_RDMA_STATUS);
 #endif
 #ifdef RDS_CMSG_RDMA_UPDATE
-    PyModule_AddIntMacro(m, RDS_CMSG_RDMA_UPDATE);
+    ADD_INT_MACRO(m, RDS_CMSG_RDMA_UPDATE);
 #endif
 #ifdef RDS_RDMA_READWRITE
-    PyModule_AddIntMacro(m, RDS_RDMA_READWRITE);
+    ADD_INT_MACRO(m, RDS_RDMA_READWRITE);
 #endif
 #ifdef RDS_RDMA_FENCE
-    PyModule_AddIntMacro(m, RDS_RDMA_FENCE);
+    ADD_INT_MACRO(m, RDS_RDMA_FENCE);
 #endif
 #ifdef RDS_RDMA_INVALIDATE
-    PyModule_AddIntMacro(m, RDS_RDMA_INVALIDATE);
+    ADD_INT_MACRO(m, RDS_RDMA_INVALIDATE);
 #endif
 #ifdef RDS_RDMA_USE_ONCE
-    PyModule_AddIntMacro(m, RDS_RDMA_USE_ONCE);
+    ADD_INT_MACRO(m, RDS_RDMA_USE_ONCE);
 #endif
 #ifdef RDS_RDMA_DONTWAIT
-    PyModule_AddIntMacro(m, RDS_RDMA_DONTWAIT);
+    ADD_INT_MACRO(m, RDS_RDMA_DONTWAIT);
 #endif
 #ifdef RDS_RDMA_NOTIFY_ME
-    PyModule_AddIntMacro(m, RDS_RDMA_NOTIFY_ME);
+    ADD_INT_MACRO(m, RDS_RDMA_NOTIFY_ME);
 #endif
 #ifdef RDS_RDMA_SILENT
-    PyModule_AddIntMacro(m, RDS_RDMA_SILENT);
+    ADD_INT_MACRO(m, RDS_RDMA_SILENT);
 #endif
 
     /* get{addr,name}info parameters */
 #ifdef EAI_ADDRFAMILY
-    PyModule_AddIntMacro(m, EAI_ADDRFAMILY);
+    ADD_INT_MACRO(m, EAI_ADDRFAMILY);
 #endif
 #ifdef EAI_AGAIN
-    PyModule_AddIntMacro(m, EAI_AGAIN);
+    ADD_INT_MACRO(m, EAI_AGAIN);
 #endif
 #ifdef EAI_BADFLAGS
-    PyModule_AddIntMacro(m, EAI_BADFLAGS);
+    ADD_INT_MACRO(m, EAI_BADFLAGS);
 #endif
 #ifdef EAI_FAIL
-    PyModule_AddIntMacro(m, EAI_FAIL);
+    ADD_INT_MACRO(m, EAI_FAIL);
 #endif
 #ifdef EAI_FAMILY
-    PyModule_AddIntMacro(m, EAI_FAMILY);
+    ADD_INT_MACRO(m, EAI_FAMILY);
 #endif
 #ifdef EAI_MEMORY
-    PyModule_AddIntMacro(m, EAI_MEMORY);
+    ADD_INT_MACRO(m, EAI_MEMORY);
 #endif
 #ifdef EAI_NODATA
-    PyModule_AddIntMacro(m, EAI_NODATA);
+    ADD_INT_MACRO(m, EAI_NODATA);
 #endif
 #ifdef EAI_NONAME
-    PyModule_AddIntMacro(m, EAI_NONAME);
+    ADD_INT_MACRO(m, EAI_NONAME);
 #endif
 #ifdef EAI_OVERFLOW
-    PyModule_AddIntMacro(m, EAI_OVERFLOW);
+    ADD_INT_MACRO(m, EAI_OVERFLOW);
 #endif
 #ifdef EAI_SERVICE
-    PyModule_AddIntMacro(m, EAI_SERVICE);
+    ADD_INT_MACRO(m, EAI_SERVICE);
 #endif
 #ifdef EAI_SOCKTYPE
-    PyModule_AddIntMacro(m, EAI_SOCKTYPE);
+    ADD_INT_MACRO(m, EAI_SOCKTYPE);
 #endif
 #ifdef EAI_SYSTEM
-    PyModule_AddIntMacro(m, EAI_SYSTEM);
+    ADD_INT_MACRO(m, EAI_SYSTEM);
 #endif
 #ifdef EAI_BADHINTS
-    PyModule_AddIntMacro(m, EAI_BADHINTS);
+    ADD_INT_MACRO(m, EAI_BADHINTS);
 #endif
 #ifdef EAI_PROTOCOL
-    PyModule_AddIntMacro(m, EAI_PROTOCOL);
+    ADD_INT_MACRO(m, EAI_PROTOCOL);
 #endif
 #ifdef EAI_MAX
-    PyModule_AddIntMacro(m, EAI_MAX);
+    ADD_INT_MACRO(m, EAI_MAX);
 #endif
 #ifdef AI_PASSIVE
-    PyModule_AddIntMacro(m, AI_PASSIVE);
+    ADD_INT_MACRO(m, AI_PASSIVE);
 #endif
 #ifdef AI_CANONNAME
-    PyModule_AddIntMacro(m, AI_CANONNAME);
+    ADD_INT_MACRO(m, AI_CANONNAME);
 #endif
 #ifdef AI_NUMERICHOST
-    PyModule_AddIntMacro(m, AI_NUMERICHOST);
+    ADD_INT_MACRO(m, AI_NUMERICHOST);
 #endif
 #ifdef AI_NUMERICSERV
-    PyModule_AddIntMacro(m, AI_NUMERICSERV);
+    ADD_INT_MACRO(m, AI_NUMERICSERV);
 #endif
 #ifdef AI_MASK
-    PyModule_AddIntMacro(m, AI_MASK);
+    ADD_INT_MACRO(m, AI_MASK);
 #endif
 #ifdef AI_ALL
-    PyModule_AddIntMacro(m, AI_ALL);
+    ADD_INT_MACRO(m, AI_ALL);
 #endif
 #ifdef AI_V4MAPPED_CFG
-    PyModule_AddIntMacro(m, AI_V4MAPPED_CFG);
+    ADD_INT_MACRO(m, AI_V4MAPPED_CFG);
 #endif
 #ifdef AI_ADDRCONFIG
-    PyModule_AddIntMacro(m, AI_ADDRCONFIG);
+    ADD_INT_MACRO(m, AI_ADDRCONFIG);
 #endif
 #ifdef AI_V4MAPPED
-    PyModule_AddIntMacro(m, AI_V4MAPPED);
+    ADD_INT_MACRO(m, AI_V4MAPPED);
 #endif
 #ifdef AI_DEFAULT
-    PyModule_AddIntMacro(m, AI_DEFAULT);
+    ADD_INT_MACRO(m, AI_DEFAULT);
 #endif
 #ifdef NI_MAXHOST
-    PyModule_AddIntMacro(m, NI_MAXHOST);
+    ADD_INT_MACRO(m, NI_MAXHOST);
 #endif
 #ifdef NI_MAXSERV
-    PyModule_AddIntMacro(m, NI_MAXSERV);
+    ADD_INT_MACRO(m, NI_MAXSERV);
 #endif
 #ifdef NI_NOFQDN
-    PyModule_AddIntMacro(m, NI_NOFQDN);
+    ADD_INT_MACRO(m, NI_NOFQDN);
 #endif
 #ifdef NI_NUMERICHOST
-    PyModule_AddIntMacro(m, NI_NUMERICHOST);
+    ADD_INT_MACRO(m, NI_NUMERICHOST);
 #endif
 #ifdef NI_NAMEREQD
-    PyModule_AddIntMacro(m, NI_NAMEREQD);
+    ADD_INT_MACRO(m, NI_NAMEREQD);
 #endif
 #ifdef NI_NUMERICSERV
-    PyModule_AddIntMacro(m, NI_NUMERICSERV);
+    ADD_INT_MACRO(m, NI_NUMERICSERV);
 #endif
 #ifdef NI_DGRAM
-    PyModule_AddIntMacro(m, NI_DGRAM);
+    ADD_INT_MACRO(m, NI_DGRAM);
 #endif
 
     /* shutdown() parameters */
 #ifdef SHUT_RD
-    PyModule_AddIntMacro(m, SHUT_RD);
+    ADD_INT_MACRO(m, SHUT_RD);
 #elif defined(SD_RECEIVE)
-    PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
+    ADD_INT_CONST(m, "SHUT_RD", SD_RECEIVE);
 #else
-    PyModule_AddIntConstant(m, "SHUT_RD", 0);
+    ADD_INT_CONST(m, "SHUT_RD", 0);
 #endif
 #ifdef SHUT_WR
-    PyModule_AddIntMacro(m, SHUT_WR);
+    ADD_INT_MACRO(m, SHUT_WR);
 #elif defined(SD_SEND)
-    PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
+    ADD_INT_CONST(m, "SHUT_WR", SD_SEND);
 #else
-    PyModule_AddIntConstant(m, "SHUT_WR", 1);
+    ADD_INT_CONST(m, "SHUT_WR", 1);
 #endif
 #ifdef SHUT_RDWR
-    PyModule_AddIntMacro(m, SHUT_RDWR);
+    ADD_INT_MACRO(m, SHUT_RDWR);
 #elif defined(SD_BOTH)
-    PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
+    ADD_INT_CONST(m, "SHUT_RDWR", SD_BOTH);
 #else
-    PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
+    ADD_INT_CONST(m, "SHUT_RDWR", 2);
 #endif
 
 #ifdef SIO_RCVALL
@@ -8741,22 +8774,26 @@ PyInit__socket(void)
 #endif
         };
         int i;
-        for(i = 0; i<Py_ARRAY_LENGTH(codes); ++i) {
-            PyObject *tmp;
-            tmp = PyLong_FromUnsignedLong(codes[i]);
-            if (tmp == NULL)
-                return NULL;
-            PyModule_AddObject(m, names[i], tmp);
+        for (i = 0; i < Py_ARRAY_LENGTH(codes); ++i) {
+            PyObject *tmp = PyLong_FromUnsignedLong(codes[i]);
+            if (tmp == NULL) {
+                goto error;
+            }
+            int rc = PyModule_AddObjectRef(m, names[i], tmp);
+            Py_DECREF(tmp);
+            if (rc < 0) {
+                goto error;
+            }
         }
     }
-    PyModule_AddIntMacro(m, RCVALL_OFF);
-    PyModule_AddIntMacro(m, RCVALL_ON);
-    PyModule_AddIntMacro(m, RCVALL_SOCKETLEVELONLY);
+    ADD_INT_MACRO(m, RCVALL_OFF);
+    ADD_INT_MACRO(m, RCVALL_ON);
+    ADD_INT_MACRO(m, RCVALL_SOCKETLEVELONLY);
 #ifdef RCVALL_IPLEVEL
-    PyModule_AddIntMacro(m, RCVALL_IPLEVEL);
+    ADD_INT_MACRO(m, RCVALL_IPLEVEL);
 #endif
 #ifdef RCVALL_MAX
-    PyModule_AddIntMacro(m, RCVALL_MAX);
+    ADD_INT_MACRO(m, RCVALL_MAX);
 #endif
 #endif /* _MSTCPIP_ */
 
@@ -8768,10 +8805,17 @@ PyInit__socket(void)
 #ifdef MS_WINDOWS
     /* remove some flags on older version Windows during run-time */
     if (remove_unusable_flags(m) < 0) {
-        Py_DECREF(m);
-        return NULL;
+        goto error;
     }
 #endif
 
+#undef ADD_INT_MACRO
+#undef ADD_INT_CONST
+#undef ADD_STR_CONST
+
     return m;
+
+error:
+    Py_XDECREF(m);
+    return NULL;
 }