[Python-checkins] cpython: Issue #17917: Use PyModule_AddIntMacro() instead of PyModule_AddIntConstant()
charles-francois.natali
python-checkins at python.org
Mon May 20 19:14:08 CEST 2013
http://hg.python.org/cpython/rev/12cbb5183d98
changeset: 83867:12cbb5183d98
user: Charles-Francois Natali <cf.natali at gmail.com>
date: Mon May 20 19:13:19 2013 +0200
summary:
Issue #17917: Use PyModule_AddIntMacro() instead of PyModule_AddIntConstant()
when applicable.
files:
Modules/_datetimemodule.c | 4 +-
Modules/_testbuffer.c | 60 +-
Modules/fcntlmodule.c | 163 ++---
Modules/posixmodule.c | 244 ++++----
Modules/resource.c | 34 +-
Modules/selectmodule.c | 50 +-
Modules/socketmodule.c | 666 ++++++++++++-------------
Modules/symtablemodule.c | 32 +-
Modules/syslogmodule.c | 66 +-
Modules/zlibmodule.c | 26 +-
PC/_msi.c | 64 +-
Python/Python-ast.c | 2 +-
12 files changed, 692 insertions(+), 719 deletions(-)
diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -5299,8 +5299,8 @@
return NULL;
/* module initialization */
- PyModule_AddIntConstant(m, "MINYEAR", MINYEAR);
- PyModule_AddIntConstant(m, "MAXYEAR", MAXYEAR);
+ PyModule_AddIntMacro(m, MINYEAR);
+ PyModule_AddIntMacro(m, MAXYEAR);
Py_INCREF(&PyDateTime_DateType);
PyModule_AddObject(m, "date", (PyObject *) &PyDateTime_DateType);
diff --git a/Modules/_testbuffer.c b/Modules/_testbuffer.c
--- a/Modules/_testbuffer.c
+++ b/Modules/_testbuffer.c
@@ -2837,36 +2837,36 @@
if (simple_format == NULL)
return NULL;
- PyModule_AddIntConstant(m, "ND_MAX_NDIM", ND_MAX_NDIM);
- PyModule_AddIntConstant(m, "ND_VAREXPORT", ND_VAREXPORT);
- PyModule_AddIntConstant(m, "ND_WRITABLE", ND_WRITABLE);
- PyModule_AddIntConstant(m, "ND_FORTRAN", ND_FORTRAN);
- PyModule_AddIntConstant(m, "ND_SCALAR", ND_SCALAR);
- PyModule_AddIntConstant(m, "ND_PIL", ND_PIL);
- PyModule_AddIntConstant(m, "ND_GETBUF_FAIL", ND_GETBUF_FAIL);
- PyModule_AddIntConstant(m, "ND_GETBUF_UNDEFINED", ND_GETBUF_UNDEFINED);
- PyModule_AddIntConstant(m, "ND_REDIRECT", ND_REDIRECT);
-
- PyModule_AddIntConstant(m, "PyBUF_SIMPLE", PyBUF_SIMPLE);
- PyModule_AddIntConstant(m, "PyBUF_WRITABLE", PyBUF_WRITABLE);
- PyModule_AddIntConstant(m, "PyBUF_FORMAT", PyBUF_FORMAT);
- PyModule_AddIntConstant(m, "PyBUF_ND", PyBUF_ND);
- PyModule_AddIntConstant(m, "PyBUF_STRIDES", PyBUF_STRIDES);
- PyModule_AddIntConstant(m, "PyBUF_INDIRECT", PyBUF_INDIRECT);
- PyModule_AddIntConstant(m, "PyBUF_C_CONTIGUOUS", PyBUF_C_CONTIGUOUS);
- PyModule_AddIntConstant(m, "PyBUF_F_CONTIGUOUS", PyBUF_F_CONTIGUOUS);
- PyModule_AddIntConstant(m, "PyBUF_ANY_CONTIGUOUS", PyBUF_ANY_CONTIGUOUS);
- PyModule_AddIntConstant(m, "PyBUF_FULL", PyBUF_FULL);
- PyModule_AddIntConstant(m, "PyBUF_FULL_RO", PyBUF_FULL_RO);
- PyModule_AddIntConstant(m, "PyBUF_RECORDS", PyBUF_RECORDS);
- PyModule_AddIntConstant(m, "PyBUF_RECORDS_RO", PyBUF_RECORDS_RO);
- PyModule_AddIntConstant(m, "PyBUF_STRIDED", PyBUF_STRIDED);
- PyModule_AddIntConstant(m, "PyBUF_STRIDED_RO", PyBUF_STRIDED_RO);
- PyModule_AddIntConstant(m, "PyBUF_CONTIG", PyBUF_CONTIG);
- PyModule_AddIntConstant(m, "PyBUF_CONTIG_RO", PyBUF_CONTIG_RO);
-
- PyModule_AddIntConstant(m, "PyBUF_READ", PyBUF_READ);
- PyModule_AddIntConstant(m, "PyBUF_WRITE", PyBUF_WRITE);
+ PyModule_AddIntMacro(m, ND_MAX_NDIM);
+ PyModule_AddIntMacro(m, ND_VAREXPORT);
+ PyModule_AddIntMacro(m, ND_WRITABLE);
+ PyModule_AddIntMacro(m, ND_FORTRAN);
+ PyModule_AddIntMacro(m, ND_SCALAR);
+ PyModule_AddIntMacro(m, ND_PIL);
+ PyModule_AddIntMacro(m, ND_GETBUF_FAIL);
+ PyModule_AddIntMacro(m, ND_GETBUF_UNDEFINED);
+ PyModule_AddIntMacro(m, ND_REDIRECT);
+
+ PyModule_AddIntMacro(m, PyBUF_SIMPLE);
+ PyModule_AddIntMacro(m, PyBUF_WRITABLE);
+ PyModule_AddIntMacro(m, PyBUF_FORMAT);
+ PyModule_AddIntMacro(m, PyBUF_ND);
+ PyModule_AddIntMacro(m, PyBUF_STRIDES);
+ PyModule_AddIntMacro(m, PyBUF_INDIRECT);
+ PyModule_AddIntMacro(m, PyBUF_C_CONTIGUOUS);
+ PyModule_AddIntMacro(m, PyBUF_F_CONTIGUOUS);
+ PyModule_AddIntMacro(m, PyBUF_ANY_CONTIGUOUS);
+ PyModule_AddIntMacro(m, PyBUF_FULL);
+ PyModule_AddIntMacro(m, PyBUF_FULL_RO);
+ PyModule_AddIntMacro(m, PyBUF_RECORDS);
+ PyModule_AddIntMacro(m, PyBUF_RECORDS_RO);
+ PyModule_AddIntMacro(m, PyBUF_STRIDED);
+ PyModule_AddIntMacro(m, PyBUF_STRIDED_RO);
+ PyModule_AddIntMacro(m, PyBUF_CONTIG);
+ PyModule_AddIntMacro(m, PyBUF_CONTIG_RO);
+
+ PyModule_AddIntMacro(m, PyBUF_READ);
+ PyModule_AddIntMacro(m, PyBUF_WRITE);
return m;
}
diff --git a/Modules/fcntlmodule.c b/Modules/fcntlmodule.c
--- a/Modules/fcntlmodule.c
+++ b/Modules/fcntlmodule.c
@@ -424,191 +424,179 @@
/* Module initialisation */
-static int
-ins(PyObject* d, char* symbol, long value)
-{
- PyObject* v = PyLong_FromLong(value);
- if (!v || PyDict_SetItemString(d, symbol, v) < 0)
- return -1;
-
- Py_DECREF(v);
- return 0;
-}
-
-#define INS(x) if (ins(d, #x, (long)x)) return -1
static int
-all_ins(PyObject* d)
+all_ins(PyObject* m)
{
- if (ins(d, "LOCK_SH", (long)LOCK_SH)) return -1;
- if (ins(d, "LOCK_EX", (long)LOCK_EX)) return -1;
- if (ins(d, "LOCK_NB", (long)LOCK_NB)) return -1;
- if (ins(d, "LOCK_UN", (long)LOCK_UN)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_SH)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_EX)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_NB)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_UN)) return -1;
/* GNU extensions, as of glibc 2.2.4 */
#ifdef LOCK_MAND
- if (ins(d, "LOCK_MAND", (long)LOCK_MAND)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_MAND)) return -1;
#endif
#ifdef LOCK_READ
- if (ins(d, "LOCK_READ", (long)LOCK_READ)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_READ)) return -1;
#endif
#ifdef LOCK_WRITE
- if (ins(d, "LOCK_WRITE", (long)LOCK_WRITE)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_WRITE)) return -1;
#endif
#ifdef LOCK_RW
- if (ins(d, "LOCK_RW", (long)LOCK_RW)) return -1;
+ if (PyModule_AddIntMacro(m, LOCK_RW)) return -1;
#endif
#ifdef F_DUPFD
- if (ins(d, "F_DUPFD", (long)F_DUPFD)) return -1;
+ if (PyModule_AddIntMacro(m, F_DUPFD)) return -1;
#endif
#ifdef F_DUPFD_CLOEXEC
- if (ins(d, "F_DUPFD_CLOEXEC", (long)F_DUPFD_CLOEXEC)) return -1;
+ if (PyModule_AddIntMacro(m, F_DUPFD_CLOEXEC)) return -1;
#endif
#ifdef F_GETFD
- if (ins(d, "F_GETFD", (long)F_GETFD)) return -1;
+ if (PyModule_AddIntMacro(m, F_GETFD)) return -1;
#endif
#ifdef F_SETFD
- if (ins(d, "F_SETFD", (long)F_SETFD)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETFD)) return -1;
#endif
#ifdef F_GETFL
- if (ins(d, "F_GETFL", (long)F_GETFL)) return -1;
+ if (PyModule_AddIntMacro(m, F_GETFL)) return -1;
#endif
#ifdef F_SETFL
- if (ins(d, "F_SETFL", (long)F_SETFL)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETFL)) return -1;
#endif
#ifdef F_GETLK
- if (ins(d, "F_GETLK", (long)F_GETLK)) return -1;
+ if (PyModule_AddIntMacro(m, F_GETLK)) return -1;
#endif
#ifdef F_SETLK
- if (ins(d, "F_SETLK", (long)F_SETLK)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETLK)) return -1;
#endif
#ifdef F_SETLKW
- if (ins(d, "F_SETLKW", (long)F_SETLKW)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETLKW)) return -1;
#endif
#ifdef F_GETOWN
- if (ins(d, "F_GETOWN", (long)F_GETOWN)) return -1;
+ if (PyModule_AddIntMacro(m, F_GETOWN)) return -1;
#endif
#ifdef F_SETOWN
- if (ins(d, "F_SETOWN", (long)F_SETOWN)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETOWN)) return -1;
#endif
#ifdef F_GETSIG
- if (ins(d, "F_GETSIG", (long)F_GETSIG)) return -1;
+ if (PyModule_AddIntMacro(m, F_GETSIG)) return -1;
#endif
#ifdef F_SETSIG
- if (ins(d, "F_SETSIG", (long)F_SETSIG)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETSIG)) return -1;
#endif
#ifdef F_RDLCK
- if (ins(d, "F_RDLCK", (long)F_RDLCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_RDLCK)) return -1;
#endif
#ifdef F_WRLCK
- if (ins(d, "F_WRLCK", (long)F_WRLCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_WRLCK)) return -1;
#endif
#ifdef F_UNLCK
- if (ins(d, "F_UNLCK", (long)F_UNLCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_UNLCK)) return -1;
#endif
/* LFS constants */
#ifdef F_GETLK64
- if (ins(d, "F_GETLK64", (long)F_GETLK64)) return -1;
+ if (PyModule_AddIntMacro(m, F_GETLK64)) return -1;
#endif
#ifdef F_SETLK64
- if (ins(d, "F_SETLK64", (long)F_SETLK64)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETLK64)) return -1;
#endif
#ifdef F_SETLKW64
- if (ins(d, "F_SETLKW64", (long)F_SETLKW64)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETLKW64)) return -1;
#endif
/* GNU extensions, as of glibc 2.2.4. */
#ifdef FASYNC
- if (ins(d, "FASYNC", (long)FASYNC)) return -1;
+ if (PyModule_AddIntMacro(m, FASYNC)) return -1;
#endif
#ifdef F_SETLEASE
- if (ins(d, "F_SETLEASE", (long)F_SETLEASE)) return -1;
+ if (PyModule_AddIntMacro(m, F_SETLEASE)) return -1;
#endif
#ifdef F_GETLEASE
- if (ins(d, "F_GETLEASE", (long)F_GETLEASE)) return -1;
+ if (PyModule_AddIntMacro(m, F_GETLEASE)) return -1;
#endif
#ifdef F_NOTIFY
- if (ins(d, "F_NOTIFY", (long)F_NOTIFY)) return -1;
+ if (PyModule_AddIntMacro(m, F_NOTIFY)) return -1;
#endif
/* Old BSD flock(). */
#ifdef F_EXLCK
- if (ins(d, "F_EXLCK", (long)F_EXLCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_EXLCK)) return -1;
#endif
#ifdef F_SHLCK
- if (ins(d, "F_SHLCK", (long)F_SHLCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_SHLCK)) return -1;
#endif
/* OS X specifics */
#ifdef F_FULLFSYNC
- if (ins(d, "F_FULLFSYNC", (long)F_FULLFSYNC)) return -1;
+ if (PyModule_AddIntMacro(m, F_FULLFSYNC)) return -1;
#endif
#ifdef F_NOCACHE
- if (ins(d, "F_NOCACHE", (long)F_NOCACHE)) return -1;
+ if (PyModule_AddIntMacro(m, F_NOCACHE)) return -1;
#endif
/* For F_{GET|SET}FL */
#ifdef FD_CLOEXEC
- if (ins(d, "FD_CLOEXEC", (long)FD_CLOEXEC)) return -1;
+ if (PyModule_AddIntMacro(m, FD_CLOEXEC)) return -1;
#endif
/* For F_NOTIFY */
#ifdef DN_ACCESS
- if (ins(d, "DN_ACCESS", (long)DN_ACCESS)) return -1;
+ if (PyModule_AddIntMacro(m, DN_ACCESS)) return -1;
#endif
#ifdef DN_MODIFY
- if (ins(d, "DN_MODIFY", (long)DN_MODIFY)) return -1;
+ if (PyModule_AddIntMacro(m, DN_MODIFY)) return -1;
#endif
#ifdef DN_CREATE
- if (ins(d, "DN_CREATE", (long)DN_CREATE)) return -1;
+ if (PyModule_AddIntMacro(m, DN_CREATE)) return -1;
#endif
#ifdef DN_DELETE
- if (ins(d, "DN_DELETE", (long)DN_DELETE)) return -1;
+ if (PyModule_AddIntMacro(m, DN_DELETE)) return -1;
#endif
#ifdef DN_RENAME
- if (ins(d, "DN_RENAME", (long)DN_RENAME)) return -1;
+ if (PyModule_AddIntMacro(m, DN_RENAME)) return -1;
#endif
#ifdef DN_ATTRIB
- if (ins(d, "DN_ATTRIB", (long)DN_ATTRIB)) return -1;
+ if (PyModule_AddIntMacro(m, DN_ATTRIB)) return -1;
#endif
#ifdef DN_MULTISHOT
- if (ins(d, "DN_MULTISHOT", (long)DN_MULTISHOT)) return -1;
+ if (PyModule_AddIntMacro(m, DN_MULTISHOT)) return -1;
#endif
#ifdef HAVE_STROPTS_H
/* Unix 98 guarantees that these are in stropts.h. */
- INS(I_PUSH);
- INS(I_POP);
- INS(I_LOOK);
- INS(I_FLUSH);
- INS(I_FLUSHBAND);
- INS(I_SETSIG);
- INS(I_GETSIG);
- INS(I_FIND);
- INS(I_PEEK);
- INS(I_SRDOPT);
- INS(I_GRDOPT);
- INS(I_NREAD);
- INS(I_FDINSERT);
- INS(I_STR);
- INS(I_SWROPT);
+ if (PyModule_AddIntMacro(m, I_PUSH)) return -1;
+ if (PyModule_AddIntMacro(m, I_POP)) return -1;
+ if (PyModule_AddIntMacro(m, I_LOOK)) return -1;
+ if (PyModule_AddIntMacro(m, I_FLUSH)) return -1;
+ if (PyModule_AddIntMacro(m, I_FLUSHBAND)) return -1;
+ if (PyModule_AddIntMacro(m, I_SETSIG)) return -1;
+ if (PyModule_AddIntMacro(m, I_GETSIG)) return -1;
+ if (PyModule_AddIntMacro(m, I_FIND)) return -1;
+ if (PyModule_AddIntMacro(m, I_PEEK)) return -1;
+ if (PyModule_AddIntMacro(m, I_SRDOPT)) return -1;
+ if (PyModule_AddIntMacro(m, I_GRDOPT)) return -1;
+ if (PyModule_AddIntMacro(m, I_NREAD)) return -1;
+ if (PyModule_AddIntMacro(m, I_FDINSERT)) return -1;
+ if (PyModule_AddIntMacro(m, I_STR)) return -1;
+ if (PyModule_AddIntMacro(m, I_SWROPT)) return -1;
#ifdef I_GWROPT
/* despite the comment above, old-ish glibcs miss a couple... */
- INS(I_GWROPT);
+ if (PyModule_AddIntMacro(m, I_GWROPT)) return -1;
#endif
- INS(I_SENDFD);
- INS(I_RECVFD);
- INS(I_LIST);
- INS(I_ATMARK);
- INS(I_CKBAND);
- INS(I_GETBAND);
- INS(I_CANPUT);
- INS(I_SETCLTIME);
+ if (PyModule_AddIntMacro(m, I_SENDFD)) return -1;
+ if (PyModule_AddIntMacro(m, I_RECVFD)) return -1;
+ if (PyModule_AddIntMacro(m, I_LIST)) return -1;
+ if (PyModule_AddIntMacro(m, I_ATMARK)) return -1;
+ if (PyModule_AddIntMacro(m, I_CKBAND)) return -1;
+ if (PyModule_AddIntMacro(m, I_GETBAND)) return -1;
+ if (PyModule_AddIntMacro(m, I_CANPUT)) return -1;
+ if (PyModule_AddIntMacro(m, I_SETCLTIME)) return -1;
#ifdef I_GETCLTIME
- INS(I_GETCLTIME);
+ if (PyModule_AddIntMacro(m, I_GETCLTIME)) return -1;
#endif
- INS(I_LINK);
- INS(I_UNLINK);
- INS(I_PLINK);
- INS(I_PUNLINK);
+ if (PyModule_AddIntMacro(m, I_LINK)) return -1;
+ if (PyModule_AddIntMacro(m, I_UNLINK)) return -1;
+ if (PyModule_AddIntMacro(m, I_PLINK)) return -1;
+ if (PyModule_AddIntMacro(m, I_PUNLINK)) return -1;
#endif
return 0;
@@ -630,7 +618,7 @@
PyMODINIT_FUNC
PyInit_fcntl(void)
{
- PyObject *m, *d;
+ PyObject *m;
/* Create the module and add the functions and documentation */
m = PyModule_Create(&fcntlmodule);
@@ -638,7 +626,6 @@
return NULL;
/* Add some symbolic constants to the module */
- d = PyModule_GetDict(m);
- all_ins(d);
+ all_ins(m);
return m;
}
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -10800,12 +10800,6 @@
};
-static int
-ins(PyObject *module, char *symbol, long value)
-{
- return PyModule_AddIntConstant(module, symbol, value);
-}
-
#if defined(HAVE_SYMLINK) && defined(MS_WINDOWS)
static int
enable_symlink()
@@ -10836,376 +10830,376 @@
#endif /* defined(HAVE_SYMLINK) && defined(MS_WINDOWS) */
static int
-all_ins(PyObject *d)
+all_ins(PyObject *m)
{
#ifdef F_OK
- if (ins(d, "F_OK", (long)F_OK)) return -1;
+ if (PyModule_AddIntMacro(m, F_OK)) return -1;
#endif
#ifdef R_OK
- if (ins(d, "R_OK", (long)R_OK)) return -1;
+ if (PyModule_AddIntMacro(m, R_OK)) return -1;
#endif
#ifdef W_OK
- if (ins(d, "W_OK", (long)W_OK)) return -1;
+ if (PyModule_AddIntMacro(m, W_OK)) return -1;
#endif
#ifdef X_OK
- if (ins(d, "X_OK", (long)X_OK)) return -1;
+ if (PyModule_AddIntMacro(m, X_OK)) return -1;
#endif
#ifdef NGROUPS_MAX
- if (ins(d, "NGROUPS_MAX", (long)NGROUPS_MAX)) return -1;
+ if (PyModule_AddIntMacro(m, NGROUPS_MAX)) return -1;
#endif
#ifdef TMP_MAX
- if (ins(d, "TMP_MAX", (long)TMP_MAX)) return -1;
+ if (PyModule_AddIntMacro(m, TMP_MAX)) return -1;
#endif
#ifdef WCONTINUED
- if (ins(d, "WCONTINUED", (long)WCONTINUED)) return -1;
+ if (PyModule_AddIntMacro(m, WCONTINUED)) return -1;
#endif
#ifdef WNOHANG
- if (ins(d, "WNOHANG", (long)WNOHANG)) return -1;
+ if (PyModule_AddIntMacro(m, WNOHANG)) return -1;
#endif
#ifdef WUNTRACED
- if (ins(d, "WUNTRACED", (long)WUNTRACED)) return -1;
+ if (PyModule_AddIntMacro(m, WUNTRACED)) return -1;
#endif
#ifdef O_RDONLY
- if (ins(d, "O_RDONLY", (long)O_RDONLY)) return -1;
+ if (PyModule_AddIntMacro(m, O_RDONLY)) return -1;
#endif
#ifdef O_WRONLY
- if (ins(d, "O_WRONLY", (long)O_WRONLY)) return -1;
+ if (PyModule_AddIntMacro(m, O_WRONLY)) return -1;
#endif
#ifdef O_RDWR
- if (ins(d, "O_RDWR", (long)O_RDWR)) return -1;
+ if (PyModule_AddIntMacro(m, O_RDWR)) return -1;
#endif
#ifdef O_NDELAY
- if (ins(d, "O_NDELAY", (long)O_NDELAY)) return -1;
+ if (PyModule_AddIntMacro(m, O_NDELAY)) return -1;
#endif
#ifdef O_NONBLOCK
- if (ins(d, "O_NONBLOCK", (long)O_NONBLOCK)) return -1;
+ if (PyModule_AddIntMacro(m, O_NONBLOCK)) return -1;
#endif
#ifdef O_APPEND
- if (ins(d, "O_APPEND", (long)O_APPEND)) return -1;
+ if (PyModule_AddIntMacro(m, O_APPEND)) return -1;
#endif
#ifdef O_DSYNC
- if (ins(d, "O_DSYNC", (long)O_DSYNC)) return -1;
+ if (PyModule_AddIntMacro(m, O_DSYNC)) return -1;
#endif
#ifdef O_RSYNC
- if (ins(d, "O_RSYNC", (long)O_RSYNC)) return -1;
+ if (PyModule_AddIntMacro(m, O_RSYNC)) return -1;
#endif
#ifdef O_SYNC
- if (ins(d, "O_SYNC", (long)O_SYNC)) return -1;
+ if (PyModule_AddIntMacro(m, O_SYNC)) return -1;
#endif
#ifdef O_NOCTTY
- if (ins(d, "O_NOCTTY", (long)O_NOCTTY)) return -1;
+ if (PyModule_AddIntMacro(m, O_NOCTTY)) return -1;
#endif
#ifdef O_CREAT
- if (ins(d, "O_CREAT", (long)O_CREAT)) return -1;
+ if (PyModule_AddIntMacro(m, O_CREAT)) return -1;
#endif
#ifdef O_EXCL
- if (ins(d, "O_EXCL", (long)O_EXCL)) return -1;
+ if (PyModule_AddIntMacro(m, O_EXCL)) return -1;
#endif
#ifdef O_TRUNC
- if (ins(d, "O_TRUNC", (long)O_TRUNC)) return -1;
+ if (PyModule_AddIntMacro(m, O_TRUNC)) return -1;
#endif
#ifdef O_BINARY
- if (ins(d, "O_BINARY", (long)O_BINARY)) return -1;
+ if (PyModule_AddIntMacro(m, O_BINARY)) return -1;
#endif
#ifdef O_TEXT
- if (ins(d, "O_TEXT", (long)O_TEXT)) return -1;
+ if (PyModule_AddIntMacro(m, O_TEXT)) return -1;
#endif
#ifdef O_XATTR
- if (ins(d, "O_XATTR", (long)O_XATTR)) return -1;
+ if (PyModule_AddIntMacro(m, O_XATTR)) return -1;
#endif
#ifdef O_LARGEFILE
- if (ins(d, "O_LARGEFILE", (long)O_LARGEFILE)) return -1;
+ if (PyModule_AddIntMacro(m, O_LARGEFILE)) return -1;
#endif
#ifdef O_SHLOCK
- if (ins(d, "O_SHLOCK", (long)O_SHLOCK)) return -1;
+ if (PyModule_AddIntMacro(m, O_SHLOCK)) return -1;
#endif
#ifdef O_EXLOCK
- if (ins(d, "O_EXLOCK", (long)O_EXLOCK)) return -1;
+ if (PyModule_AddIntMacro(m, O_EXLOCK)) return -1;
#endif
#ifdef O_EXEC
- if (ins(d, "O_EXEC", (long)O_EXEC)) return -1;
+ if (PyModule_AddIntMacro(m, O_EXEC)) return -1;
#endif
#ifdef O_SEARCH
- if (ins(d, "O_SEARCH", (long)O_SEARCH)) return -1;
+ if (PyModule_AddIntMacro(m, O_SEARCH)) return -1;
#endif
#ifdef O_PATH
- if (ins(d, "O_PATH", (long)O_PATH)) return -1;
+ if (PyModule_AddIntMacro(m, O_PATH)) return -1;
#endif
#ifdef O_TTY_INIT
- if (ins(d, "O_TTY_INIT", (long)O_TTY_INIT)) return -1;
+ if (PyModule_AddIntMacro(m, O_TTY_INIT)) return -1;
#endif
#ifdef PRIO_PROCESS
- if (ins(d, "PRIO_PROCESS", (long)PRIO_PROCESS)) return -1;
+ if (PyModule_AddIntMacro(m, PRIO_PROCESS)) return -1;
#endif
#ifdef PRIO_PGRP
- if (ins(d, "PRIO_PGRP", (long)PRIO_PGRP)) return -1;
+ if (PyModule_AddIntMacro(m, PRIO_PGRP)) return -1;
#endif
#ifdef PRIO_USER
- if (ins(d, "PRIO_USER", (long)PRIO_USER)) return -1;
+ if (PyModule_AddIntMacro(m, PRIO_USER)) return -1;
#endif
#ifdef O_CLOEXEC
- if (ins(d, "O_CLOEXEC", (long)O_CLOEXEC)) return -1;
+ if (PyModule_AddIntMacro(m, O_CLOEXEC)) return -1;
#endif
#ifdef O_ACCMODE
- if (ins(d, "O_ACCMODE", (long)O_ACCMODE)) return -1;
+ if (PyModule_AddIntMacro(m, O_ACCMODE)) return -1;
#endif
#ifdef SEEK_HOLE
- if (ins(d, "SEEK_HOLE", (long)SEEK_HOLE)) return -1;
+ if (PyModule_AddIntMacro(m, SEEK_HOLE)) return -1;
#endif
#ifdef SEEK_DATA
- if (ins(d, "SEEK_DATA", (long)SEEK_DATA)) return -1;
+ if (PyModule_AddIntMacro(m, SEEK_DATA)) return -1;
#endif
/* MS Windows */
#ifdef O_NOINHERIT
/* Don't inherit in child processes. */
- if (ins(d, "O_NOINHERIT", (long)O_NOINHERIT)) return -1;
+ if (PyModule_AddIntMacro(m, O_NOINHERIT)) return -1;
#endif
#ifdef _O_SHORT_LIVED
/* Optimize for short life (keep in memory). */
/* MS forgot to define this one with a non-underscore form too. */
- if (ins(d, "O_SHORT_LIVED", (long)_O_SHORT_LIVED)) return -1;
+ if (PyModule_AddIntConstant(m, "O_SHORT_LIVED", _O_SHORT_LIVED)) return -1;
#endif
#ifdef O_TEMPORARY
/* Automatically delete when last handle is closed. */
- if (ins(d, "O_TEMPORARY", (long)O_TEMPORARY)) return -1;
+ if (PyModule_AddIntMacro(m, O_TEMPORARY)) return -1;
#endif
#ifdef O_RANDOM
/* Optimize for random access. */
- if (ins(d, "O_RANDOM", (long)O_RANDOM)) return -1;
+ if (PyModule_AddIntMacro(m, O_RANDOM)) return -1;
#endif
#ifdef O_SEQUENTIAL
/* Optimize for sequential access. */
- if (ins(d, "O_SEQUENTIAL", (long)O_SEQUENTIAL)) return -1;
+ if (PyModule_AddIntMacro(m, O_SEQUENTIAL)) return -1;
#endif
/* GNU extensions. */
#ifdef O_ASYNC
/* Send a SIGIO signal whenever input or output
becomes available on file descriptor */
- if (ins(d, "O_ASYNC", (long)O_ASYNC)) return -1;
+ if (PyModule_AddIntMacro(m, O_ASYNC)) return -1;
#endif
#ifdef O_DIRECT
/* Direct disk access. */
- if (ins(d, "O_DIRECT", (long)O_DIRECT)) return -1;
+ if (PyModule_AddIntMacro(m, O_DIRECT)) return -1;
#endif
#ifdef O_DIRECTORY
/* Must be a directory. */
- if (ins(d, "O_DIRECTORY", (long)O_DIRECTORY)) return -1;
+ if (PyModule_AddIntMacro(m, O_DIRECTORY)) return -1;
#endif
#ifdef O_NOFOLLOW
/* Do not follow links. */
- if (ins(d, "O_NOFOLLOW", (long)O_NOFOLLOW)) return -1;
+ if (PyModule_AddIntMacro(m, O_NOFOLLOW)) return -1;
#endif
#ifdef O_NOLINKS
/* Fails if link count of the named file is greater than 1 */
- if (ins(d, "O_NOLINKS", (long)O_NOLINKS)) return -1;
+ if (PyModule_AddIntMacro(m, O_NOLINKS)) return -1;
#endif
#ifdef O_NOATIME
/* Do not update the access time. */
- if (ins(d, "O_NOATIME", (long)O_NOATIME)) return -1;
+ if (PyModule_AddIntMacro(m, O_NOATIME)) return -1;
#endif
/* These come from sysexits.h */
#ifdef EX_OK
- if (ins(d, "EX_OK", (long)EX_OK)) return -1;
+ if (PyModule_AddIntMacro(m, EX_OK)) return -1;
#endif /* EX_OK */
#ifdef EX_USAGE
- if (ins(d, "EX_USAGE", (long)EX_USAGE)) return -1;
+ if (PyModule_AddIntMacro(m, EX_USAGE)) return -1;
#endif /* EX_USAGE */
#ifdef EX_DATAERR
- if (ins(d, "EX_DATAERR", (long)EX_DATAERR)) return -1;
+ if (PyModule_AddIntMacro(m, EX_DATAERR)) return -1;
#endif /* EX_DATAERR */
#ifdef EX_NOINPUT
- if (ins(d, "EX_NOINPUT", (long)EX_NOINPUT)) return -1;
+ if (PyModule_AddIntMacro(m, EX_NOINPUT)) return -1;
#endif /* EX_NOINPUT */
#ifdef EX_NOUSER
- if (ins(d, "EX_NOUSER", (long)EX_NOUSER)) return -1;
+ if (PyModule_AddIntMacro(m, EX_NOUSER)) return -1;
#endif /* EX_NOUSER */
#ifdef EX_NOHOST
- if (ins(d, "EX_NOHOST", (long)EX_NOHOST)) return -1;
+ if (PyModule_AddIntMacro(m, EX_NOHOST)) return -1;
#endif /* EX_NOHOST */
#ifdef EX_UNAVAILABLE
- if (ins(d, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE)) return -1;
+ if (PyModule_AddIntMacro(m, EX_UNAVAILABLE)) return -1;
#endif /* EX_UNAVAILABLE */
#ifdef EX_SOFTWARE
- if (ins(d, "EX_SOFTWARE", (long)EX_SOFTWARE)) return -1;
+ if (PyModule_AddIntMacro(m, EX_SOFTWARE)) return -1;
#endif /* EX_SOFTWARE */
#ifdef EX_OSERR
- if (ins(d, "EX_OSERR", (long)EX_OSERR)) return -1;
+ if (PyModule_AddIntMacro(m, EX_OSERR)) return -1;
#endif /* EX_OSERR */
#ifdef EX_OSFILE
- if (ins(d, "EX_OSFILE", (long)EX_OSFILE)) return -1;
+ if (PyModule_AddIntMacro(m, EX_OSFILE)) return -1;
#endif /* EX_OSFILE */
#ifdef EX_CANTCREAT
- if (ins(d, "EX_CANTCREAT", (long)EX_CANTCREAT)) return -1;
+ if (PyModule_AddIntMacro(m, EX_CANTCREAT)) return -1;
#endif /* EX_CANTCREAT */
#ifdef EX_IOERR
- if (ins(d, "EX_IOERR", (long)EX_IOERR)) return -1;
+ if (PyModule_AddIntMacro(m, EX_IOERR)) return -1;
#endif /* EX_IOERR */
#ifdef EX_TEMPFAIL
- if (ins(d, "EX_TEMPFAIL", (long)EX_TEMPFAIL)) return -1;
+ if (PyModule_AddIntMacro(m, EX_TEMPFAIL)) return -1;
#endif /* EX_TEMPFAIL */
#ifdef EX_PROTOCOL
- if (ins(d, "EX_PROTOCOL", (long)EX_PROTOCOL)) return -1;
+ if (PyModule_AddIntMacro(m, EX_PROTOCOL)) return -1;
#endif /* EX_PROTOCOL */
#ifdef EX_NOPERM
- if (ins(d, "EX_NOPERM", (long)EX_NOPERM)) return -1;
+ if (PyModule_AddIntMacro(m, EX_NOPERM)) return -1;
#endif /* EX_NOPERM */
#ifdef EX_CONFIG
- if (ins(d, "EX_CONFIG", (long)EX_CONFIG)) return -1;
+ if (PyModule_AddIntMacro(m, EX_CONFIG)) return -1;
#endif /* EX_CONFIG */
#ifdef EX_NOTFOUND
- if (ins(d, "EX_NOTFOUND", (long)EX_NOTFOUND)) return -1;
+ if (PyModule_AddIntMacro(m, EX_NOTFOUND)) return -1;
#endif /* EX_NOTFOUND */
/* statvfs */
#ifdef ST_RDONLY
- if (ins(d, "ST_RDONLY", (long)ST_RDONLY)) return -1;
+ if (PyModule_AddIntMacro(m, ST_RDONLY)) return -1;
#endif /* ST_RDONLY */
#ifdef ST_NOSUID
- if (ins(d, "ST_NOSUID", (long)ST_NOSUID)) return -1;
+ if (PyModule_AddIntMacro(m, ST_NOSUID)) return -1;
#endif /* ST_NOSUID */
/* FreeBSD sendfile() constants */
#ifdef SF_NODISKIO
- if (ins(d, "SF_NODISKIO", (long)SF_NODISKIO)) return -1;
+ if (PyModule_AddIntMacro(m, SF_NODISKIO)) return -1;
#endif
#ifdef SF_MNOWAIT
- if (ins(d, "SF_MNOWAIT", (long)SF_MNOWAIT)) return -1;
+ if (PyModule_AddIntMacro(m, SF_MNOWAIT)) return -1;
#endif
#ifdef SF_SYNC
- if (ins(d, "SF_SYNC", (long)SF_SYNC)) return -1;
+ if (PyModule_AddIntMacro(m, SF_SYNC)) return -1;
#endif
/* constants for posix_fadvise */
#ifdef POSIX_FADV_NORMAL
- if (ins(d, "POSIX_FADV_NORMAL", (long)POSIX_FADV_NORMAL)) return -1;
+ if (PyModule_AddIntMacro(m, POSIX_FADV_NORMAL)) return -1;
#endif
#ifdef POSIX_FADV_SEQUENTIAL
- if (ins(d, "POSIX_FADV_SEQUENTIAL", (long)POSIX_FADV_SEQUENTIAL)) return -1;
+ if (PyModule_AddIntMacro(m, POSIX_FADV_SEQUENTIAL)) return -1;
#endif
#ifdef POSIX_FADV_RANDOM
- if (ins(d, "POSIX_FADV_RANDOM", (long)POSIX_FADV_RANDOM)) return -1;
+ if (PyModule_AddIntMacro(m, POSIX_FADV_RANDOM)) return -1;
#endif
#ifdef POSIX_FADV_NOREUSE
- if (ins(d, "POSIX_FADV_NOREUSE", (long)POSIX_FADV_NOREUSE)) return -1;
+ if (PyModule_AddIntMacro(m, POSIX_FADV_NOREUSE)) return -1;
#endif
#ifdef POSIX_FADV_WILLNEED
- if (ins(d, "POSIX_FADV_WILLNEED", (long)POSIX_FADV_WILLNEED)) return -1;
+ if (PyModule_AddIntMacro(m, POSIX_FADV_WILLNEED)) return -1;
#endif
#ifdef POSIX_FADV_DONTNEED
- if (ins(d, "POSIX_FADV_DONTNEED", (long)POSIX_FADV_DONTNEED)) return -1;
+ if (PyModule_AddIntMacro(m, POSIX_FADV_DONTNEED)) return -1;
#endif
/* constants for waitid */
#if defined(HAVE_SYS_WAIT_H) && defined(HAVE_WAITID)
- if (ins(d, "P_PID", (long)P_PID)) return -1;
- if (ins(d, "P_PGID", (long)P_PGID)) return -1;
- if (ins(d, "P_ALL", (long)P_ALL)) return -1;
+ if (PyModule_AddIntMacro(m, P_PID)) return -1;
+ if (PyModule_AddIntMacro(m, P_PGID)) return -1;
+ if (PyModule_AddIntMacro(m, P_ALL)) return -1;
#endif
#ifdef WEXITED
- if (ins(d, "WEXITED", (long)WEXITED)) return -1;
+ if (PyModule_AddIntMacro(m, WEXITED)) return -1;
#endif
#ifdef WNOWAIT
- if (ins(d, "WNOWAIT", (long)WNOWAIT)) return -1;
+ if (PyModule_AddIntMacro(m, WNOWAIT)) return -1;
#endif
#ifdef WSTOPPED
- if (ins(d, "WSTOPPED", (long)WSTOPPED)) return -1;
+ if (PyModule_AddIntMacro(m, WSTOPPED)) return -1;
#endif
#ifdef CLD_EXITED
- if (ins(d, "CLD_EXITED", (long)CLD_EXITED)) return -1;
+ if (PyModule_AddIntMacro(m, CLD_EXITED)) return -1;
#endif
#ifdef CLD_DUMPED
- if (ins(d, "CLD_DUMPED", (long)CLD_DUMPED)) return -1;
+ if (PyModule_AddIntMacro(m, CLD_DUMPED)) return -1;
#endif
#ifdef CLD_TRAPPED
- if (ins(d, "CLD_TRAPPED", (long)CLD_TRAPPED)) return -1;
+ if (PyModule_AddIntMacro(m, CLD_TRAPPED)) return -1;
#endif
#ifdef CLD_CONTINUED
- if (ins(d, "CLD_CONTINUED", (long)CLD_CONTINUED)) return -1;
+ if (PyModule_AddIntMacro(m, CLD_CONTINUED)) return -1;
#endif
/* constants for lockf */
#ifdef F_LOCK
- if (ins(d, "F_LOCK", (long)F_LOCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_LOCK)) return -1;
#endif
#ifdef F_TLOCK
- if (ins(d, "F_TLOCK", (long)F_TLOCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_TLOCK)) return -1;
#endif
#ifdef F_ULOCK
- if (ins(d, "F_ULOCK", (long)F_ULOCK)) return -1;
+ if (PyModule_AddIntMacro(m, F_ULOCK)) return -1;
#endif
#ifdef F_TEST
- if (ins(d, "F_TEST", (long)F_TEST)) return -1;
+ if (PyModule_AddIntMacro(m, F_TEST)) return -1;
#endif
#ifdef HAVE_SPAWNV
- if (ins(d, "P_WAIT", (long)_P_WAIT)) return -1;
- if (ins(d, "P_NOWAIT", (long)_P_NOWAIT)) return -1;
- if (ins(d, "P_OVERLAY", (long)_OLD_P_OVERLAY)) return -1;
- if (ins(d, "P_NOWAITO", (long)_P_NOWAITO)) return -1;
- if (ins(d, "P_DETACH", (long)_P_DETACH)) return -1;
+ if (PyModule_AddIntConstant(m, "P_WAIT", _P_WAIT)) return -1;
+ if (PyModule_AddIntConstant(m, "P_NOWAIT", _P_NOWAIT)) return -1;
+ if (PyModule_AddIntConstant(m, "P_OVERLAY", _OLD_P_OVERLAY)) return -1;
+ if (PyModule_AddIntConstant(m, "P_NOWAITO", _P_NOWAITO)) return -1;
+ if (PyModule_AddIntConstant(m, "P_DETACH", _P_DETACH)) return -1;
#endif
#ifdef HAVE_SCHED_H
- if (ins(d, "SCHED_OTHER", (long)SCHED_OTHER)) return -1;
- if (ins(d, "SCHED_FIFO", (long)SCHED_FIFO)) return -1;
- if (ins(d, "SCHED_RR", (long)SCHED_RR)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_OTHER)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_FIFO)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_RR)) return -1;
#ifdef SCHED_SPORADIC
- if (ins(d, "SCHED_SPORADIC", (long)SCHED_SPORADIC) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_SPORADIC) return -1;
#endif
#ifdef SCHED_BATCH
- if (ins(d, "SCHED_BATCH", (long)SCHED_BATCH)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_BATCH)) return -1;
#endif
#ifdef SCHED_IDLE
- if (ins(d, "SCHED_IDLE", (long)SCHED_IDLE)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_IDLE)) return -1;
#endif
#ifdef SCHED_RESET_ON_FORK
- if (ins(d, "SCHED_RESET_ON_FORK", (long)SCHED_RESET_ON_FORK)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_RESET_ON_FORK)) return -1;
#endif
#ifdef SCHED_SYS
- if (ins(d, "SCHED_SYS", (long)SCHED_SYS)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_SYS)) return -1;
#endif
#ifdef SCHED_IA
- if (ins(d, "SCHED_IA", (long)SCHED_IA)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_IA)) return -1;
#endif
#ifdef SCHED_FSS
- if (ins(d, "SCHED_FSS", (long)SCHED_FSS)) return -1;
+ if (PyModule_AddIntMacro(m, SCHED_FSS)) return -1;
#endif
#ifdef SCHED_FX
- if (ins(d, "SCHED_FX", (long)SCHED_FSS)) return -1;
+ if (PyModule_AddIntConstant(m, "SCHED_FX", SCHED_FSS)) return -1;
#endif
#endif
#ifdef USE_XATTRS
- if (ins(d, "XATTR_CREATE", (long)XATTR_CREATE)) return -1;
- if (ins(d, "XATTR_REPLACE", (long)XATTR_REPLACE)) return -1;
- if (ins(d, "XATTR_SIZE_MAX", (long)XATTR_SIZE_MAX)) return -1;
+ if (PyModule_AddIntMacro(m, XATTR_CREATE)) return -1;
+ if (PyModule_AddIntMacro(m, XATTR_REPLACE)) return -1;
+ if (PyModule_AddIntMacro(m, XATTR_SIZE_MAX)) return -1;
#endif
#ifdef RTLD_LAZY
- if (PyModule_AddIntMacro(d, RTLD_LAZY)) return -1;
+ if (PyModule_AddIntMacro(m, RTLD_LAZY)) return -1;
#endif
#ifdef RTLD_NOW
- if (PyModule_AddIntMacro(d, RTLD_NOW)) return -1;
+ if (PyModule_AddIntMacro(m, RTLD_NOW)) return -1;
#endif
#ifdef RTLD_GLOBAL
- if (PyModule_AddIntMacro(d, RTLD_GLOBAL)) return -1;
+ if (PyModule_AddIntMacro(m, RTLD_GLOBAL)) return -1;
#endif
#ifdef RTLD_LOCAL
- if (PyModule_AddIntMacro(d, RTLD_LOCAL)) return -1;
+ if (PyModule_AddIntMacro(m, RTLD_LOCAL)) return -1;
#endif
#ifdef RTLD_NODELETE
- if (PyModule_AddIntMacro(d, RTLD_NODELETE)) return -1;
+ if (PyModule_AddIntMacro(m, RTLD_NODELETE)) return -1;
#endif
#ifdef RTLD_NOLOAD
- if (PyModule_AddIntMacro(d, RTLD_NOLOAD)) return -1;
+ if (PyModule_AddIntMacro(m, RTLD_NOLOAD)) return -1;
#endif
#ifdef RTLD_DEEPBIND
- if (PyModule_AddIntMacro(d, RTLD_DEEPBIND)) return -1;
+ if (PyModule_AddIntMacro(m, RTLD_DEEPBIND)) return -1;
#endif
return 0;
diff --git a/Modules/resource.c b/Modules/resource.c
--- a/Modules/resource.c
+++ b/Modules/resource.c
@@ -272,71 +272,71 @@
/* insert constants */
#ifdef RLIMIT_CPU
- PyModule_AddIntConstant(m, "RLIMIT_CPU", RLIMIT_CPU);
+ PyModule_AddIntMacro(m, RLIMIT_CPU);
#endif
#ifdef RLIMIT_FSIZE
- PyModule_AddIntConstant(m, "RLIMIT_FSIZE", RLIMIT_FSIZE);
+ PyModule_AddIntMacro(m, RLIMIT_FSIZE);
#endif
#ifdef RLIMIT_DATA
- PyModule_AddIntConstant(m, "RLIMIT_DATA", RLIMIT_DATA);
+ PyModule_AddIntMacro(m, RLIMIT_DATA);
#endif
#ifdef RLIMIT_STACK
- PyModule_AddIntConstant(m, "RLIMIT_STACK", RLIMIT_STACK);
+ PyModule_AddIntMacro(m, RLIMIT_STACK);
#endif
#ifdef RLIMIT_CORE
- PyModule_AddIntConstant(m, "RLIMIT_CORE", RLIMIT_CORE);
+ PyModule_AddIntMacro(m, RLIMIT_CORE);
#endif
#ifdef RLIMIT_NOFILE
- PyModule_AddIntConstant(m, "RLIMIT_NOFILE", RLIMIT_NOFILE);
+ PyModule_AddIntMacro(m, RLIMIT_NOFILE);
#endif
#ifdef RLIMIT_OFILE
- PyModule_AddIntConstant(m, "RLIMIT_OFILE", RLIMIT_OFILE);
+ PyModule_AddIntMacro(m, RLIMIT_OFILE);
#endif
#ifdef RLIMIT_VMEM
- PyModule_AddIntConstant(m, "RLIMIT_VMEM", RLIMIT_VMEM);
+ PyModule_AddIntMacro(m, RLIMIT_VMEM);
#endif
#ifdef RLIMIT_AS
- PyModule_AddIntConstant(m, "RLIMIT_AS", RLIMIT_AS);
+ PyModule_AddIntMacro(m, RLIMIT_AS);
#endif
#ifdef RLIMIT_RSS
- PyModule_AddIntConstant(m, "RLIMIT_RSS", RLIMIT_RSS);
+ PyModule_AddIntMacro(m, RLIMIT_RSS);
#endif
#ifdef RLIMIT_NPROC
- PyModule_AddIntConstant(m, "RLIMIT_NPROC", RLIMIT_NPROC);
+ PyModule_AddIntMacro(m, RLIMIT_NPROC);
#endif
#ifdef RLIMIT_MEMLOCK
- PyModule_AddIntConstant(m, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
+ PyModule_AddIntMacro(m, RLIMIT_MEMLOCK);
#endif
#ifdef RLIMIT_SBSIZE
- PyModule_AddIntConstant(m, "RLIMIT_SBSIZE", RLIMIT_SBSIZE);
+ PyModule_AddIntMacro(m, RLIMIT_SBSIZE);
#endif
#ifdef RUSAGE_SELF
- PyModule_AddIntConstant(m, "RUSAGE_SELF", RUSAGE_SELF);
+ PyModule_AddIntMacro(m, RUSAGE_SELF);
#endif
#ifdef RUSAGE_CHILDREN
- PyModule_AddIntConstant(m, "RUSAGE_CHILDREN", RUSAGE_CHILDREN);
+ PyModule_AddIntMacro(m, RUSAGE_CHILDREN);
#endif
#ifdef RUSAGE_BOTH
- PyModule_AddIntConstant(m, "RUSAGE_BOTH", RUSAGE_BOTH);
+ PyModule_AddIntMacro(m, RUSAGE_BOTH);
#endif
#ifdef RUSAGE_THREAD
- PyModule_AddIntConstant(m, "RUSAGE_THREAD", RUSAGE_THREAD);
+ PyModule_AddIntMacro(m, RUSAGE_THREAD);
#endif
#if defined(HAVE_LONG_LONG)
diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
--- a/Modules/selectmodule.c
+++ b/Modules/selectmodule.c
@@ -2183,7 +2183,7 @@
#undef PIPE_BUF
#define PIPE_BUF 512
#endif
- PyModule_AddIntConstant(m, "PIPE_BUF", PIPE_BUF);
+ PyModule_AddIntMacro(m, PIPE_BUF);
#endif
#if defined(HAVE_POLL) && !defined(HAVE_BROKEN_POLL)
@@ -2198,27 +2198,27 @@
#endif
if (PyType_Ready(&poll_Type) < 0)
return NULL;
- 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);
+ PyModule_AddIntMacro(m, POLLIN);
+ PyModule_AddIntMacro(m, POLLPRI);
+ PyModule_AddIntMacro(m, POLLOUT);
+ PyModule_AddIntMacro(m, POLLERR);
+ PyModule_AddIntMacro(m, POLLHUP);
+ PyModule_AddIntMacro(m, POLLNVAL);
#ifdef POLLRDNORM
- PyModule_AddIntConstant(m, "POLLRDNORM", POLLRDNORM);
+ PyModule_AddIntMacro(m, POLLRDNORM);
#endif
#ifdef POLLRDBAND
- PyModule_AddIntConstant(m, "POLLRDBAND", POLLRDBAND);
+ PyModule_AddIntMacro(m, POLLRDBAND);
#endif
#ifdef POLLWRNORM
- PyModule_AddIntConstant(m, "POLLWRNORM", POLLWRNORM);
+ PyModule_AddIntMacro(m, POLLWRNORM);
#endif
#ifdef POLLWRBAND
- PyModule_AddIntConstant(m, "POLLWRBAND", POLLWRBAND);
+ PyModule_AddIntMacro(m, POLLWRBAND);
#endif
#ifdef POLLMSG
- PyModule_AddIntConstant(m, "POLLMSG", POLLMSG);
+ PyModule_AddIntMacro(m, POLLMSG);
#endif
}
#endif /* HAVE_POLL */
@@ -2236,25 +2236,25 @@
Py_INCREF(&pyEpoll_Type);
PyModule_AddObject(m, "epoll", (PyObject *) &pyEpoll_Type);
- PyModule_AddIntConstant(m, "EPOLLIN", EPOLLIN);
- PyModule_AddIntConstant(m, "EPOLLOUT", EPOLLOUT);
- PyModule_AddIntConstant(m, "EPOLLPRI", EPOLLPRI);
- PyModule_AddIntConstant(m, "EPOLLERR", EPOLLERR);
- PyModule_AddIntConstant(m, "EPOLLHUP", EPOLLHUP);
- PyModule_AddIntConstant(m, "EPOLLET", EPOLLET);
+ PyModule_AddIntMacro(m, EPOLLIN);
+ PyModule_AddIntMacro(m, EPOLLOUT);
+ PyModule_AddIntMacro(m, EPOLLPRI);
+ PyModule_AddIntMacro(m, EPOLLERR);
+ PyModule_AddIntMacro(m, EPOLLHUP);
+ PyModule_AddIntMacro(m, EPOLLET);
#ifdef EPOLLONESHOT
/* Kernel 2.6.2+ */
- PyModule_AddIntConstant(m, "EPOLLONESHOT", EPOLLONESHOT);
+ PyModule_AddIntMacro(m, EPOLLONESHOT);
#endif
/* PyModule_AddIntConstant(m, "EPOLL_RDHUP", EPOLLRDHUP); */
- PyModule_AddIntConstant(m, "EPOLLRDNORM", EPOLLRDNORM);
- PyModule_AddIntConstant(m, "EPOLLRDBAND", EPOLLRDBAND);
- PyModule_AddIntConstant(m, "EPOLLWRNORM", EPOLLWRNORM);
- PyModule_AddIntConstant(m, "EPOLLWRBAND", EPOLLWRBAND);
- PyModule_AddIntConstant(m, "EPOLLMSG", EPOLLMSG);
+ PyModule_AddIntMacro(m, EPOLLRDNORM);
+ PyModule_AddIntMacro(m, EPOLLRDBAND);
+ PyModule_AddIntMacro(m, EPOLLWRNORM);
+ PyModule_AddIntMacro(m, EPOLLWRBAND);
+ PyModule_AddIntMacro(m, EPOLLMSG);
#ifdef EPOLL_CLOEXEC
- PyModule_AddIntConstant(m, "EPOLL_CLOEXEC", EPOLL_CLOEXEC);
+ PyModule_AddIntMacro(m, EPOLL_CLOEXEC);
#endif
#endif /* HAVE_EPOLL */
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -5556,184 +5556,184 @@
/* Address families (we only support AF_INET and AF_UNIX) */
#ifdef AF_UNSPEC
- PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
-#endif
- PyModule_AddIntConstant(m, "AF_INET", AF_INET);
+ PyModule_AddIntMacro(m, AF_UNSPEC);
+#endif
+ PyModule_AddIntMacro(m, AF_INET);
#ifdef AF_INET6
- PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
+ PyModule_AddIntMacro(m, AF_INET6);
#endif /* AF_INET6 */
#if defined(AF_UNIX)
- PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
+ PyModule_AddIntMacro(m, AF_UNIX);
#endif /* AF_UNIX */
#ifdef AF_AX25
/* Amateur Radio AX.25 */
- PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
+ PyModule_AddIntMacro(m, AF_AX25);
#endif
#ifdef AF_IPX
- PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
+ PyModule_AddIntMacro(m, AF_IPX); /* Novell IPX */
#endif
#ifdef AF_APPLETALK
/* Appletalk DDP */
- PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
+ PyModule_AddIntMacro(m, AF_APPLETALK);
#endif
#ifdef AF_NETROM
/* Amateur radio NetROM */
- PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
+ PyModule_AddIntMacro(m, AF_NETROM);
#endif
#ifdef AF_BRIDGE
/* Multiprotocol bridge */
- PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
+ PyModule_AddIntMacro(m, AF_BRIDGE);
#endif
#ifdef AF_ATMPVC
/* ATM PVCs */
- PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
+ PyModule_AddIntMacro(m, AF_ATMPVC);
#endif
#ifdef AF_AAL5
/* Reserved for Werner's ATM */
- PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
+ PyModule_AddIntMacro(m, AF_AAL5);
#endif
#ifdef AF_X25
/* Reserved for X.25 project */
- PyModule_AddIntConstant(m, "AF_X25", AF_X25);
+ PyModule_AddIntMacro(m, AF_X25);
#endif
#ifdef AF_INET6
- PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
+ PyModule_AddIntMacro(m, AF_INET6); /* IP version 6 */
#endif
#ifdef AF_ROSE
/* Amateur Radio X.25 PLP */
- PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
+ PyModule_AddIntMacro(m, AF_ROSE);
#endif
#ifdef AF_DECnet
/* Reserved for DECnet project */
- PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
+ PyModule_AddIntMacro(m, AF_DECnet);
#endif
#ifdef AF_NETBEUI
/* Reserved for 802.2LLC project */
- PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
+ PyModule_AddIntMacro(m, AF_NETBEUI);
#endif
#ifdef AF_SECURITY
/* Security callback pseudo AF */
- PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
+ PyModule_AddIntMacro(m, AF_SECURITY);
#endif
#ifdef AF_KEY
/* PF_KEY key management API */
- PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
+ PyModule_AddIntMacro(m, AF_KEY);
#endif
#ifdef AF_NETLINK
/* */
- PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
- PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
+ PyModule_AddIntMacro(m, AF_NETLINK);
+ PyModule_AddIntMacro(m, NETLINK_ROUTE);
#ifdef NETLINK_SKIP
- PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
+ PyModule_AddIntMacro(m, NETLINK_SKIP);
#endif
#ifdef NETLINK_W1
- PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
-#endif
- PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
- PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
+ PyModule_AddIntMacro(m, NETLINK_W1);
+#endif
+ PyModule_AddIntMacro(m, NETLINK_USERSOCK);
+ PyModule_AddIntMacro(m, NETLINK_FIREWALL);
#ifdef NETLINK_TCPDIAG
- PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
+ PyModule_AddIntMacro(m, NETLINK_TCPDIAG);
#endif
#ifdef NETLINK_NFLOG
- PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
+ PyModule_AddIntMacro(m, NETLINK_NFLOG);
#endif
#ifdef NETLINK_XFRM
- PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
+ PyModule_AddIntMacro(m, NETLINK_XFRM);
#endif
#ifdef NETLINK_ARPD
- PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
+ PyModule_AddIntMacro(m, NETLINK_ARPD);
#endif
#ifdef NETLINK_ROUTE6
- PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
-#endif
- PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
+ PyModule_AddIntMacro(m, NETLINK_ROUTE6);
+#endif
+ PyModule_AddIntMacro(m, NETLINK_IP6_FW);
#ifdef NETLINK_DNRTMSG
- PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
+ PyModule_AddIntMacro(m, NETLINK_DNRTMSG);
#endif
#ifdef NETLINK_TAPBASE
- PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
+ PyModule_AddIntMacro(m, NETLINK_TAPBASE);
#endif
#endif /* AF_NETLINK */
#ifdef AF_ROUTE
/* Alias to emulate 4.4BSD */
- PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
+ PyModule_AddIntMacro(m, AF_ROUTE);
#endif
#ifdef AF_ASH
/* Ash */
- PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
+ PyModule_AddIntMacro(m, AF_ASH);
#endif
#ifdef AF_ECONET
/* Acorn Econet */
- PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
+ PyModule_AddIntMacro(m, AF_ECONET);
#endif
#ifdef AF_ATMSVC
/* ATM SVCs */
- PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
+ PyModule_AddIntMacro(m, AF_ATMSVC);
#endif
#ifdef AF_SNA
/* Linux SNA Project (nutters!) */
- PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
+ PyModule_AddIntMacro(m, AF_SNA);
#endif
#ifdef AF_IRDA
/* IRDA sockets */
- PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
+ PyModule_AddIntMacro(m, AF_IRDA);
#endif
#ifdef AF_PPPOX
/* PPPoX sockets */
- PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
+ PyModule_AddIntMacro(m, AF_PPPOX);
#endif
#ifdef AF_WANPIPE
/* Wanpipe API Sockets */
- PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
+ PyModule_AddIntMacro(m, AF_WANPIPE);
#endif
#ifdef AF_LLC
/* Linux LLC */
- PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
+ PyModule_AddIntMacro(m, AF_LLC);
#endif
#ifdef USE_BLUETOOTH
- PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
- PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
- PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
- PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
+ PyModule_AddIntMacro(m, AF_BLUETOOTH);
+ PyModule_AddIntMacro(m, BTPROTO_L2CAP);
+ PyModule_AddIntMacro(m, BTPROTO_HCI);
+ PyModule_AddIntMacro(m, SOL_HCI);
#if !defined(__NetBSD__) && !defined(__DragonFly__)
- PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
+ PyModule_AddIntMacro(m, HCI_FILTER);
#endif
#if !defined(__FreeBSD__)
#if !defined(__NetBSD__) && !defined(__DragonFly__)
- PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
-#endif
- PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
- PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
-#endif
- PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
+ PyModule_AddIntMacro(m, HCI_TIME_STAMP);
+#endif
+ PyModule_AddIntMacro(m, HCI_DATA_DIR);
+ PyModule_AddIntMacro(m, BTPROTO_SCO);
+#endif
+ PyModule_AddIntMacro(m, BTPROTO_RFCOMM);
PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
#endif
#ifdef AF_CAN
/* Controller Area Network */
- PyModule_AddIntConstant(m, "AF_CAN", AF_CAN);
+ PyModule_AddIntMacro(m, AF_CAN);
#endif
#ifdef PF_CAN
/* Controller Area Network */
- PyModule_AddIntConstant(m, "PF_CAN", PF_CAN);
+ PyModule_AddIntMacro(m, PF_CAN);
#endif
/* Reliable Datagram Sockets */
#ifdef AF_RDS
- PyModule_AddIntConstant(m, "AF_RDS", AF_RDS);
+ PyModule_AddIntMacro(m, AF_RDS);
#endif
#ifdef PF_RDS
- PyModule_AddIntConstant(m, "PF_RDS", PF_RDS);
+ PyModule_AddIntMacro(m, PF_RDS);
#endif
/* Kernel event messages */
#ifdef PF_SYSTEM
- PyModule_AddIntConstant(m, "PF_SYSTEM", PF_SYSTEM);
+ PyModule_AddIntMacro(m, PF_SYSTEM);
#endif
#ifdef AF_SYSTEM
- PyModule_AddIntConstant(m, "AF_SYSTEM", AF_SYSTEM);
+ PyModule_AddIntMacro(m, AF_SYSTEM);
#endif
#ifdef AF_PACKET
@@ -5765,134 +5765,129 @@
#endif
#ifdef HAVE_LINUX_TIPC_H
- PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);
+ PyModule_AddIntMacro(m, AF_TIPC);
/* for addresses */
- PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
- PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
- PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
-
- PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
- PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
- PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
+ PyModule_AddIntMacro(m, TIPC_ADDR_NAMESEQ);
+ PyModule_AddIntMacro(m, TIPC_ADDR_NAME);
+ PyModule_AddIntMacro(m, TIPC_ADDR_ID);
+
+ PyModule_AddIntMacro(m, TIPC_ZONE_SCOPE);
+ PyModule_AddIntMacro(m, TIPC_CLUSTER_SCOPE);
+ PyModule_AddIntMacro(m, TIPC_NODE_SCOPE);
/* for setsockopt() */
- PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
- PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
- PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
- TIPC_DEST_DROPPABLE);
- PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
-
- PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
- TIPC_LOW_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
- TIPC_MEDIUM_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
- TIPC_HIGH_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
- TIPC_CRITICAL_IMPORTANCE);
+ 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);
+
+ PyModule_AddIntMacro(m, TIPC_LOW_IMPORTANCE);
+ PyModule_AddIntMacro(m, TIPC_MEDIUM_IMPORTANCE);
+ PyModule_AddIntMacro(m, TIPC_HIGH_IMPORTANCE);
+ PyModule_AddIntMacro(m, TIPC_CRITICAL_IMPORTANCE);
/* for subscriptions */
- PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
- PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
+ PyModule_AddIntMacro(m, TIPC_SUB_PORTS);
+ PyModule_AddIntMacro(m, TIPC_SUB_SERVICE);
#ifdef TIPC_SUB_CANCEL
/* doesn't seem to be available everywhere */
- PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
-#endif
- PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
- PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
- PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
- PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
- PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
- PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
+ PyModule_AddIntMacro(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);
#endif
/* Socket types */
- PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
- PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
+ PyModule_AddIntMacro(m, SOCK_STREAM);
+ PyModule_AddIntMacro(m, SOCK_DGRAM);
/* We have incomplete socket support. */
- PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
- PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
+ PyModule_AddIntMacro(m, SOCK_RAW);
+ PyModule_AddIntMacro(m, SOCK_SEQPACKET);
#if defined(SOCK_RDM)
- PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
+ PyModule_AddIntMacro(m, SOCK_RDM);
#endif
#ifdef SOCK_CLOEXEC
- PyModule_AddIntConstant(m, "SOCK_CLOEXEC", SOCK_CLOEXEC);
+ PyModule_AddIntMacro(m, SOCK_CLOEXEC);
#endif
#ifdef SOCK_NONBLOCK
- PyModule_AddIntConstant(m, "SOCK_NONBLOCK", SOCK_NONBLOCK);
+ PyModule_AddIntMacro(m, SOCK_NONBLOCK);
#endif
#ifdef SO_DEBUG
- PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
+ PyModule_AddIntMacro(m, SO_DEBUG);
#endif
#ifdef SO_ACCEPTCONN
- PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
+ PyModule_AddIntMacro(m, SO_ACCEPTCONN);
#endif
#ifdef SO_REUSEADDR
- PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
+ PyModule_AddIntMacro(m, SO_REUSEADDR);
#endif
#ifdef SO_EXCLUSIVEADDRUSE
- PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
+ PyModule_AddIntMacro(m, SO_EXCLUSIVEADDRUSE);
#endif
#ifdef SO_KEEPALIVE
- PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
+ PyModule_AddIntMacro(m, SO_KEEPALIVE);
#endif
#ifdef SO_DONTROUTE
- PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
+ PyModule_AddIntMacro(m, SO_DONTROUTE);
#endif
#ifdef SO_BROADCAST
- PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
+ PyModule_AddIntMacro(m, SO_BROADCAST);
#endif
#ifdef SO_USELOOPBACK
- PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
+ PyModule_AddIntMacro(m, SO_USELOOPBACK);
#endif
#ifdef SO_LINGER
- PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
+ PyModule_AddIntMacro(m, SO_LINGER);
#endif
#ifdef SO_OOBINLINE
- PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
+ PyModule_AddIntMacro(m, SO_OOBINLINE);
#endif
#ifdef SO_REUSEPORT
- PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
+ PyModule_AddIntMacro(m, SO_REUSEPORT);
#endif
#ifdef SO_SNDBUF
- PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
+ PyModule_AddIntMacro(m, SO_SNDBUF);
#endif
#ifdef SO_RCVBUF
- PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
+ PyModule_AddIntMacro(m, SO_RCVBUF);
#endif
#ifdef SO_SNDLOWAT
- PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
+ PyModule_AddIntMacro(m, SO_SNDLOWAT);
#endif
#ifdef SO_RCVLOWAT
- PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
+ PyModule_AddIntMacro(m, SO_RCVLOWAT);
#endif
#ifdef SO_SNDTIMEO
- PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
+ PyModule_AddIntMacro(m, SO_SNDTIMEO);
#endif
#ifdef SO_RCVTIMEO
- PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
+ PyModule_AddIntMacro(m, SO_RCVTIMEO);
#endif
#ifdef SO_ERROR
- PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
+ PyModule_AddIntMacro(m, SO_ERROR);
#endif
#ifdef SO_TYPE
- PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
+ PyModule_AddIntMacro(m, SO_TYPE);
#endif
#ifdef SO_SETFIB
- PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB);
+ PyModule_AddIntMacro(m, SO_SETFIB);
#endif
#ifdef SO_PASSCRED
- PyModule_AddIntConstant(m, "SO_PASSCRED", SO_PASSCRED);
+ PyModule_AddIntMacro(m, SO_PASSCRED);
#endif
#ifdef SO_PEERCRED
- PyModule_AddIntConstant(m, "SO_PEERCRED", SO_PEERCRED);
+ PyModule_AddIntMacro(m, SO_PEERCRED);
#endif
#ifdef LOCAL_PEERCRED
- PyModule_AddIntConstant(m, "LOCAL_PEERCRED", LOCAL_PEERCRED);
+ PyModule_AddIntMacro(m, LOCAL_PEERCRED);
#endif
#ifdef SO_BINDTODEVICE
PyModule_AddIntMacro(m, SO_BINDTODEVICE);
@@ -5900,142 +5895,142 @@
/* Maximum number of connections for "listen" */
#ifdef SOMAXCONN
- PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
+ PyModule_AddIntMacro(m, SOMAXCONN);
#else
PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
#endif
/* Ancilliary message types */
#ifdef SCM_RIGHTS
- PyModule_AddIntConstant(m, "SCM_RIGHTS", SCM_RIGHTS);
+ PyModule_AddIntMacro(m, SCM_RIGHTS);
#endif
#ifdef SCM_CREDENTIALS
- PyModule_AddIntConstant(m, "SCM_CREDENTIALS", SCM_CREDENTIALS);
+ PyModule_AddIntMacro(m, SCM_CREDENTIALS);
#endif
#ifdef SCM_CREDS
- PyModule_AddIntConstant(m, "SCM_CREDS", SCM_CREDS);
+ PyModule_AddIntMacro(m, SCM_CREDS);
#endif
/* Flags for send, recv */
#ifdef MSG_OOB
- PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
+ PyModule_AddIntMacro(m, MSG_OOB);
#endif
#ifdef MSG_PEEK
- PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
+ PyModule_AddIntMacro(m, MSG_PEEK);
#endif
#ifdef MSG_DONTROUTE
- PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
+ PyModule_AddIntMacro(m, MSG_DONTROUTE);
#endif
#ifdef MSG_DONTWAIT
- PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
+ PyModule_AddIntMacro(m, MSG_DONTWAIT);
#endif
#ifdef MSG_EOR
- PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
+ PyModule_AddIntMacro(m, MSG_EOR);
#endif
#ifdef MSG_TRUNC
- PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
+ PyModule_AddIntMacro(m, MSG_TRUNC);
#endif
#ifdef MSG_CTRUNC
- PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
+ PyModule_AddIntMacro(m, MSG_CTRUNC);
#endif
#ifdef MSG_WAITALL
- PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
+ PyModule_AddIntMacro(m, MSG_WAITALL);
#endif
#ifdef MSG_BTAG
- PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
+ PyModule_AddIntMacro(m, MSG_BTAG);
#endif
#ifdef MSG_ETAG
- PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
+ PyModule_AddIntMacro(m, MSG_ETAG);
#endif
#ifdef MSG_NOSIGNAL
- PyModule_AddIntConstant(m, "MSG_NOSIGNAL", MSG_NOSIGNAL);
+ PyModule_AddIntMacro(m, MSG_NOSIGNAL);
#endif
#ifdef MSG_NOTIFICATION
- PyModule_AddIntConstant(m, "MSG_NOTIFICATION", MSG_NOTIFICATION);
+ PyModule_AddIntMacro(m, MSG_NOTIFICATION);
#endif
#ifdef MSG_CMSG_CLOEXEC
- PyModule_AddIntConstant(m, "MSG_CMSG_CLOEXEC", MSG_CMSG_CLOEXEC);
+ PyModule_AddIntMacro(m, MSG_CMSG_CLOEXEC);
#endif
#ifdef MSG_ERRQUEUE
- PyModule_AddIntConstant(m, "MSG_ERRQUEUE", MSG_ERRQUEUE);
+ PyModule_AddIntMacro(m, MSG_ERRQUEUE);
#endif
#ifdef MSG_CONFIRM
- PyModule_AddIntConstant(m, "MSG_CONFIRM", MSG_CONFIRM);
+ PyModule_AddIntMacro(m, MSG_CONFIRM);
#endif
#ifdef MSG_MORE
- PyModule_AddIntConstant(m, "MSG_MORE", MSG_MORE);
+ PyModule_AddIntMacro(m, MSG_MORE);
#endif
#ifdef MSG_EOF
- PyModule_AddIntConstant(m, "MSG_EOF", MSG_EOF);
+ PyModule_AddIntMacro(m, MSG_EOF);
#endif
#ifdef MSG_BCAST
- PyModule_AddIntConstant(m, "MSG_BCAST", MSG_BCAST);
+ PyModule_AddIntMacro(m, MSG_BCAST);
#endif
#ifdef MSG_MCAST
- PyModule_AddIntConstant(m, "MSG_MCAST", MSG_MCAST);
+ PyModule_AddIntMacro(m, MSG_MCAST);
#endif
#ifdef MSG_FASTOPEN
- PyModule_AddIntConstant(m, "MSG_FASTOPEN", MSG_FASTOPEN);
+ PyModule_AddIntMacro(m, MSG_FASTOPEN);
#endif
/* Protocol level and numbers, usable for [gs]etsockopt */
#ifdef SOL_SOCKET
- PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
+ PyModule_AddIntMacro(m, SOL_SOCKET);
#endif
#ifdef SOL_IP
- PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
+ PyModule_AddIntMacro(m, SOL_IP);
#else
PyModule_AddIntConstant(m, "SOL_IP", 0);
#endif
#ifdef SOL_IPX
- PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
+ PyModule_AddIntMacro(m, SOL_IPX);
#endif
#ifdef SOL_AX25
- PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
+ PyModule_AddIntMacro(m, SOL_AX25);
#endif
#ifdef SOL_ATALK
- PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
+ PyModule_AddIntMacro(m, SOL_ATALK);
#endif
#ifdef SOL_NETROM
- PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
+ PyModule_AddIntMacro(m, SOL_NETROM);
#endif
#ifdef SOL_ROSE
- PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
+ PyModule_AddIntMacro(m, SOL_ROSE);
#endif
#ifdef SOL_TCP
- PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
+ PyModule_AddIntMacro(m, SOL_TCP);
#else
PyModule_AddIntConstant(m, "SOL_TCP", 6);
#endif
#ifdef SOL_UDP
- PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
+ PyModule_AddIntMacro(m, SOL_UDP);
#else
PyModule_AddIntConstant(m, "SOL_UDP", 17);
#endif
#ifdef SOL_CAN_BASE
- PyModule_AddIntConstant(m, "SOL_CAN_BASE", SOL_CAN_BASE);
+ PyModule_AddIntMacro(m, SOL_CAN_BASE);
#endif
#ifdef SOL_CAN_RAW
- PyModule_AddIntConstant(m, "SOL_CAN_RAW", SOL_CAN_RAW);
- PyModule_AddIntConstant(m, "CAN_RAW", CAN_RAW);
+ PyModule_AddIntMacro(m, SOL_CAN_RAW);
+ PyModule_AddIntMacro(m, CAN_RAW);
#endif
#ifdef HAVE_LINUX_CAN_H
- PyModule_AddIntConstant(m, "CAN_EFF_FLAG", CAN_EFF_FLAG);
- PyModule_AddIntConstant(m, "CAN_RTR_FLAG", CAN_RTR_FLAG);
- PyModule_AddIntConstant(m, "CAN_ERR_FLAG", CAN_ERR_FLAG);
-
- PyModule_AddIntConstant(m, "CAN_SFF_MASK", CAN_SFF_MASK);
- PyModule_AddIntConstant(m, "CAN_EFF_MASK", CAN_EFF_MASK);
- PyModule_AddIntConstant(m, "CAN_ERR_MASK", CAN_ERR_MASK);
+ PyModule_AddIntMacro(m, CAN_EFF_FLAG);
+ PyModule_AddIntMacro(m, CAN_RTR_FLAG);
+ PyModule_AddIntMacro(m, CAN_ERR_FLAG);
+
+ PyModule_AddIntMacro(m, CAN_SFF_MASK);
+ PyModule_AddIntMacro(m, CAN_EFF_MASK);
+ PyModule_AddIntMacro(m, CAN_ERR_MASK);
#endif
#ifdef HAVE_LINUX_CAN_RAW_H
- PyModule_AddIntConstant(m, "CAN_RAW_FILTER", CAN_RAW_FILTER);
- PyModule_AddIntConstant(m, "CAN_RAW_ERR_FILTER", CAN_RAW_ERR_FILTER);
- PyModule_AddIntConstant(m, "CAN_RAW_LOOPBACK", CAN_RAW_LOOPBACK);
- PyModule_AddIntConstant(m, "CAN_RAW_RECV_OWN_MSGS", CAN_RAW_RECV_OWN_MSGS);
+ PyModule_AddIntMacro(m, CAN_RAW_FILTER);
+ PyModule_AddIntMacro(m, CAN_RAW_ERR_FILTER);
+ PyModule_AddIntMacro(m, CAN_RAW_LOOPBACK);
+ PyModule_AddIntMacro(m, CAN_RAW_RECV_OWN_MSGS);
#endif
#ifdef HAVE_LINUX_CAN_BCM_H
- PyModule_AddIntConstant(m, "CAN_BCM", CAN_BCM);
+ PyModule_AddIntMacro(m, CAN_BCM);
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);
@@ -6050,180 +6045,180 @@
PyModule_AddIntConstant(m, "CAN_BCM_RX_CHANGED", RX_CHANGED);
#endif
#ifdef SOL_RDS
- PyModule_AddIntConstant(m, "SOL_RDS", SOL_RDS);
+ PyModule_AddIntMacro(m, SOL_RDS);
#endif
#ifdef RDS_CANCEL_SENT_TO
- PyModule_AddIntConstant(m, "RDS_CANCEL_SENT_TO", RDS_CANCEL_SENT_TO);
+ PyModule_AddIntMacro(m, RDS_CANCEL_SENT_TO);
#endif
#ifdef RDS_GET_MR
- PyModule_AddIntConstant(m, "RDS_GET_MR", RDS_GET_MR);
+ PyModule_AddIntMacro(m, RDS_GET_MR);
#endif
#ifdef RDS_FREE_MR
- PyModule_AddIntConstant(m, "RDS_FREE_MR", RDS_FREE_MR);
+ PyModule_AddIntMacro(m, RDS_FREE_MR);
#endif
#ifdef RDS_RECVERR
- PyModule_AddIntConstant(m, "RDS_RECVERR", RDS_RECVERR);
+ PyModule_AddIntMacro(m, RDS_RECVERR);
#endif
#ifdef RDS_CONG_MONITOR
- PyModule_AddIntConstant(m, "RDS_CONG_MONITOR", RDS_CONG_MONITOR);
+ PyModule_AddIntMacro(m, RDS_CONG_MONITOR);
#endif
#ifdef RDS_GET_MR_FOR_DEST
- PyModule_AddIntConstant(m, "RDS_GET_MR_FOR_DEST", RDS_GET_MR_FOR_DEST);
+ PyModule_AddIntMacro(m, RDS_GET_MR_FOR_DEST);
#endif
#ifdef IPPROTO_IP
- PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
+ PyModule_AddIntMacro(m, IPPROTO_IP);
#else
PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
#endif
#ifdef IPPROTO_HOPOPTS
- PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
+ PyModule_AddIntMacro(m, IPPROTO_HOPOPTS);
#endif
#ifdef IPPROTO_ICMP
- PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
+ PyModule_AddIntMacro(m, IPPROTO_ICMP);
#else
PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
#endif
#ifdef IPPROTO_IGMP
- PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
+ PyModule_AddIntMacro(m, IPPROTO_IGMP);
#endif
#ifdef IPPROTO_GGP
- PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
+ PyModule_AddIntMacro(m, IPPROTO_GGP);
#endif
#ifdef IPPROTO_IPV4
- PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
+ PyModule_AddIntMacro(m, IPPROTO_IPV4);
#endif
#ifdef IPPROTO_IPV6
- PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
+ PyModule_AddIntMacro(m, IPPROTO_IPV6);
#endif
#ifdef IPPROTO_IPIP
- PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
+ PyModule_AddIntMacro(m, IPPROTO_IPIP);
#endif
#ifdef IPPROTO_TCP
- PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
+ PyModule_AddIntMacro(m, IPPROTO_TCP);
#else
PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
#endif
#ifdef IPPROTO_EGP
- PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
+ PyModule_AddIntMacro(m, IPPROTO_EGP);
#endif
#ifdef IPPROTO_PUP
- PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
+ PyModule_AddIntMacro(m, IPPROTO_PUP);
#endif
#ifdef IPPROTO_UDP
- PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
+ PyModule_AddIntMacro(m, IPPROTO_UDP);
#else
PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
#endif
#ifdef IPPROTO_IDP
- PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
+ PyModule_AddIntMacro(m, IPPROTO_IDP);
#endif
#ifdef IPPROTO_HELLO
- PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
+ PyModule_AddIntMacro(m, IPPROTO_HELLO);
#endif
#ifdef IPPROTO_ND
- PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
+ PyModule_AddIntMacro(m, IPPROTO_ND);
#endif
#ifdef IPPROTO_TP
- PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
+ PyModule_AddIntMacro(m, IPPROTO_TP);
#endif
#ifdef IPPROTO_IPV6
- PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
+ PyModule_AddIntMacro(m, IPPROTO_IPV6);
#endif
#ifdef IPPROTO_ROUTING
- PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
+ PyModule_AddIntMacro(m, IPPROTO_ROUTING);
#endif
#ifdef IPPROTO_FRAGMENT
- PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
+ PyModule_AddIntMacro(m, IPPROTO_FRAGMENT);
#endif
#ifdef IPPROTO_RSVP
- PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
+ PyModule_AddIntMacro(m, IPPROTO_RSVP);
#endif
#ifdef IPPROTO_GRE
- PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
+ PyModule_AddIntMacro(m, IPPROTO_GRE);
#endif
#ifdef IPPROTO_ESP
- PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
+ PyModule_AddIntMacro(m, IPPROTO_ESP);
#endif
#ifdef IPPROTO_AH
- PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
+ PyModule_AddIntMacro(m, IPPROTO_AH);
#endif
#ifdef IPPROTO_MOBILE
- PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
+ PyModule_AddIntMacro(m, IPPROTO_MOBILE);
#endif
#ifdef IPPROTO_ICMPV6
- PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
+ PyModule_AddIntMacro(m, IPPROTO_ICMPV6);
#endif
#ifdef IPPROTO_NONE
- PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
+ PyModule_AddIntMacro(m, IPPROTO_NONE);
#endif
#ifdef IPPROTO_DSTOPTS
- PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
+ PyModule_AddIntMacro(m, IPPROTO_DSTOPTS);
#endif
#ifdef IPPROTO_XTP
- PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
+ PyModule_AddIntMacro(m, IPPROTO_XTP);
#endif
#ifdef IPPROTO_EON
- PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
+ PyModule_AddIntMacro(m, IPPROTO_EON);
#endif
#ifdef IPPROTO_PIM
- PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
+ PyModule_AddIntMacro(m, IPPROTO_PIM);
#endif
#ifdef IPPROTO_IPCOMP
- PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
+ PyModule_AddIntMacro(m, IPPROTO_IPCOMP);
#endif
#ifdef IPPROTO_VRRP
- PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
+ PyModule_AddIntMacro(m, IPPROTO_VRRP);
#endif
#ifdef IPPROTO_SCTP
- PyModule_AddIntConstant(m, "IPPROTO_SCTP", IPPROTO_SCTP);
+ PyModule_AddIntMacro(m, IPPROTO_SCTP);
#endif
#ifdef IPPROTO_BIP
- PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
+ PyModule_AddIntMacro(m, IPPROTO_BIP);
#endif
/**/
#ifdef IPPROTO_RAW
- PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
+ PyModule_AddIntMacro(m, IPPROTO_RAW);
#else
PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
#endif
#ifdef IPPROTO_MAX
- PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
+ PyModule_AddIntMacro(m, IPPROTO_MAX);
#endif
#ifdef SYSPROTO_CONTROL
- PyModule_AddIntConstant(m, "SYSPROTO_CONTROL", SYSPROTO_CONTROL);
+ PyModule_AddIntMacro(m, SYSPROTO_CONTROL);
#endif
/* Some port configuration */
#ifdef IPPORT_RESERVED
- PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
+ PyModule_AddIntMacro(m, IPPORT_RESERVED);
#else
PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
#endif
#ifdef IPPORT_USERRESERVED
- PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
+ PyModule_AddIntMacro(m, IPPORT_USERRESERVED);
#else
PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
#endif
/* Some reserved IP v.4 addresses */
#ifdef INADDR_ANY
- PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
+ PyModule_AddIntMacro(m, INADDR_ANY);
#else
PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
#endif
#ifdef INADDR_BROADCAST
- PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
+ PyModule_AddIntMacro(m, INADDR_BROADCAST);
#else
PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
#endif
#ifdef INADDR_LOOPBACK
- PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
+ PyModule_AddIntMacro(m, INADDR_LOOPBACK);
#else
PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
#endif
#ifdef INADDR_UNSPEC_GROUP
- PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
+ PyModule_AddIntMacro(m, INADDR_UNSPEC_GROUP);
#else
PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
#endif
@@ -6234,356 +6229,353 @@
PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
#endif
#ifdef INADDR_MAX_LOCAL_GROUP
- PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
- INADDR_MAX_LOCAL_GROUP);
+ PyModule_AddIntMacro(m, INADDR_MAX_LOCAL_GROUP);
#else
PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
#endif
#ifdef INADDR_NONE
- PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
+ PyModule_AddIntMacro(m, INADDR_NONE);
#else
PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
#endif
/* IPv4 [gs]etsockopt options */
#ifdef IP_OPTIONS
- PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
+ PyModule_AddIntMacro(m, IP_OPTIONS);
#endif
#ifdef IP_HDRINCL
- PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
+ PyModule_AddIntMacro(m, IP_HDRINCL);
#endif
#ifdef IP_TOS
- PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
+ PyModule_AddIntMacro(m, IP_TOS);
#endif
#ifdef IP_TTL
- PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
+ PyModule_AddIntMacro(m, IP_TTL);
#endif
#ifdef IP_RECVOPTS
- PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
+ PyModule_AddIntMacro(m, IP_RECVOPTS);
#endif
#ifdef IP_RECVRETOPTS
- PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
+ PyModule_AddIntMacro(m, IP_RECVRETOPTS);
#endif
#ifdef IP_RECVDSTADDR
- PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
+ PyModule_AddIntMacro(m, IP_RECVDSTADDR);
#endif
#ifdef IP_RETOPTS
- PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
+ PyModule_AddIntMacro(m, IP_RETOPTS);
#endif
#ifdef IP_MULTICAST_IF
- PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
+ PyModule_AddIntMacro(m, IP_MULTICAST_IF);
#endif
#ifdef IP_MULTICAST_TTL
- PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
+ PyModule_AddIntMacro(m, IP_MULTICAST_TTL);
#endif
#ifdef IP_MULTICAST_LOOP
- PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
+ PyModule_AddIntMacro(m, IP_MULTICAST_LOOP);
#endif
#ifdef IP_ADD_MEMBERSHIP
- PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
+ PyModule_AddIntMacro(m, IP_ADD_MEMBERSHIP);
#endif
#ifdef IP_DROP_MEMBERSHIP
- PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
+ PyModule_AddIntMacro(m, IP_DROP_MEMBERSHIP);
#endif
#ifdef IP_DEFAULT_MULTICAST_TTL
- PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
- IP_DEFAULT_MULTICAST_TTL);
+ PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_TTL);
#endif
#ifdef IP_DEFAULT_MULTICAST_LOOP
- PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
- IP_DEFAULT_MULTICAST_LOOP);
+ PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_LOOP);
#endif
#ifdef IP_MAX_MEMBERSHIPS
- PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
+ PyModule_AddIntMacro(m, IP_MAX_MEMBERSHIPS);
#endif
#ifdef IP_TRANSPARENT
- PyModule_AddIntConstant(m, "IP_TRANSPARENT", IP_TRANSPARENT);
+ PyModule_AddIntMacro(m, IP_TRANSPARENT);
#endif
/* IPv6 [gs]etsockopt options, defined in RFC2553 */
#ifdef IPV6_JOIN_GROUP
- PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
+ PyModule_AddIntMacro(m, IPV6_JOIN_GROUP);
#endif
#ifdef IPV6_LEAVE_GROUP
- PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
+ PyModule_AddIntMacro(m, IPV6_LEAVE_GROUP);
#endif
#ifdef IPV6_MULTICAST_HOPS
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
+ PyModule_AddIntMacro(m, IPV6_MULTICAST_HOPS);
#endif
#ifdef IPV6_MULTICAST_IF
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
+ PyModule_AddIntMacro(m, IPV6_MULTICAST_IF);
#endif
#ifdef IPV6_MULTICAST_LOOP
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
+ PyModule_AddIntMacro(m, IPV6_MULTICAST_LOOP);
#endif
#ifdef IPV6_UNICAST_HOPS
- PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
+ PyModule_AddIntMacro(m, IPV6_UNICAST_HOPS);
#endif
/* Additional IPV6 socket options, defined in RFC 3493 */
#ifdef IPV6_V6ONLY
- PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
+ PyModule_AddIntMacro(m, IPV6_V6ONLY);
#endif
/* Advanced IPV6 socket options, from RFC 3542 */
#ifdef IPV6_CHECKSUM
- PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
+ PyModule_AddIntMacro(m, IPV6_CHECKSUM);
#endif
#ifdef IPV6_DONTFRAG
- PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
+ PyModule_AddIntMacro(m, IPV6_DONTFRAG);
#endif
#ifdef IPV6_DSTOPTS
- PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
+ PyModule_AddIntMacro(m, IPV6_DSTOPTS);
#endif
#ifdef IPV6_HOPLIMIT
- PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
+ PyModule_AddIntMacro(m, IPV6_HOPLIMIT);
#endif
#ifdef IPV6_HOPOPTS
- PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
+ PyModule_AddIntMacro(m, IPV6_HOPOPTS);
#endif
#ifdef IPV6_NEXTHOP
- PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
+ PyModule_AddIntMacro(m, IPV6_NEXTHOP);
#endif
#ifdef IPV6_PATHMTU
- PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
+ PyModule_AddIntMacro(m, IPV6_PATHMTU);
#endif
#ifdef IPV6_PKTINFO
- PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
+ PyModule_AddIntMacro(m, IPV6_PKTINFO);
#endif
#ifdef IPV6_RECVDSTOPTS
- PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
+ PyModule_AddIntMacro(m, IPV6_RECVDSTOPTS);
#endif
#ifdef IPV6_RECVHOPLIMIT
- PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
+ PyModule_AddIntMacro(m, IPV6_RECVHOPLIMIT);
#endif
#ifdef IPV6_RECVHOPOPTS
- PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
+ PyModule_AddIntMacro(m, IPV6_RECVHOPOPTS);
#endif
#ifdef IPV6_RECVPKTINFO
- PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
+ PyModule_AddIntMacro(m, IPV6_RECVPKTINFO);
#endif
#ifdef IPV6_RECVRTHDR
- PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
+ PyModule_AddIntMacro(m, IPV6_RECVRTHDR);
#endif
#ifdef IPV6_RECVTCLASS
- PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
+ PyModule_AddIntMacro(m, IPV6_RECVTCLASS);
#endif
#ifdef IPV6_RTHDR
- PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
+ PyModule_AddIntMacro(m, IPV6_RTHDR);
#endif
#ifdef IPV6_RTHDRDSTOPTS
- PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
+ PyModule_AddIntMacro(m, IPV6_RTHDRDSTOPTS);
#endif
#ifdef IPV6_RTHDR_TYPE_0
- PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
+ PyModule_AddIntMacro(m, IPV6_RTHDR_TYPE_0);
#endif
#ifdef IPV6_RECVPATHMTU
- PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
+ PyModule_AddIntMacro(m, IPV6_RECVPATHMTU);
#endif
#ifdef IPV6_TCLASS
- PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
+ PyModule_AddIntMacro(m, IPV6_TCLASS);
#endif
#ifdef IPV6_USE_MIN_MTU
- PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
+ PyModule_AddIntMacro(m, IPV6_USE_MIN_MTU);
#endif
/* TCP options */
#ifdef TCP_NODELAY
- PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
+ PyModule_AddIntMacro(m, TCP_NODELAY);
#endif
#ifdef TCP_MAXSEG
- PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
+ PyModule_AddIntMacro(m, TCP_MAXSEG);
#endif
#ifdef TCP_CORK
- PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
+ PyModule_AddIntMacro(m, TCP_CORK);
#endif
#ifdef TCP_KEEPIDLE
- PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
+ PyModule_AddIntMacro(m, TCP_KEEPIDLE);
#endif
#ifdef TCP_KEEPINTVL
- PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
+ PyModule_AddIntMacro(m, TCP_KEEPINTVL);
#endif
#ifdef TCP_KEEPCNT
- PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
+ PyModule_AddIntMacro(m, TCP_KEEPCNT);
#endif
#ifdef TCP_SYNCNT
- PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
+ PyModule_AddIntMacro(m, TCP_SYNCNT);
#endif
#ifdef TCP_LINGER2
- PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
+ PyModule_AddIntMacro(m, TCP_LINGER2);
#endif
#ifdef TCP_DEFER_ACCEPT
- PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
+ PyModule_AddIntMacro(m, TCP_DEFER_ACCEPT);
#endif
#ifdef TCP_WINDOW_CLAMP
- PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
+ PyModule_AddIntMacro(m, TCP_WINDOW_CLAMP);
#endif
#ifdef TCP_INFO
- PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
+ PyModule_AddIntMacro(m, TCP_INFO);
#endif
#ifdef TCP_QUICKACK
- PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
+ PyModule_AddIntMacro(m, TCP_QUICKACK);
#endif
#ifdef TCP_FASTOPEN
- PyModule_AddIntConstant(m, "TCP_FASTOPEN", TCP_FASTOPEN);
+ PyModule_AddIntMacro(m, TCP_FASTOPEN);
#endif
/* IPX options */
#ifdef IPX_TYPE
- PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
+ PyModule_AddIntMacro(m, IPX_TYPE);
#endif
/* Reliable Datagram Sockets */
#ifdef RDS_CMSG_RDMA_ARGS
- PyModule_AddIntConstant(m, "RDS_CMSG_RDMA_ARGS", RDS_CMSG_RDMA_ARGS);
+ PyModule_AddIntMacro(m, RDS_CMSG_RDMA_ARGS);
#endif
#ifdef RDS_CMSG_RDMA_DEST
- PyModule_AddIntConstant(m, "RDS_CMSG_RDMA_DEST", RDS_CMSG_RDMA_DEST);
+ PyModule_AddIntMacro(m, RDS_CMSG_RDMA_DEST);
#endif
#ifdef RDS_CMSG_RDMA_MAP
- PyModule_AddIntConstant(m, "RDS_CMSG_RDMA_MAP", RDS_CMSG_RDMA_MAP);
+ PyModule_AddIntMacro(m, RDS_CMSG_RDMA_MAP);
#endif
#ifdef RDS_CMSG_RDMA_STATUS
- PyModule_AddIntConstant(m, "RDS_CMSG_RDMA_STATUS", RDS_CMSG_RDMA_STATUS);
+ PyModule_AddIntMacro(m, RDS_CMSG_RDMA_STATUS);
#endif
#ifdef RDS_CMSG_RDMA_UPDATE
- PyModule_AddIntConstant(m, "RDS_CMSG_RDMA_UPDATE", RDS_CMSG_RDMA_UPDATE);
+ PyModule_AddIntMacro(m, RDS_CMSG_RDMA_UPDATE);
#endif
#ifdef RDS_RDMA_READWRITE
- PyModule_AddIntConstant(m, "RDS_RDMA_READWRITE", RDS_RDMA_READWRITE);
+ PyModule_AddIntMacro(m, RDS_RDMA_READWRITE);
#endif
#ifdef RDS_RDMA_FENCE
- PyModule_AddIntConstant(m, "RDS_RDMA_FENCE", RDS_RDMA_FENCE);
+ PyModule_AddIntMacro(m, RDS_RDMA_FENCE);
#endif
#ifdef RDS_RDMA_INVALIDATE
- PyModule_AddIntConstant(m, "RDS_RDMA_INVALIDATE", RDS_RDMA_INVALIDATE);
+ PyModule_AddIntMacro(m, RDS_RDMA_INVALIDATE);
#endif
#ifdef RDS_RDMA_USE_ONCE
- PyModule_AddIntConstant(m, "RDS_RDMA_USE_ONCE", RDS_RDMA_USE_ONCE);
+ PyModule_AddIntMacro(m, RDS_RDMA_USE_ONCE);
#endif
#ifdef RDS_RDMA_DONTWAIT
- PyModule_AddIntConstant(m, "RDS_RDMA_DONTWAIT", RDS_RDMA_DONTWAIT);
+ PyModule_AddIntMacro(m, RDS_RDMA_DONTWAIT);
#endif
#ifdef RDS_RDMA_NOTIFY_ME
- PyModule_AddIntConstant(m, "RDS_RDMA_NOTIFY_ME", RDS_RDMA_NOTIFY_ME);
+ PyModule_AddIntMacro(m, RDS_RDMA_NOTIFY_ME);
#endif
#ifdef RDS_RDMA_SILENT
- PyModule_AddIntConstant(m, "RDS_RDMA_SILENT", RDS_RDMA_SILENT);
+ PyModule_AddIntMacro(m, RDS_RDMA_SILENT);
#endif
/* get{addr,name}info parameters */
#ifdef EAI_ADDRFAMILY
- PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
+ PyModule_AddIntMacro(m, EAI_ADDRFAMILY);
#endif
#ifdef EAI_AGAIN
- PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
+ PyModule_AddIntMacro(m, EAI_AGAIN);
#endif
#ifdef EAI_BADFLAGS
- PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
+ PyModule_AddIntMacro(m, EAI_BADFLAGS);
#endif
#ifdef EAI_FAIL
- PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
+ PyModule_AddIntMacro(m, EAI_FAIL);
#endif
#ifdef EAI_FAMILY
- PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
+ PyModule_AddIntMacro(m, EAI_FAMILY);
#endif
#ifdef EAI_MEMORY
- PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
+ PyModule_AddIntMacro(m, EAI_MEMORY);
#endif
#ifdef EAI_NODATA
- PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
+ PyModule_AddIntMacro(m, EAI_NODATA);
#endif
#ifdef EAI_NONAME
- PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
+ PyModule_AddIntMacro(m, EAI_NONAME);
#endif
#ifdef EAI_OVERFLOW
- PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
+ PyModule_AddIntMacro(m, EAI_OVERFLOW);
#endif
#ifdef EAI_SERVICE
- PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
+ PyModule_AddIntMacro(m, EAI_SERVICE);
#endif
#ifdef EAI_SOCKTYPE
- PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
+ PyModule_AddIntMacro(m, EAI_SOCKTYPE);
#endif
#ifdef EAI_SYSTEM
- PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
+ PyModule_AddIntMacro(m, EAI_SYSTEM);
#endif
#ifdef EAI_BADHINTS
- PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
+ PyModule_AddIntMacro(m, EAI_BADHINTS);
#endif
#ifdef EAI_PROTOCOL
- PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
+ PyModule_AddIntMacro(m, EAI_PROTOCOL);
#endif
#ifdef EAI_MAX
- PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
+ PyModule_AddIntMacro(m, EAI_MAX);
#endif
#ifdef AI_PASSIVE
- PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
+ PyModule_AddIntMacro(m, AI_PASSIVE);
#endif
#ifdef AI_CANONNAME
- PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
+ PyModule_AddIntMacro(m, AI_CANONNAME);
#endif
#ifdef AI_NUMERICHOST
- PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
+ PyModule_AddIntMacro(m, AI_NUMERICHOST);
#endif
#ifdef AI_NUMERICSERV
- PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
+ PyModule_AddIntMacro(m, AI_NUMERICSERV);
#endif
#ifdef AI_MASK
- PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
+ PyModule_AddIntMacro(m, AI_MASK);
#endif
#ifdef AI_ALL
- PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
+ PyModule_AddIntMacro(m, AI_ALL);
#endif
#ifdef AI_V4MAPPED_CFG
- PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
+ PyModule_AddIntMacro(m, AI_V4MAPPED_CFG);
#endif
#ifdef AI_ADDRCONFIG
- PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
+ PyModule_AddIntMacro(m, AI_ADDRCONFIG);
#endif
#ifdef AI_V4MAPPED
- PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
+ PyModule_AddIntMacro(m, AI_V4MAPPED);
#endif
#ifdef AI_DEFAULT
- PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
+ PyModule_AddIntMacro(m, AI_DEFAULT);
#endif
#ifdef NI_MAXHOST
- PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
+ PyModule_AddIntMacro(m, NI_MAXHOST);
#endif
#ifdef NI_MAXSERV
- PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
+ PyModule_AddIntMacro(m, NI_MAXSERV);
#endif
#ifdef NI_NOFQDN
- PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
+ PyModule_AddIntMacro(m, NI_NOFQDN);
#endif
#ifdef NI_NUMERICHOST
- PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
+ PyModule_AddIntMacro(m, NI_NUMERICHOST);
#endif
#ifdef NI_NAMEREQD
- PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
+ PyModule_AddIntMacro(m, NI_NAMEREQD);
#endif
#ifdef NI_NUMERICSERV
- PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
+ PyModule_AddIntMacro(m, NI_NUMERICSERV);
#endif
#ifdef NI_DGRAM
- PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
+ PyModule_AddIntMacro(m, NI_DGRAM);
#endif
/* shutdown() parameters */
#ifdef SHUT_RD
- PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
+ PyModule_AddIntMacro(m, SHUT_RD);
#elif defined(SD_RECEIVE)
PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
#else
PyModule_AddIntConstant(m, "SHUT_RD", 0);
#endif
#ifdef SHUT_WR
- PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
+ PyModule_AddIntMacro(m, SHUT_WR);
#elif defined(SD_SEND)
PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
#else
PyModule_AddIntConstant(m, "SHUT_WR", 1);
#endif
#ifdef SHUT_RDWR
- PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
+ PyModule_AddIntMacro(m, SHUT_RDWR);
#elif defined(SD_BOTH)
PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
#else
@@ -6603,14 +6595,14 @@
PyModule_AddObject(m, names[i], tmp);
}
}
- PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
- PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
- PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
+ PyModule_AddIntMacro(m, RCVALL_OFF);
+ PyModule_AddIntMacro(m, RCVALL_ON);
+ PyModule_AddIntMacro(m, RCVALL_SOCKETLEVELONLY);
#ifdef RCVALL_IPLEVEL
- PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);
+ PyModule_AddIntMacro(m, RCVALL_IPLEVEL);
#endif
#ifdef RCVALL_MAX
- PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);
+ PyModule_AddIntMacro(m, RCVALL_MAX);
#endif
#endif /* _MSTCPIP_ */
diff --git a/Modules/symtablemodule.c b/Modules/symtablemodule.c
--- a/Modules/symtablemodule.c
+++ b/Modules/symtablemodule.c
@@ -69,30 +69,30 @@
m = PyModule_Create(&symtablemodule);
if (m == NULL)
return NULL;
- PyModule_AddIntConstant(m, "USE", USE);
- PyModule_AddIntConstant(m, "DEF_GLOBAL", DEF_GLOBAL);
- PyModule_AddIntConstant(m, "DEF_LOCAL", DEF_LOCAL);
- PyModule_AddIntConstant(m, "DEF_PARAM", DEF_PARAM);
- PyModule_AddIntConstant(m, "DEF_FREE", DEF_FREE);
- PyModule_AddIntConstant(m, "DEF_FREE_CLASS", DEF_FREE_CLASS);
- PyModule_AddIntConstant(m, "DEF_IMPORT", DEF_IMPORT);
- PyModule_AddIntConstant(m, "DEF_BOUND", DEF_BOUND);
+ PyModule_AddIntMacro(m, USE);
+ PyModule_AddIntMacro(m, DEF_GLOBAL);
+ PyModule_AddIntMacro(m, DEF_LOCAL);
+ PyModule_AddIntMacro(m, DEF_PARAM);
+ PyModule_AddIntMacro(m, DEF_FREE);
+ PyModule_AddIntMacro(m, DEF_FREE_CLASS);
+ PyModule_AddIntMacro(m, DEF_IMPORT);
+ PyModule_AddIntMacro(m, DEF_BOUND);
PyModule_AddIntConstant(m, "TYPE_FUNCTION", FunctionBlock);
PyModule_AddIntConstant(m, "TYPE_CLASS", ClassBlock);
PyModule_AddIntConstant(m, "TYPE_MODULE", ModuleBlock);
- PyModule_AddIntConstant(m, "OPT_IMPORT_STAR", OPT_IMPORT_STAR);
- PyModule_AddIntConstant(m, "OPT_TOPLEVEL", OPT_TOPLEVEL);
+ PyModule_AddIntMacro(m, OPT_IMPORT_STAR);
+ PyModule_AddIntMacro(m, OPT_TOPLEVEL);
- PyModule_AddIntConstant(m, "LOCAL", LOCAL);
- PyModule_AddIntConstant(m, "GLOBAL_EXPLICIT", GLOBAL_EXPLICIT);
- PyModule_AddIntConstant(m, "GLOBAL_IMPLICIT", GLOBAL_IMPLICIT);
- PyModule_AddIntConstant(m, "FREE", FREE);
- PyModule_AddIntConstant(m, "CELL", CELL);
+ PyModule_AddIntMacro(m, LOCAL);
+ PyModule_AddIntMacro(m, GLOBAL_EXPLICIT);
+ PyModule_AddIntMacro(m, GLOBAL_IMPLICIT);
+ PyModule_AddIntMacro(m, FREE);
+ PyModule_AddIntMacro(m, CELL);
PyModule_AddIntConstant(m, "SCOPE_OFF", SCOPE_OFFSET);
- PyModule_AddIntConstant(m, "SCOPE_MASK", SCOPE_MASK);
+ PyModule_AddIntMacro(m, SCOPE_MASK);
if (PyErr_Occurred()) {
Py_DECREF(m);
diff --git a/Modules/syslogmodule.c b/Modules/syslogmodule.c
--- a/Modules/syslogmodule.c
+++ b/Modules/syslogmodule.c
@@ -278,44 +278,44 @@
/* Add some symbolic constants to the module */
/* Priorities */
- 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);
+ PyModule_AddIntMacro(m, LOG_EMERG);
+ PyModule_AddIntMacro(m, LOG_ALERT);
+ PyModule_AddIntMacro(m, LOG_CRIT);
+ PyModule_AddIntMacro(m, LOG_ERR);
+ PyModule_AddIntMacro(m, LOG_WARNING);
+ PyModule_AddIntMacro(m, LOG_NOTICE);
+ PyModule_AddIntMacro(m, LOG_INFO);
+ PyModule_AddIntMacro(m, LOG_DEBUG);
/* openlog() option flags */
- PyModule_AddIntConstant(m, "LOG_PID", LOG_PID);
- PyModule_AddIntConstant(m, "LOG_CONS", LOG_CONS);
- PyModule_AddIntConstant(m, "LOG_NDELAY", LOG_NDELAY);
+ PyModule_AddIntMacro(m, LOG_PID);
+ PyModule_AddIntMacro(m, LOG_CONS);
+ PyModule_AddIntMacro(m, LOG_NDELAY);
#ifdef LOG_ODELAY
- PyModule_AddIntConstant(m, "LOG_ODELAY", LOG_ODELAY);
+ PyModule_AddIntMacro(m, LOG_ODELAY);
#endif
#ifdef LOG_NOWAIT
- PyModule_AddIntConstant(m, "LOG_NOWAIT", LOG_NOWAIT);
+ PyModule_AddIntMacro(m, LOG_NOWAIT);
#endif
#ifdef LOG_PERROR
- PyModule_AddIntConstant(m, "LOG_PERROR", LOG_PERROR);
+ PyModule_AddIntMacro(m, LOG_PERROR);
#endif
/* Facilities */
- 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);
+ PyModule_AddIntMacro(m, LOG_KERN);
+ PyModule_AddIntMacro(m, LOG_USER);
+ PyModule_AddIntMacro(m, LOG_MAIL);
+ PyModule_AddIntMacro(m, LOG_DAEMON);
+ PyModule_AddIntMacro(m, LOG_AUTH);
+ PyModule_AddIntMacro(m, LOG_LPR);
+ PyModule_AddIntMacro(m, LOG_LOCAL0);
+ PyModule_AddIntMacro(m, LOG_LOCAL1);
+ PyModule_AddIntMacro(m, LOG_LOCAL2);
+ PyModule_AddIntMacro(m, LOG_LOCAL3);
+ PyModule_AddIntMacro(m, LOG_LOCAL4);
+ PyModule_AddIntMacro(m, LOG_LOCAL5);
+ PyModule_AddIntMacro(m, LOG_LOCAL6);
+ PyModule_AddIntMacro(m, LOG_LOCAL7);
#ifndef LOG_SYSLOG
#define LOG_SYSLOG LOG_DAEMON
@@ -330,13 +330,13 @@
#define LOG_CRON LOG_DAEMON
#endif
- 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);
+ PyModule_AddIntMacro(m, LOG_SYSLOG);
+ PyModule_AddIntMacro(m, LOG_CRON);
+ PyModule_AddIntMacro(m, LOG_UUCP);
+ PyModule_AddIntMacro(m, LOG_NEWS);
#ifdef LOG_AUTHPRIV
- PyModule_AddIntConstant(m, "LOG_AUTHPRIV", LOG_AUTHPRIV);
+ PyModule_AddIntMacro(m, LOG_AUTHPRIV);
#endif
return m;
diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c
--- a/Modules/zlibmodule.c
+++ b/Modules/zlibmodule.c
@@ -1266,20 +1266,20 @@
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);
- PyModule_AddIntConstant(m, "Z_BEST_SPEED", Z_BEST_SPEED);
- PyModule_AddIntConstant(m, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION);
- PyModule_AddIntConstant(m, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION);
- PyModule_AddIntConstant(m, "Z_FILTERED", Z_FILTERED);
- PyModule_AddIntConstant(m, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY);
- PyModule_AddIntConstant(m, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY);
+ PyModule_AddIntMacro(m, MAX_WBITS);
+ PyModule_AddIntMacro(m, DEFLATED);
+ PyModule_AddIntMacro(m, DEF_MEM_LEVEL);
+ PyModule_AddIntMacro(m, Z_BEST_SPEED);
+ PyModule_AddIntMacro(m, Z_BEST_COMPRESSION);
+ PyModule_AddIntMacro(m, Z_DEFAULT_COMPRESSION);
+ PyModule_AddIntMacro(m, Z_FILTERED);
+ PyModule_AddIntMacro(m, Z_HUFFMAN_ONLY);
+ PyModule_AddIntMacro(m, Z_DEFAULT_STRATEGY);
- PyModule_AddIntConstant(m, "Z_FINISH", Z_FINISH);
- PyModule_AddIntConstant(m, "Z_NO_FLUSH", Z_NO_FLUSH);
- PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
- PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
+ PyModule_AddIntMacro(m, Z_FINISH);
+ PyModule_AddIntMacro(m, Z_NO_FLUSH);
+ PyModule_AddIntMacro(m, Z_SYNC_FLUSH);
+ PyModule_AddIntMacro(m, Z_FULL_FLUSH);
ver = PyUnicode_FromString(ZLIB_VERSION);
if (ver != NULL)
diff --git a/PC/_msi.c b/PC/_msi.c
--- a/PC/_msi.c
+++ b/PC/_msi.c
@@ -1030,40 +1030,40 @@
PyModule_AddIntConstant(m, "MSIDBOPEN_TRANSACT", (int)MSIDBOPEN_TRANSACT);
PyModule_AddIntConstant(m, "MSIDBOPEN_PATCHFILE", (int)MSIDBOPEN_PATCHFILE);
- PyModule_AddIntConstant(m, "MSICOLINFO_NAMES", MSICOLINFO_NAMES);
- PyModule_AddIntConstant(m, "MSICOLINFO_TYPES", MSICOLINFO_TYPES);
+ PyModule_AddIntMacro(m, MSICOLINFO_NAMES);
+ PyModule_AddIntMacro(m, MSICOLINFO_TYPES);
- PyModule_AddIntConstant(m, "MSIMODIFY_SEEK", MSIMODIFY_SEEK);
- PyModule_AddIntConstant(m, "MSIMODIFY_REFRESH", MSIMODIFY_REFRESH);
- PyModule_AddIntConstant(m, "MSIMODIFY_INSERT", MSIMODIFY_INSERT);
- PyModule_AddIntConstant(m, "MSIMODIFY_UPDATE", MSIMODIFY_UPDATE);
- PyModule_AddIntConstant(m, "MSIMODIFY_ASSIGN", MSIMODIFY_ASSIGN);
- PyModule_AddIntConstant(m, "MSIMODIFY_REPLACE", MSIMODIFY_REPLACE);
- PyModule_AddIntConstant(m, "MSIMODIFY_MERGE", MSIMODIFY_MERGE);
- PyModule_AddIntConstant(m, "MSIMODIFY_DELETE", MSIMODIFY_DELETE);
- PyModule_AddIntConstant(m, "MSIMODIFY_INSERT_TEMPORARY", MSIMODIFY_INSERT_TEMPORARY);
- PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE", MSIMODIFY_VALIDATE);
- PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE_NEW", MSIMODIFY_VALIDATE_NEW);
- PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE_FIELD", MSIMODIFY_VALIDATE_FIELD);
- PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE_DELETE", MSIMODIFY_VALIDATE_DELETE);
+ PyModule_AddIntMacro(m, MSIMODIFY_SEEK);
+ PyModule_AddIntMacro(m, MSIMODIFY_REFRESH);
+ PyModule_AddIntMacro(m, MSIMODIFY_INSERT);
+ PyModule_AddIntMacro(m, MSIMODIFY_UPDATE);
+ PyModule_AddIntMacro(m, MSIMODIFY_ASSIGN);
+ PyModule_AddIntMacro(m, MSIMODIFY_REPLACE);
+ PyModule_AddIntMacro(m, MSIMODIFY_MERGE);
+ PyModule_AddIntMacro(m, MSIMODIFY_DELETE);
+ PyModule_AddIntMacro(m, MSIMODIFY_INSERT_TEMPORARY);
+ PyModule_AddIntMacro(m, MSIMODIFY_VALIDATE);
+ PyModule_AddIntMacro(m, MSIMODIFY_VALIDATE_NEW);
+ PyModule_AddIntMacro(m, MSIMODIFY_VALIDATE_FIELD);
+ PyModule_AddIntMacro(m, MSIMODIFY_VALIDATE_DELETE);
- PyModule_AddIntConstant(m, "PID_CODEPAGE", PID_CODEPAGE);
- PyModule_AddIntConstant(m, "PID_TITLE", PID_TITLE);
- PyModule_AddIntConstant(m, "PID_SUBJECT", PID_SUBJECT);
- PyModule_AddIntConstant(m, "PID_AUTHOR", PID_AUTHOR);
- PyModule_AddIntConstant(m, "PID_KEYWORDS", PID_KEYWORDS);
- PyModule_AddIntConstant(m, "PID_COMMENTS", PID_COMMENTS);
- PyModule_AddIntConstant(m, "PID_TEMPLATE", PID_TEMPLATE);
- PyModule_AddIntConstant(m, "PID_LASTAUTHOR", PID_LASTAUTHOR);
- PyModule_AddIntConstant(m, "PID_REVNUMBER", PID_REVNUMBER);
- PyModule_AddIntConstant(m, "PID_LASTPRINTED", PID_LASTPRINTED);
- PyModule_AddIntConstant(m, "PID_CREATE_DTM", PID_CREATE_DTM);
- PyModule_AddIntConstant(m, "PID_LASTSAVE_DTM", PID_LASTSAVE_DTM);
- PyModule_AddIntConstant(m, "PID_PAGECOUNT", PID_PAGECOUNT);
- PyModule_AddIntConstant(m, "PID_WORDCOUNT", PID_WORDCOUNT);
- PyModule_AddIntConstant(m, "PID_CHARCOUNT", PID_CHARCOUNT);
- PyModule_AddIntConstant(m, "PID_APPNAME", PID_APPNAME);
- PyModule_AddIntConstant(m, "PID_SECURITY", PID_SECURITY);
+ PyModule_AddIntMacro(m, PID_CODEPAGE);
+ PyModule_AddIntMacro(m, PID_TITLE);
+ PyModule_AddIntMacro(m, PID_SUBJECT);
+ PyModule_AddIntMacro(m, PID_AUTHOR);
+ PyModule_AddIntMacro(m, PID_KEYWORDS);
+ PyModule_AddIntMacro(m, PID_COMMENTS);
+ PyModule_AddIntMacro(m, PID_TEMPLATE);
+ PyModule_AddIntMacro(m, PID_LASTAUTHOR);
+ PyModule_AddIntMacro(m, PID_REVNUMBER);
+ PyModule_AddIntMacro(m, PID_LASTPRINTED);
+ PyModule_AddIntMacro(m, PID_CREATE_DTM);
+ PyModule_AddIntMacro(m, PID_LASTSAVE_DTM);
+ PyModule_AddIntMacro(m, PID_PAGECOUNT);
+ PyModule_AddIntMacro(m, PID_WORDCOUNT);
+ PyModule_AddIntMacro(m, PID_CHARCOUNT);
+ PyModule_AddIntMacro(m, PID_APPNAME);
+ PyModule_AddIntMacro(m, PID_SECURITY);
MSIError = PyErr_NewException ("_msi.MSIError", NULL, NULL);
if (!MSIError)
diff --git a/Python/Python-ast.c b/Python/Python-ast.c
--- a/Python/Python-ast.c
+++ b/Python/Python-ast.c
@@ -6977,7 +6977,7 @@
d = PyModule_GetDict(m);
if (PyDict_SetItemString(d, "AST", (PyObject*)&AST_type) < 0) return
NULL;
- if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0)
+ if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0)
return NULL;
if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return
NULL;
--
Repository URL: http://hg.python.org/cpython
More information about the Python-checkins
mailing list