Recorded merge of revisions 81032 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/branches/py3k

................
  r81032 | antoine.pitrou | 2010-05-09 17:52:27 +0200 (dim., 09 mai 2010) | 9 lines

  Recorded merge of revisions 81029 via svnmerge from
  svn+ssh://pythondev@svn.python.org/python/trunk

  ........
    r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines

    Untabify C files. Will watch buildbots.
  ........
................

Demo/embed/demo.c

@@ -6,44 +6,44 @@ PyObject* PyInit_xyzzy(void); /* Forward */
 
 main(int argc, char **argv)
 {
-	/* Ignore passed-in argc/argv. If desired, conversion
-	   should use mbstowcs to convert them. */
-	wchar_t *args[] = {L"embed", L"hello", 0};
+    /* Ignore passed-in argc/argv. If desired, conversion
+       should use mbstowcs to convert them. */
+    wchar_t *args[] = {L"embed", L"hello", 0};
 
-	/* Pass argv[0] to the Python interpreter */
-	Py_SetProgramName(args[0]);
+    /* Pass argv[0] to the Python interpreter */
+    Py_SetProgramName(args[0]);
 
-	/* Add a static module */
-	PyImport_AppendInittab("xyzzy", PyInit_xyzzy);
+    /* Add a static module */
+    PyImport_AppendInittab("xyzzy", PyInit_xyzzy);
 
-	/* Initialize the Python interpreter.  Required. */
-	Py_Initialize();
+    /* Initialize the Python interpreter.  Required. */
+    Py_Initialize();
 
-	/* Define sys.argv.  It is up to the application if you
-	   want this; you can also let it undefined (since the Python 
-	   code is generally not a main program it has no business
-	   touching sys.argv...) */
-	PySys_SetArgv(2, args);
+    /* Define sys.argv.  It is up to the application if you
+       want this; you can also let it undefined (since the Python
+       code is generally not a main program it has no business
+       touching sys.argv...) */
+    PySys_SetArgv(2, args);
 
-	/* Do some application specific code */
-	printf("Hello, brave new world\n\n");
+    /* Do some application specific code */
+    printf("Hello, brave new world\n\n");
 
-	/* Execute some Python statements (in module __main__) */
-	PyRun_SimpleString("import sys\n");
-	PyRun_SimpleString("print(sys.builtin_module_names)\n");
-	PyRun_SimpleString("print(sys.modules.keys())\n");
-	PyRun_SimpleString("print(sys.executable)\n");
-	PyRun_SimpleString("print(sys.argv)\n");
+    /* Execute some Python statements (in module __main__) */
+    PyRun_SimpleString("import sys\n");
+    PyRun_SimpleString("print(sys.builtin_module_names)\n");
+    PyRun_SimpleString("print(sys.modules.keys())\n");
+    PyRun_SimpleString("print(sys.executable)\n");
+    PyRun_SimpleString("print(sys.argv)\n");
 
-	/* Note that you can call any public function of the Python
-	   interpreter here, e.g. call_object(). */
+    /* Note that you can call any public function of the Python
+       interpreter here, e.g. call_object(). */
 
-	/* Some more application specific code */
-	printf("\nGoodbye, cruel world\n");
+    /* Some more application specific code */
+    printf("\nGoodbye, cruel world\n");
 
-	/* Exit, cleaning up the interpreter */
-	Py_Exit(0);
-	/*NOTREACHED*/
+    /* Exit, cleaning up the interpreter */
+    Py_Exit(0);
+    /*NOTREACHED*/
 }
 
 /* A static module */
@@ -52,29 +52,29 @@ main(int argc, char **argv)
 static PyObject *
 xyzzy_foo(PyObject *self, PyObject* args)
 {
-	return PyLong_FromLong(42L);
+    return PyLong_FromLong(42L);
 }
 
 static PyMethodDef xyzzy_methods[] = {
-	{"foo",		xyzzy_foo,	METH_NOARGS,
-	 "Return the meaning of everything."},
-	{NULL,		NULL}		/* sentinel */
+    {"foo",             xyzzy_foo,      METH_NOARGS,
+     "Return the meaning of everything."},
+    {NULL,              NULL}           /* sentinel */
 };
 
 static struct PyModuleDef xyzzymodule = {
-	{}, /* m_base */
-	"xyzzy",  /* m_name */
-	0,  /* m_doc */
-	0,  /* m_size */
-	xyzzy_methods,  /* m_methods */
-	0,  /* m_reload */
-	0,  /* m_traverse */
-	0,  /* m_clear */
-	0,  /* m_free */
+    {}, /* m_base */
+    "xyzzy",  /* m_name */
+    0,  /* m_doc */
+    0,  /* m_size */
+    xyzzy_methods,  /* m_methods */
+    0,  /* m_reload */
+    0,  /* m_traverse */
+    0,  /* m_clear */
+    0,  /* m_free */
 };
 
 PyObject*
 PyInit_xyzzy(void)
 {
-	return PyModule_Create(&xyzzymodule);
+    return PyModule_Create(&xyzzymodule);
 }

Demo/embed/loop.c

@@ -6,28 +6,28 @@
 
 main(int argc, char **argv)
 {
-	int count = -1;
-	char *command;
+    int count = -1;
+    char *command;
 
-	if (argc < 2 || argc > 3) {
-		fprintf(stderr, "usage: loop <python-command> [count]\n");
-		exit(2);
-	}
-	command = argv[1];
+    if (argc < 2 || argc > 3) {
+        fprintf(stderr, "usage: loop <python-command> [count]\n");
+        exit(2);
+    }
+    command = argv[1];
 
-	if (argc == 3) {
-		count = atoi(argv[2]);
-	}
+    if (argc == 3) {
+        count = atoi(argv[2]);
+    }
 
-	Py_SetProgramName(argv[0]);
+    Py_SetProgramName(argv[0]);
 
-	/* uncomment this if you don't want to load site.py */
-	/* Py_NoSiteFlag = 1; */
+    /* uncomment this if you don't want to load site.py */
+    /* Py_NoSiteFlag = 1; */
 
-	while (count == -1 || --count >= 0 ) {
-		Py_Initialize();
-		PyRun_SimpleString(command);
-		Py_Finalize();
-	}
-	return 0;
+    while (count == -1 || --count >= 0 ) {
+        Py_Initialize();
+        PyRun_SimpleString(command);
+        Py_Finalize();
+    }
+    return 0;
 }

Include/ceval.h

@@ -8,7 +8,7 @@ extern "C" {
 /* Interface to random parts in ceval.c */
 
 PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
-	PyObject *, PyObject *, PyObject *);
+    PyObject *, PyObject *, PyObject *);
 
 /* DLL-level Backwards compatibility: */
 #undef PyEval_CallObject
@@ -16,7 +16,7 @@ PyAPI_FUNC(PyObject *) PyEval_CallObject(PyObject *, PyObject *);
 
 /* Inline this */
 #define PyEval_CallObject(func,arg) \
-        PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
+    PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
 
 PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,
                                            const char *format, ...);
@@ -49,7 +49,7 @@ PyAPI_FUNC(int) Py_MakePendingCalls(void);
      exceeds the current recursion limit. It raises a RuntimeError, and sets
      the "overflowed" flag in the thread state structure. This flag
      temporarily *disables* the normal protection; this allows cleanup code
-     to potentially outgrow the recursion limit while processing the 
+     to potentially outgrow the recursion limit while processing the
      RuntimeError.
    * "last chance" anti-recursion protection is triggered when the recursion
      level exceeds "current recursion limit + 50". By construction, this
@@ -71,12 +71,12 @@ PyAPI_FUNC(void) Py_SetRecursionLimit(int);
 PyAPI_FUNC(int) Py_GetRecursionLimit(void);
 
 #define Py_EnterRecursiveCall(where)  \
-	    (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
-	     _Py_CheckRecursiveCall(where))
-#define Py_LeaveRecursiveCall()				\
+            (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
+             _Py_CheckRecursiveCall(where))
+#define Py_LeaveRecursiveCall()                         \
     do{ if(_Py_MakeEndRecCheck(PyThreadState_GET()->recursion_depth))  \
-	  PyThreadState_GET()->overflowed = 0;  \
-	} while(0)
+      PyThreadState_GET()->overflowed = 0;  \
+    } while(0)
 PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where);
 PyAPI_DATA(int) _Py_CheckRecursionLimit;
 
@@ -87,15 +87,15 @@ PyAPI_DATA(int) _Py_CheckRecursionLimit;
    of _Py_CheckRecursionLimit for _Py_MakeEndRecCheck() to function properly.
 */
 #  define _Py_MakeRecCheck(x)  \
-	(++(x) > (_Py_CheckRecursionLimit += PyThreadState_GET()->overflowed - 1))
+    (++(x) > (_Py_CheckRecursionLimit += PyThreadState_GET()->overflowed - 1))
 #else
 #  define _Py_MakeRecCheck(x)  (++(x) > _Py_CheckRecursionLimit)
 #endif
 
 #define _Py_MakeEndRecCheck(x) \
-	(--(x) < ((_Py_CheckRecursionLimit > 100) \
-		? (_Py_CheckRecursionLimit - 50) \
-		: (3 * (_Py_CheckRecursionLimit >> 2))))
+    (--(x) < ((_Py_CheckRecursionLimit > 100) \
+        ? (_Py_CheckRecursionLimit - 50) \
+        : (3 * (_Py_CheckRecursionLimit >> 2))))
 
 #define Py_ALLOW_RECURSION \
   do { unsigned char _old = PyThreadState_GET()->recursion_critical;\
@@ -122,31 +122,31 @@ PyAPI_DATA(int) _Py_CheckInterval;
    that lasts a long time and doesn't touch Python data) can allow other
    threads to run as follows:
 
-	...preparations here...
-	Py_BEGIN_ALLOW_THREADS
-	...blocking system call here...
-	Py_END_ALLOW_THREADS
-	...interpret result here...
+    ...preparations here...
+    Py_BEGIN_ALLOW_THREADS
+    ...blocking system call here...
+    Py_END_ALLOW_THREADS
+    ...interpret result here...
 
    The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
    {}-surrounded block.
    To leave the block in the middle (e.g., with return), you must insert
    a line containing Py_BLOCK_THREADS before the return, e.g.
 
-	if (...premature_exit...) {
-		Py_BLOCK_THREADS
-		PyErr_SetFromErrno(PyExc_IOError);
-		return NULL;
-	}
+    if (...premature_exit...) {
+        Py_BLOCK_THREADS
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
 
    An alternative is:
 
-	Py_BLOCK_THREADS
-	if (...premature_exit...) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		return NULL;
-	}
-	Py_UNBLOCK_THREADS
+    Py_BLOCK_THREADS
+    if (...premature_exit...) {
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+    Py_UNBLOCK_THREADS
 
    For convenience, that the value of 'errno' is restored across
    Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
@@ -175,12 +175,12 @@ PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
 PyAPI_FUNC(void) PyEval_ReInitThreads(void);
 
 #define Py_BEGIN_ALLOW_THREADS { \
-			PyThreadState *_save; \
-			_save = PyEval_SaveThread();
-#define Py_BLOCK_THREADS	PyEval_RestoreThread(_save);
-#define Py_UNBLOCK_THREADS	_save = PyEval_SaveThread();
-#define Py_END_ALLOW_THREADS	PyEval_RestoreThread(_save); \
-		 }
+                        PyThreadState *_save; \
+                        _save = PyEval_SaveThread();
+#define Py_BLOCK_THREADS        PyEval_RestoreThread(_save);
+#define Py_UNBLOCK_THREADS      _save = PyEval_SaveThread();
+#define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
+                 }
 
 #else /* !WITH_THREAD */
 

Include/datetime.h

@@ -11,13 +11,13 @@ extern "C" {
  * big-endian, unless otherwise noted:
  *
  * byte offset
- *  0 		year     2 bytes, 1-9999
- *  2		month    1 byte, 1-12
- *  3 		day      1 byte, 1-31
- *  4		hour     1 byte, 0-23
- *  5 		minute   1 byte, 0-59
- *  6 		second   1 byte, 0-59
- *  7 		usecond  3 bytes, 0-999999
+ *  0           year     2 bytes, 1-9999
+ *  2           month    1 byte, 1-12
+ *  3           day      1 byte, 1-31
+ *  4           hour     1 byte, 0-23
+ *  5           minute   1 byte, 0-59
+ *  6           second   1 byte, 0-59
+ *  7           usecond  3 bytes, 0-999999
  * 10
  */
 
@@ -33,26 +33,26 @@ extern "C" {
 
 typedef struct
 {
-	PyObject_HEAD
-	long hashcode;		/* -1 when unknown */
-	int days;		/* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
-	int seconds;		/* 0 <= seconds < 24*3600 is invariant */
-	int microseconds;	/* 0 <= microseconds < 1000000 is invariant */
+    PyObject_HEAD
+    long hashcode;              /* -1 when unknown */
+    int days;                   /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
+    int seconds;                /* 0 <= seconds < 24*3600 is invariant */
+    int microseconds;           /* 0 <= microseconds < 1000000 is invariant */
 } PyDateTime_Delta;
 
 typedef struct
 {
-	PyObject_HEAD		/* a pure abstract base clase */
+    PyObject_HEAD               /* a pure abstract base clase */
 } PyDateTime_TZInfo;
 
 
 /* The datetime and time types have hashcodes, and an optional tzinfo member,
  * present if and only if hastzinfo is true.
  */
-#define _PyTZINFO_HEAD		\
-	PyObject_HEAD		\
-	long hashcode;		\
-	char hastzinfo;		/* boolean flag */
+#define _PyTZINFO_HEAD          \
+    PyObject_HEAD               \
+    long hashcode;              \
+    char hastzinfo;             /* boolean flag */
 
 /* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
  * convenient to cast to, when getting at the hastzinfo member of objects
@@ -60,7 +60,7 @@ typedef struct
  */
 typedef struct
 {
-	_PyTZINFO_HEAD
+    _PyTZINFO_HEAD
 } _PyDateTime_BaseTZInfo;
 
 /* All time objects are of PyDateTime_TimeType, but that can be allocated
@@ -69,20 +69,20 @@ typedef struct
  * internal struct used to allocate the right amount of space for the
  * "without" case.
  */
-#define _PyDateTime_TIMEHEAD	\
-	_PyTZINFO_HEAD		\
-	unsigned char data[_PyDateTime_TIME_DATASIZE];
+#define _PyDateTime_TIMEHEAD    \
+    _PyTZINFO_HEAD              \
+    unsigned char data[_PyDateTime_TIME_DATASIZE];
 
 typedef struct
 {
-	_PyDateTime_TIMEHEAD
-} _PyDateTime_BaseTime;		/* hastzinfo false */
+    _PyDateTime_TIMEHEAD
+} _PyDateTime_BaseTime;         /* hastzinfo false */
 
 typedef struct
 {
-	_PyDateTime_TIMEHEAD
-	PyObject *tzinfo;
-} PyDateTime_Time;		/* hastzinfo true */
+    _PyDateTime_TIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_Time;              /* hastzinfo true */
 
 
 /* All datetime objects are of PyDateTime_DateTimeType, but that can be
@@ -92,48 +92,48 @@ typedef struct
  */
 typedef struct
 {
-	_PyTZINFO_HEAD
-	unsigned char data[_PyDateTime_DATE_DATASIZE];
+    _PyTZINFO_HEAD
+    unsigned char data[_PyDateTime_DATE_DATASIZE];
 } PyDateTime_Date;
 
-#define _PyDateTime_DATETIMEHEAD	\
-	_PyTZINFO_HEAD			\
-	unsigned char data[_PyDateTime_DATETIME_DATASIZE];
+#define _PyDateTime_DATETIMEHEAD        \
+    _PyTZINFO_HEAD                      \
+    unsigned char data[_PyDateTime_DATETIME_DATASIZE];
 
 typedef struct
 {
-	_PyDateTime_DATETIMEHEAD
-} _PyDateTime_BaseDateTime;	/* hastzinfo false */
+    _PyDateTime_DATETIMEHEAD
+} _PyDateTime_BaseDateTime;     /* hastzinfo false */
 
 typedef struct
 {
-	_PyDateTime_DATETIMEHEAD
-	PyObject *tzinfo;
-} PyDateTime_DateTime;		/* hastzinfo true */
+    _PyDateTime_DATETIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_DateTime;          /* hastzinfo true */
 
 
 /* Apply for date and datetime instances. */
 #define PyDateTime_GET_YEAR(o)     ((((PyDateTime_Date*)o)->data[0] << 8) | \
-                                     ((PyDateTime_Date*)o)->data[1])
+                     ((PyDateTime_Date*)o)->data[1])
 #define PyDateTime_GET_MONTH(o)    (((PyDateTime_Date*)o)->data[2])
 #define PyDateTime_GET_DAY(o)      (((PyDateTime_Date*)o)->data[3])
 
 #define PyDateTime_DATE_GET_HOUR(o)        (((PyDateTime_DateTime*)o)->data[4])
 #define PyDateTime_DATE_GET_MINUTE(o)      (((PyDateTime_DateTime*)o)->data[5])
 #define PyDateTime_DATE_GET_SECOND(o)      (((PyDateTime_DateTime*)o)->data[6])
-#define PyDateTime_DATE_GET_MICROSECOND(o) 		\
-	((((PyDateTime_DateTime*)o)->data[7] << 16) |	\
-         (((PyDateTime_DateTime*)o)->data[8] << 8)  |	\
-          ((PyDateTime_DateTime*)o)->data[9])
+#define PyDateTime_DATE_GET_MICROSECOND(o)              \
+    ((((PyDateTime_DateTime*)o)->data[7] << 16) |       \
+     (((PyDateTime_DateTime*)o)->data[8] << 8)  |       \
+      ((PyDateTime_DateTime*)o)->data[9])
 
 /* Apply for time instances. */
 #define PyDateTime_TIME_GET_HOUR(o)        (((PyDateTime_Time*)o)->data[0])
 #define PyDateTime_TIME_GET_MINUTE(o)      (((PyDateTime_Time*)o)->data[1])
 #define PyDateTime_TIME_GET_SECOND(o)      (((PyDateTime_Time*)o)->data[2])
-#define PyDateTime_TIME_GET_MICROSECOND(o) 		\
-	((((PyDateTime_Time*)o)->data[3] << 16) |	\
-         (((PyDateTime_Time*)o)->data[4] << 8)  |	\
-          ((PyDateTime_Time*)o)->data[5])
+#define PyDateTime_TIME_GET_MICROSECOND(o)              \
+    ((((PyDateTime_Time*)o)->data[3] << 16) |           \
+     (((PyDateTime_Time*)o)->data[4] << 8)  |           \
+      ((PyDateTime_Time*)o)->data[5])
 
 
 /* Define structure for C API. */
@@ -148,7 +148,7 @@ typedef struct {
     /* constructors */
     PyObject *(*Date_FromDate)(int, int, int, PyTypeObject*);
     PyObject *(*DateTime_FromDateAndTime)(int, int, int, int, int, int, int,
-            PyObject*, PyTypeObject*);
+        PyObject*, PyTypeObject*);
     PyObject *(*Time_FromTime)(int, int, int, int, PyObject*, PyTypeObject*);
     PyObject *(*Delta_FromDelta)(int, int, int, int, PyTypeObject*);
 
@@ -185,7 +185,7 @@ typedef struct {
 static PyDateTime_CAPI *PyDateTimeAPI;
 
 #define PyDateTime_IMPORT \
-        PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
+    PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
 
 /* Macros for type checking when not building the Python core. */
 #define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType)
@@ -205,30 +205,30 @@ static PyDateTime_CAPI *PyDateTimeAPI;
 
 /* Macros for accessing constructors in a simplified fashion. */
 #define PyDate_FromDate(year, month, day) \
-	PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
+    PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
 
 #define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \
-	PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
-		min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
+    PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
+        min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
 
 #define PyTime_FromTime(hour, minute, second, usecond) \
-	PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
-		Py_None, PyDateTimeAPI->TimeType)
+    PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
+        Py_None, PyDateTimeAPI->TimeType)
 
 #define PyDelta_FromDSU(days, seconds, useconds) \
-	PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
-		PyDateTimeAPI->DeltaType)
+    PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
+        PyDateTimeAPI->DeltaType)
 
 /* Macros supporting the DB API. */
 #define PyDateTime_FromTimestamp(args) \
-	PyDateTimeAPI->DateTime_FromTimestamp( \
-		(PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
+    PyDateTimeAPI->DateTime_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
 
 #define PyDate_FromTimestamp(args) \
-	PyDateTimeAPI->Date_FromTimestamp( \
-		(PyObject*) (PyDateTimeAPI->DateType), args)
+    PyDateTimeAPI->Date_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateType), args)
 
-#endif	/* Py_BUILD_CORE */
+#endif  /* Py_BUILD_CORE */
 
 #ifdef __cplusplus
 }

Include/descrobject.h

@@ -9,27 +9,27 @@ typedef PyObject *(*getter)(PyObject *, void *);
 typedef int (*setter)(PyObject *, PyObject *, void *);
 
 typedef struct PyGetSetDef {
-	char *name;
-	getter get;
-	setter set;
-	char *doc;
-	void *closure;
+    char *name;
+    getter get;
+    setter set;
+    char *doc;
+    void *closure;
 } PyGetSetDef;
 
 typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
-				 void *wrapped);
+                                 void *wrapped);
 
 typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
-				      void *wrapped, PyObject *kwds);
+                                      void *wrapped, PyObject *kwds);
 
 struct wrapperbase {
-	char *name;
-	int offset;
-	void *function;
-	wrapperfunc wrapper;
-	char *doc;
-	int flags;
-	PyObject *name_strobj;
+    char *name;
+    int offset;
+    void *function;
+    wrapperfunc wrapper;
+    char *doc;
+    int flags;
+    PyObject *name_strobj;
 };
 
 /* Flags for above struct */
@@ -38,33 +38,33 @@ struct wrapperbase {
 /* Various kinds of descriptor objects */
 
 #define PyDescr_COMMON \
-	PyObject_HEAD \
-	PyTypeObject *d_type; \
-	PyObject *d_name
+    PyObject_HEAD \
+    PyTypeObject *d_type; \
+    PyObject *d_name
 
 typedef struct {
-	PyDescr_COMMON;
+    PyDescr_COMMON;
 } PyDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	PyMethodDef *d_method;
+    PyDescr_COMMON;
+    PyMethodDef *d_method;
 } PyMethodDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	struct PyMemberDef *d_member;
+    PyDescr_COMMON;
+    struct PyMemberDef *d_member;
 } PyMemberDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	PyGetSetDef *d_getset;
+    PyDescr_COMMON;
+    PyGetSetDef *d_getset;
 } PyGetSetDescrObject;
 
 typedef struct {
-	PyDescr_COMMON;
-	struct wrapperbase *d_base;
-	void *d_wrapped; /* This can be any function pointer */
+    PyDescr_COMMON;
+    struct wrapperbase *d_base;
+    void *d_wrapped; /* This can be any function pointer */
 } PyWrapperDescrObject;
 
 PyAPI_DATA(PyTypeObject) PyClassMethodDescr_Type;
@@ -77,11 +77,11 @@ PyAPI_DATA(PyTypeObject) PyDictProxy_Type;
 PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
-					       struct PyMemberDef *);
+                                               struct PyMemberDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
-					       struct PyGetSetDef *);
+                                               struct PyGetSetDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
-						struct wrapperbase *, void *);
+                                                struct wrapperbase *, void *);
 #define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)
 
 PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *);

Include/dictobject.h

@@ -48,13 +48,13 @@ meaning otherwise.
 #define PyDict_MINSIZE 8
 
 typedef struct {
-	/* Cached hash code of me_key.  Note that hash codes are C longs.
-	 * We have to use Py_ssize_t instead because dict_popitem() abuses
-	 * me_hash to hold a search finger.
-	 */
-	Py_ssize_t me_hash;
-	PyObject *me_key;
-	PyObject *me_value;
+    /* Cached hash code of me_key.  Note that hash codes are C longs.
+     * We have to use Py_ssize_t instead because dict_popitem() abuses
+     * me_hash to hold a search finger.
+     */
+    Py_ssize_t me_hash;
+    PyObject *me_key;
+    PyObject *me_value;
 } PyDictEntry;
 
 /*
@@ -68,24 +68,24 @@ it's two-thirds full.
 */
 typedef struct _dictobject PyDictObject;
 struct _dictobject {
-	PyObject_HEAD
-	Py_ssize_t ma_fill;  /* # Active + # Dummy */
-	Py_ssize_t ma_used;  /* # Active */
-
-	/* The table contains ma_mask + 1 slots, and that's a power of 2.
-	 * We store the mask instead of the size because the mask is more
-	 * frequently needed.
-	 */
-	Py_ssize_t ma_mask;
-
-	/* ma_table points to ma_smalltable for small tables, else to
-	 * additional malloc'ed memory.  ma_table is never NULL!  This rule
-	 * saves repeated runtime null-tests in the workhorse getitem and
-	 * setitem calls.
-	 */
-	PyDictEntry *ma_table;
-	PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
-	PyDictEntry ma_smalltable[PyDict_MINSIZE];
+    PyObject_HEAD
+    Py_ssize_t ma_fill;  /* # Active + # Dummy */
+    Py_ssize_t ma_used;  /* # Active */
+
+    /* The table contains ma_mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t ma_mask;
+
+    /* ma_table points to ma_smalltable for small tables, else to
+     * additional malloc'ed memory.  ma_table is never NULL!  This rule
+     * saves repeated runtime null-tests in the workhorse getitem and
+     * setitem calls.
+     */
+    PyDictEntry *ma_table;
+    PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
+    PyDictEntry ma_smalltable[PyDict_MINSIZE];
 };
 
 PyAPI_DATA(PyTypeObject) PyDict_Type;
@@ -104,7 +104,7 @@ PyAPI_DATA(PyTypeObject) PyDictValues_Type;
 #define PyDictValues_Check(op) (Py_TYPE(op) == &PyDictValues_Type)
 /* This excludes Values, since they are not sets. */
 # define PyDictViewSet_Check(op) \
-	(PyDictKeys_Check(op) || PyDictItems_Check(op))
+    (PyDictKeys_Check(op) || PyDictItems_Check(op))
 
 
 PyAPI_FUNC(PyObject *) PyDict_New(void);
@@ -114,9 +114,9 @@ PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
 PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key);
 PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
 PyAPI_FUNC(int) PyDict_Next(
-	PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
 PyAPI_FUNC(int) _PyDict_Next(
-	PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
 PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
 PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
 PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp);
@@ -136,8 +136,8 @@ PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other);
    dict.update(other) is equivalent to PyDict_Merge(dict, other, 1).
 */
 PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
-				   PyObject *other,
-				   int override);
+                                   PyObject *other,
+                                   int override);
 
 /* PyDict_MergeFromSeq2 updates/merges from an iterable object producing
    iterable objects of length 2.  If override is true, the last occurrence
@@ -145,8 +145,8 @@ PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
    is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1).
 */
 PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d,
-					   PyObject *seq2,
-					   int override);
+                                           PyObject *seq2,
+                                           int override);
 
 PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key);
 PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item);

Include/pyerrors.h

@@ -8,8 +8,8 @@ extern "C" {
 
 /* PyException_HEAD defines the initial segment of every exception class. */
 #define PyException_HEAD PyObject_HEAD PyObject *dict;\
-                         PyObject *args; PyObject *traceback;\
-                         PyObject *context; PyObject *cause;
+             PyObject *args; PyObject *traceback;\
+             PyObject *context; PyObject *cause;
 
 typedef struct {
     PyException_HEAD
@@ -92,15 +92,15 @@ PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *);
 
 /* */
 
-#define PyExceptionClass_Check(x)					\
-	(PyType_Check((x)) &&						\
-	 PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
+#define PyExceptionClass_Check(x)                                       \
+    (PyType_Check((x)) &&                                               \
+     PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
 
-#define PyExceptionInstance_Check(x)			\
-	PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
+#define PyExceptionInstance_Check(x)                    \
+    PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
 
 #define PyExceptionClass_Name(x) \
-	 ((char *)(((PyTypeObject*)(x))->tp_name))
+     ((char *)(((PyTypeObject*)(x))->tp_name))
 
 #define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type))
 
@@ -175,29 +175,29 @@ PyAPI_FUNC(int) PyErr_BadArgument(void);
 PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
-	PyObject *, PyObject *);
+    PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(PyObject *, const char *);
 #ifdef MS_WINDOWS
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
-	PyObject *, const Py_UNICODE *);
+    PyObject *, const Py_UNICODE *);
 #endif /* MS_WINDOWS */
 
 PyAPI_FUNC(PyObject *) PyErr_Format(PyObject *, const char *, ...);
 
 #ifdef MS_WINDOWS
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilenameObject(
-	int, const char *);
+    int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
-	int, const char *);
+    int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
-	int, const Py_UNICODE *);
+    int, const Py_UNICODE *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
-	PyObject *,int, PyObject *);
+    PyObject *,int, PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
-	PyObject *,int, const char *);
+    PyObject *,int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
-	PyObject *,int, const Py_UNICODE *);
+    PyObject *,int, const Py_UNICODE *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
 #endif /* MS_WINDOWS */
 
@@ -229,15 +229,15 @@ PyAPI_FUNC(PyObject *) PyErr_ProgramText(const char *, int);
 
 /* create a UnicodeDecodeError object */
 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
-	const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 
 /* create a UnicodeEncodeError object */
 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
-	const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 
 /* create a UnicodeTranslateError object */
 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
-	const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 
 /* get the encoding attribute */
 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
@@ -280,11 +280,11 @@ PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);
 /* assign a new value to the reason attribute
    return 0 on success, -1 on failure */
 PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
-	PyObject *, const char *);
+    PyObject *, const char *);
 PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
-	PyObject *, const char *);
+    PyObject *, const char *);
 PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
-	PyObject *, const char *);
+    PyObject *, const char *);
 
 
 /* These APIs aren't really part of the error implementation, but
@@ -303,9 +303,9 @@ PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
 
 #include <stdarg.h>
 PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char  *format, ...)
-			Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
 PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)
-			Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
 
 #ifdef __cplusplus
 }

Include/pymacconfig.h

@@ -4,7 +4,7 @@
       * This file moves some of the autoconf magic to compile-time
       * when building on MacOSX. This is needed for building 4-way
       * universal binaries and for 64-bit universal binaries because
-      * the values redefined below aren't configure-time constant but 
+      * the values redefined below aren't configure-time constant but
       * only compile-time constant in these scenarios.
       */
 
@@ -34,36 +34,36 @@
 
 #    undef SIZEOF_LONG
 #    ifdef __LP64__
-#	 define SIZEOF__BOOL		1
-#        define SIZEOF__BOOL		1
-#        define SIZEOF_LONG 		8
-#        define SIZEOF_PTHREAD_T 	8
-#        define SIZEOF_SIZE_T 		8
-#        define SIZEOF_TIME_T 		8
-#        define SIZEOF_VOID_P 		8
+#        define SIZEOF__BOOL            1
+#        define SIZEOF__BOOL            1
+#        define SIZEOF_LONG             8
+#        define SIZEOF_PTHREAD_T        8
+#        define SIZEOF_SIZE_T           8
+#        define SIZEOF_TIME_T           8
+#        define SIZEOF_VOID_P           8
 #    else
 #        ifdef __ppc__
-#	    define SIZEOF__BOOL		4
+#           define SIZEOF__BOOL         4
 #        else
-#	    define SIZEOF__BOOL		1
+#           define SIZEOF__BOOL         1
 #        endif
-#        define SIZEOF_LONG 		4
-#        define SIZEOF_PTHREAD_T 	4
-#        define SIZEOF_SIZE_T 		4
-#        define SIZEOF_TIME_T 		4
-#        define SIZEOF_VOID_P 		4
+#        define SIZEOF_LONG             4
+#        define SIZEOF_PTHREAD_T        4
+#        define SIZEOF_SIZE_T           4
+#        define SIZEOF_TIME_T           4
+#        define SIZEOF_VOID_P           4
 #    endif
 
 #    if defined(__LP64__)
-	 /* MacOSX 10.4 (the first release to suppport 64-bit code
-	  * at all) only supports 64-bit in the UNIX layer. 
-	  * Therefore surpress the toolbox-glue in 64-bit mode.
-	  */
+     /* MacOSX 10.4 (the first release to suppport 64-bit code
+      * at all) only supports 64-bit in the UNIX layer.
+      * Therefore surpress the toolbox-glue in 64-bit mode.
+      */
 
-	/* In 64-bit mode setpgrp always has no argments, in 32-bit
-	 * mode that depends on the compilation environment
-	 */
-#	undef SETPGRP_HAVE_ARG
+    /* In 64-bit mode setpgrp always has no argments, in 32-bit
+     * mode that depends on the compilation environment
+     */
+#       undef SETPGRP_HAVE_ARG
 
 #    endif
 
@@ -78,17 +78,17 @@
 # define HAVE_GCC_ASM_FOR_X87
 #endif
 
-	/* 
-	 * The definition in pyconfig.h is only valid on the OS release
-	 * where configure ran on and not necessarily for all systems where
-	 * the executable can be used on. 
-	 * 
-	 * Specifically: OSX 10.4 has limited supported for '%zd', while
-	 * 10.5 has full support for '%zd'. A binary built on 10.5 won't
-	 * work properly on 10.4 unless we surpress the definition
-	 * of PY_FORMAT_SIZE_T
-	 */
-#undef	PY_FORMAT_SIZE_T
+    /*
+     * The definition in pyconfig.h is only valid on the OS release
+     * where configure ran on and not necessarily for all systems where
+     * the executable can be used on.
+     *
+     * Specifically: OSX 10.4 has limited supported for '%zd', while
+     * 10.5 has full support for '%zd'. A binary built on 10.5 won't
+     * work properly on 10.4 unless we surpress the definition
+     * of PY_FORMAT_SIZE_T
+     */
+#undef  PY_FORMAT_SIZE_T
 
 
 #endif /* defined(_APPLE__) */

Include/pythonrun.h

@@ -17,7 +17,7 @@ extern "C" {
 #define PyCF_IGNORE_COOKIE 0x0800
 
 typedef struct {
-	int cf_flags;  /* bitmask of CO_xxx flags relevant to future */
+    int cf_flags;  /* bitmask of CO_xxx flags relevant to future */
 } PyCompilerFlags;
 
 PyAPI_FUNC(void) Py_SetProgramName(wchar_t *);
@@ -40,33 +40,33 @@ PyAPI_FUNC(int) PyRun_SimpleFileExFlags(FILE *, const char *, int, PyCompilerFla
 PyAPI_FUNC(int) PyRun_InteractiveOneFlags(FILE *, const char *, PyCompilerFlags *);
 PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(FILE *, const char *, PyCompilerFlags *);
 
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(const char *, const char *, 
-						 int, PyCompilerFlags *flags,
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(const char *, const char *,
+                                                 int, PyCompilerFlags *flags,
                                                  PyArena *);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(FILE *, const char *, 
-					       const char*, int, 
-					       char *, char *,
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(FILE *, const char *,
+                                               const char*, int,
+                                               char *, char *,
                                                PyCompilerFlags *, int *,
                                                PyArena *);
 #define PyParser_SimpleParseString(S, B) \
-        PyParser_SimpleParseStringFlags(S, B, 0)
+    PyParser_SimpleParseStringFlags(S, B, 0)
 #define PyParser_SimpleParseFile(FP, S, B) \
-        PyParser_SimpleParseFileFlags(FP, S, B, 0)
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int, 
-							  int);
+    PyParser_SimpleParseFileFlags(FP, S, B, 0)
+PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
+                                                          int);
 PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *,
-							int, int);
+                                                        int, int);
 
-PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *, 
-					 PyObject *, PyCompilerFlags *);
+PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
+                                         PyObject *, PyCompilerFlags *);
 
-PyAPI_FUNC(PyObject *) PyRun_FileExFlags(FILE *, const char *, int, 
-					 PyObject *, PyObject *, int, 
-					 PyCompilerFlags *);
+PyAPI_FUNC(PyObject *) PyRun_FileExFlags(FILE *, const char *, int,
+                                         PyObject *, PyObject *, int,
+                                         PyCompilerFlags *);
 
 #define Py_CompileString(str, p, s) Py_CompileStringFlags(str, p, s, NULL)
 PyAPI_FUNC(PyObject *) Py_CompileStringFlags(const char *, const char *, int,
-					     PyCompilerFlags *);
+                                             PyCompilerFlags *);
 PyAPI_FUNC(struct symtable *) Py_SymtableString(const char *, const char *, int);
 
 PyAPI_FUNC(void) PyErr_Print(void);
@@ -90,20 +90,20 @@ PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv);
 #define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL)
 #define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
 #define PyRun_AnyFileEx(fp, name, closeit) \
-	PyRun_AnyFileExFlags(fp, name, closeit, NULL)
+    PyRun_AnyFileExFlags(fp, name, closeit, NULL)
 #define PyRun_AnyFileFlags(fp, name, flags) \
-	PyRun_AnyFileExFlags(fp, name, 0, flags)
+    PyRun_AnyFileExFlags(fp, name, 0, flags)
 #define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
 #define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
 #define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL)
 #define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL)
 #define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
 #define PyRun_File(fp, p, s, g, l) \
-        PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
+    PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
 #define PyRun_FileEx(fp, p, s, g, l, c) \
-        PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
+    PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
 #define PyRun_FileFlags(fp, p, s, g, l, flags) \
-        PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
+    PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
 
 /* In getpath.c */
 PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void);

Include/setobject.h

@@ -22,8 +22,8 @@ no meaning otherwise.
 #define PySet_MINSIZE 8
 
 typedef struct {
-	long hash;      /* cached hash code for the entry key */
-	PyObject *key;
+    long hash;      /* cached hash code for the entry key */
+    PyObject *key;
 } setentry;
 
 
@@ -33,27 +33,27 @@ This data structure is shared by set and frozenset objects.
 
 typedef struct _setobject PySetObject;
 struct _setobject {
-	PyObject_HEAD
-
-	Py_ssize_t fill;  /* # Active + # Dummy */
-	Py_ssize_t used;  /* # Active */
-
-	/* The table contains mask + 1 slots, and that's a power of 2.
-	 * We store the mask instead of the size because the mask is more
-	 * frequently needed.
-	 */
-	Py_ssize_t mask;
-
-	/* table points to smalltable for small tables, else to
-	 * additional malloc'ed memory.  table is never NULL!  This rule
-	 * saves repeated runtime null-tests.
-	 */
-	setentry *table;
-	setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
-	setentry smalltable[PySet_MINSIZE];
-
-	long hash;		/* only used by frozenset objects */
-	PyObject *weakreflist;	/* List of weak references */
+    PyObject_HEAD
+
+    Py_ssize_t fill;  /* # Active + # Dummy */
+    Py_ssize_t used;  /* # Active */
+
+    /* The table contains mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t mask;
+
+    /* table points to smalltable for small tables, else to
+     * additional malloc'ed memory.  table is never NULL!  This rule
+     * saves repeated runtime null-tests.
+     */
+    setentry *table;
+    setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
+    setentry smalltable[PySet_MINSIZE];
+
+    long hash;                  /* only used by frozenset objects */
+    PyObject *weakreflist;      /* List of weak references */
 };
 
 PyAPI_DATA(PyTypeObject) PySet_Type;
@@ -69,17 +69,17 @@ PyAPI_DATA(PyTypeObject) PySetIter_Type;
 
 #define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_CheckExact(ob) \
-	(Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
+    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_Check(ob) \
-	(Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
-	  PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
-	  PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
+      PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
 #define PySet_Check(ob) \
-	(Py_TYPE(ob) == &PySet_Type || \
-	PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
+    (Py_TYPE(ob) == &PySet_Type || \
+    PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
 #define   PyFrozenSet_Check(ob) \
-	(Py_TYPE(ob) == &PyFrozenSet_Type || \
-	  PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+    (Py_TYPE(ob) == &PyFrozenSet_Type || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
 
 PyAPI_FUNC(PyObject *) PySet_New(PyObject *);
 PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *);

Include/structseq.h

@@ -8,35 +8,35 @@ extern "C" {
 #endif
 
 typedef struct PyStructSequence_Field {
-	char *name;
-	char *doc;
+    char *name;
+    char *doc;
 } PyStructSequence_Field;
 
 typedef struct PyStructSequence_Desc {
-	char *name;
-	char *doc;
-	struct PyStructSequence_Field *fields;
-	int n_in_sequence;
+    char *name;
+    char *doc;
+    struct PyStructSequence_Field *fields;
+    int n_in_sequence;
 } PyStructSequence_Desc;
 
 extern char* PyStructSequence_UnnamedField;
 
 PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type,
-					   PyStructSequence_Desc *desc);
+                                           PyStructSequence_Desc *desc);
 
 PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type);
 
 typedef struct {
-	PyObject_VAR_HEAD
-	PyObject *ob_item[1];
+    PyObject_VAR_HEAD
+    PyObject *ob_item[1];
 } PyStructSequence;
 
 /* Macro, *only* to be used to fill in brand new objects */
 #define PyStructSequence_SET_ITEM(op, i, v) \
-	(((PyStructSequence *)(op))->ob_item[i] = v)
+    (((PyStructSequence *)(op))->ob_item[i] = v)
 
 #define PyStructSequence_GET_ITEM(op, i) \
-	(((PyStructSequence *)(op))->ob_item[i])
+    (((PyStructSequence *)(op))->ob_item[i])
 
 
 #ifdef __cplusplus

Include/symtable.h

@@ -15,40 +15,40 @@ typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock }
 struct _symtable_entry;
 
 struct symtable {
-	const char *st_filename;        /* name of file being compiled */
-	struct _symtable_entry *st_cur; /* current symbol table entry */
-	struct _symtable_entry *st_top; /* symbol table entry for module */
-	PyObject *st_blocks;            /* dict: map AST node addresses
-	                                 *       to symbol table entries */
-	PyObject *st_stack;             /* list: stack of namespace info */
-	PyObject *st_global;            /* borrowed ref to st_top->st_symbols */
-	int st_nblocks;                 /* number of blocks used */
-	PyObject *st_private;           /* name of current class or NULL */
-	PyFutureFeatures *st_future;    /* module's future features */
+    const char *st_filename;        /* name of file being compiled */
+    struct _symtable_entry *st_cur; /* current symbol table entry */
+    struct _symtable_entry *st_top; /* symbol table entry for module */
+    PyObject *st_blocks;            /* dict: map AST node addresses
+                                     *       to symbol table entries */
+    PyObject *st_stack;             /* list: stack of namespace info */
+    PyObject *st_global;            /* borrowed ref to st_top->st_symbols */
+    int st_nblocks;                 /* number of blocks used */
+    PyObject *st_private;           /* name of current class or NULL */
+    PyFutureFeatures *st_future;    /* module's future features */
 };
 
 typedef struct _symtable_entry {
-	PyObject_HEAD
-	PyObject *ste_id;        /* int: key in ste_table->st_blocks */
-	PyObject *ste_symbols;   /* dict: variable names to flags */
-	PyObject *ste_name;      /* string: name of current block */
-	PyObject *ste_varnames;  /* list of variable names */
-	PyObject *ste_children;  /* list of child blocks */
-	_Py_block_ty ste_type;   /* module, class, or function */
-	int ste_unoptimized;     /* false if namespace is optimized */
-	int ste_nested;      /* true if block is nested */
-	unsigned ste_free : 1;        /* true if block has free variables */
-	unsigned ste_child_free : 1;  /* true if a child block has free vars,
-				         including free refs to globals */
-	unsigned ste_generator : 1;   /* true if namespace is a generator */
-	unsigned ste_varargs : 1;     /* true if block has varargs */
-	unsigned ste_varkeywords : 1; /* true if block has varkeywords */
-	unsigned ste_returns_value : 1;  /* true if namespace uses return with
-	                                    an argument */
-	int ste_lineno;          /* first line of block */
-	int ste_opt_lineno;      /* lineno of last exec or import * */
-	int ste_tmpname;         /* counter for listcomp temp vars */
-	struct symtable *ste_table;
+    PyObject_HEAD
+    PyObject *ste_id;        /* int: key in ste_table->st_blocks */
+    PyObject *ste_symbols;   /* dict: variable names to flags */
+    PyObject *ste_name;      /* string: name of current block */
+    PyObject *ste_varnames;  /* list of variable names */
+    PyObject *ste_children;  /* list of child blocks */
+    _Py_block_ty ste_type;   /* module, class, or function */
+    int ste_unoptimized;     /* false if namespace is optimized */
+    int ste_nested;      /* true if block is nested */
+    unsigned ste_free : 1;        /* true if block has free variables */
+    unsigned ste_child_free : 1;  /* true if a child block has free vars,
+                                     including free refs to globals */
+    unsigned ste_generator : 1;   /* true if namespace is a generator */
+    unsigned ste_varargs : 1;     /* true if block has varargs */
+    unsigned ste_varkeywords : 1; /* true if block has varkeywords */
+    unsigned ste_returns_value : 1;  /* true if namespace uses return with
+                                        an argument */
+    int ste_lineno;          /* first line of block */
+    int ste_opt_lineno;      /* lineno of last exec or import * */
+    int ste_tmpname;         /* counter for listcomp temp vars */
+    struct symtable *ste_table;
 } PySTEntryObject;
 
 PyAPI_DATA(PyTypeObject) PySTEntry_Type;
@@ -57,8 +57,8 @@ PyAPI_DATA(PyTypeObject) PySTEntry_Type;
 
 PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *);
 
-PyAPI_FUNC(struct symtable *) PySymtable_Build(mod_ty, const char *, 
-					      PyFutureFeatures *);
+PyAPI_FUNC(struct symtable *) PySymtable_Build(mod_ty, const char *,
+                                              PyFutureFeatures *);
 PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *);
 
 PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
@@ -81,7 +81,7 @@ PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
 #define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT)
 
 /* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol
-   table.  GLOBAL is returned from PyST_GetScope() for either of them. 
+   table.  GLOBAL is returned from PyST_GetScope() for either of them.
    It is stored in ste_symbols at bits 12-15.
 */
 #define SCOPE_OFFSET 11

Misc/setuid-prog.c

@@ -21,28 +21,28 @@
 
    Assuming the script is a Bourne shell script, the first line of the
    script should be
-	#!/bin/sh -
+    #!/bin/sh -
    The - is important, don't omit it.  If you're using esh, the first
    line should be
-	#!/usr/local/bin/esh -f
+    #!/usr/local/bin/esh -f
    and for ksh, the first line should be
-	#!/usr/local/bin/ksh -p
+    #!/usr/local/bin/ksh -p
    The script should then set the variable IFS to the string
    consisting of <space>, <tab>, and <newline>.  After this (*not*
    before!), the PATH variable should be set to a reasonable value and
    exported.  Do not expect the PATH to have a reasonable value, so do
    not trust the old value of PATH.  You should then set the umask of
    the program by calling
-	umask 077 # or 022 if you want the files to be readable
+    umask 077 # or 022 if you want the files to be readable
    If you plan to change directories, you should either unset CDPATH
    or set it to a good value.  Setting CDPATH to just ``.'' (dot) is a
    good idea.
    If, for some reason, you want to use csh, the first line should be
-	#!/bin/csh -fb
+    #!/bin/csh -fb
    You should then set the path variable to something reasonable,
    without trusting the inherited path.  Here too, you should set the
    umask using the command
-	umask 077 # or 022 if you want the files to be readable
+    umask 077 # or 022 if you want the files to be readable
 */
 
 #include <unistd.h>
@@ -54,14 +54,14 @@
 
 /* CONFIGURATION SECTION */
 
-#ifndef FULL_PATH	/* so that this can be specified from the Makefile */
+#ifndef FULL_PATH       /* so that this can be specified from the Makefile */
 /* Uncomment the following line:
-#define FULL_PATH	"/full/path/of/script" 
+#define FULL_PATH       "/full/path/of/script"
 * Then comment out the #error line. */
 #error "You must define FULL_PATH somewhere"
 #endif
 #ifndef UMASK
-#define UMASK		077
+#define UMASK           077
 #endif
 
 /* END OF CONFIGURATION SECTION */
@@ -101,76 +101,76 @@ char def_ENV[] = "ENV=:";
 void
 clean_environ(void)
 {
-	char **p;
-	extern char **environ;
-
-	for (p = environ; *p; p++) {
-		if (strncmp(*p, "LD_", 3) == 0)
-			**p = 'X';
-		else if (strncmp(*p, "_RLD", 4) == 0)
-			**p = 'X';
-		else if (strncmp(*p, "PYTHON", 6) == 0)
-			**p = 'X';
-		else if (strncmp(*p, "IFS=", 4) == 0)
-			*p = def_IFS;
-		else if (strncmp(*p, "CDPATH=", 7) == 0)
-			*p = def_CDPATH;
-		else if (strncmp(*p, "ENV=", 4) == 0)
-			*p = def_ENV;
-	}
-	putenv(def_PATH);
+    char **p;
+    extern char **environ;
+
+    for (p = environ; *p; p++) {
+        if (strncmp(*p, "LD_", 3) == 0)
+            **p = 'X';
+        else if (strncmp(*p, "_RLD", 4) == 0)
+            **p = 'X';
+        else if (strncmp(*p, "PYTHON", 6) == 0)
+            **p = 'X';
+        else if (strncmp(*p, "IFS=", 4) == 0)
+            *p = def_IFS;
+        else if (strncmp(*p, "CDPATH=", 7) == 0)
+            *p = def_CDPATH;
+        else if (strncmp(*p, "ENV=", 4) == 0)
+            *p = def_ENV;
+    }
+    putenv(def_PATH);
 }
 
 int
 main(int argc, char **argv)
 {
-	struct stat statb;
-	gid_t egid = getegid();
-	uid_t euid = geteuid();
-
-	/*
-	   Sanity check #1.
-	   This check should be made compile-time, but that's not possible.
-	   If you're sure that you specified a full path name for FULL_PATH,
-	   you can omit this check.
-	*/
-	if (FULL_PATH[0] != '/') {
-		fprintf(stderr, "%s: %s is not a full path name\n", argv[0],
-			FULL_PATH);
-		fprintf(stderr, "You can only use this wrapper if you\n");
-		fprintf(stderr, "compile it with an absolute path.\n");
-		exit(1);
-	}
-
-	/*
-	   Sanity check #2.
-	   Check that the owner of the script is equal to either the
-	   effective uid or the super user.
-	*/
-	if (stat(FULL_PATH, &statb) < 0) {
-		perror("stat");
-		exit(1);
-	}
-	if (statb.st_uid != 0 && statb.st_uid != euid) {
-		fprintf(stderr, "%s: %s has the wrong owner\n", argv[0],
-			FULL_PATH);
-		fprintf(stderr, "The script should be owned by root,\n");
-		fprintf(stderr, "and shouldn't be writable by anyone.\n");
-		exit(1);
-	}
-
-	if (setregid(egid, egid) < 0)
-		perror("setregid");
-	if (setreuid(euid, euid) < 0)
-		perror("setreuid");
-
-	clean_environ();
-
-	umask(UMASK);
-
-	while (**argv == '-')	/* don't let argv[0] start with '-' */
-		(*argv)++;
-	execv(FULL_PATH, argv);
-	fprintf(stderr, "%s: could not execute the script\n", argv[0]);
-	exit(1);
+    struct stat statb;
+    gid_t egid = getegid();
+    uid_t euid = geteuid();
+
+    /*
+       Sanity check #1.
+       This check should be made compile-time, but that's not possible.
+       If you're sure that you specified a full path name for FULL_PATH,
+       you can omit this check.
+    */
+    if (FULL_PATH[0] != '/') {
+        fprintf(stderr, "%s: %s is not a full path name\n", argv[0],
+            FULL_PATH);
+        fprintf(stderr, "You can only use this wrapper if you\n");
+        fprintf(stderr, "compile it with an absolute path.\n");
+        exit(1);
+    }
+
+    /*
+       Sanity check #2.
+       Check that the owner of the script is equal to either the
+       effective uid or the super user.
+    */
+    if (stat(FULL_PATH, &statb) < 0) {
+        perror("stat");
+        exit(1);
+    }
+    if (statb.st_uid != 0 && statb.st_uid != euid) {
+        fprintf(stderr, "%s: %s has the wrong owner\n", argv[0],
+            FULL_PATH);
+        fprintf(stderr, "The script should be owned by root,\n");
+        fprintf(stderr, "and shouldn't be writable by anyone.\n");
+        exit(1);
+    }
+
+    if (setregid(egid, egid) < 0)
+        perror("setregid");
+    if (setreuid(euid, euid) < 0)
+        perror("setreuid");
+
+    clean_environ();
+
+    umask(UMASK);
+
+    while (**argv == '-')       /* don't let argv[0] start with '-' */
+        (*argv)++;
+    execv(FULL_PATH, argv);
+    fprintf(stderr, "%s: could not execute the script\n", argv[0]);
+    exit(1);
 }

Modules/_ctypes/malloc_closure.c

@@ -23,8 +23,8 @@
 /******************************************************************/
 
 typedef union _tagITEM {
-	ffi_closure closure;
-	union _tagITEM *next;
+    ffi_closure closure;
+    union _tagITEM *next;
 } ITEM;
 
 static ITEM *free_list;
@@ -32,58 +32,58 @@ static int _pagesize;
 
 static void more_core(void)
 {
-	ITEM *item;
-	int count, i;
+    ITEM *item;
+    int count, i;
 
 /* determine the pagesize */
 #ifdef MS_WIN32
-	if (!_pagesize) {
-		SYSTEM_INFO systeminfo;
-		GetSystemInfo(&systeminfo);
-		_pagesize = systeminfo.dwPageSize;
-	}
+    if (!_pagesize) {
+        SYSTEM_INFO systeminfo;
+        GetSystemInfo(&systeminfo);
+        _pagesize = systeminfo.dwPageSize;
+    }
 #else
-	if (!_pagesize) {
+    if (!_pagesize) {
 #ifdef _SC_PAGESIZE
-		_pagesize = sysconf(_SC_PAGESIZE);
+        _pagesize = sysconf(_SC_PAGESIZE);
 #else
-		_pagesize = getpagesize();
+        _pagesize = getpagesize();
 #endif
-	}
+    }
 #endif
 
-	/* calculate the number of nodes to allocate */
-	count = BLOCKSIZE / sizeof(ITEM);
+    /* calculate the number of nodes to allocate */
+    count = BLOCKSIZE / sizeof(ITEM);
 
-	/* allocate a memory block */
+    /* allocate a memory block */
 #ifdef MS_WIN32
-	item = (ITEM *)VirtualAlloc(NULL,
-					       count * sizeof(ITEM),
-					       MEM_COMMIT,
-					       PAGE_EXECUTE_READWRITE);
-	if (item == NULL)
-		return;
+    item = (ITEM *)VirtualAlloc(NULL,
+                                           count * sizeof(ITEM),
+                                           MEM_COMMIT,
+                                           PAGE_EXECUTE_READWRITE);
+    if (item == NULL)
+        return;
 #else
-	item = (ITEM *)mmap(NULL,
-			    count * sizeof(ITEM),
-			    PROT_READ | PROT_WRITE | PROT_EXEC,
-			    MAP_PRIVATE | MAP_ANONYMOUS,
-			    -1,
-			    0);
-	if (item == (void *)MAP_FAILED)
-		return;
+    item = (ITEM *)mmap(NULL,
+                        count * sizeof(ITEM),
+                        PROT_READ | PROT_WRITE | PROT_EXEC,
+                        MAP_PRIVATE | MAP_ANONYMOUS,
+                        -1,
+                        0);
+    if (item == (void *)MAP_FAILED)
+        return;
 #endif
 
 #ifdef MALLOC_CLOSURE_DEBUG
-	printf("block at %p allocated (%d bytes), %d ITEMs\n",
-	       item, count * sizeof(ITEM), count);
+    printf("block at %p allocated (%d bytes), %d ITEMs\n",
+           item, count * sizeof(ITEM), count);
 #endif
-	/* put them into the free list */
-	for (i = 0; i < count; ++i) {
-		item->next = free_list;
-		free_list = item;
-		++item;
-	}
+    /* put them into the free list */
+    for (i = 0; i < count; ++i) {
+        item->next = free_list;
+        free_list = item;
+        ++item;
+    }
 }
 
 /******************************************************************/
@@ -91,20 +91,20 @@ static void more_core(void)
 /* put the item back into the free list */
 void _ctypes_free_closure(void *p)
 {
-	ITEM *item = (ITEM *)p;
-	item->next = free_list;
-	free_list = item;
+    ITEM *item = (ITEM *)p;
+    item->next = free_list;
+    free_list = item;
 }
 
 /* return one item from the free list, allocating more if needed */
 void *_ctypes_alloc_closure(void)
 {
-	ITEM *item;
-	if (!free_list)
-		more_core();
-	if (!free_list)
-		return NULL;
-	item = free_list;
-	free_list = item->next;
-	return item;
+    ITEM *item;
+    if (!free_list)
+        more_core();
+    if (!free_list)
+        return NULL;
+    item = free_list;
+    free_list = item->next;
+    return item;
 }

Modules/_gdbmmodule.c

@@ -30,7 +30,7 @@ supported.");
 
 typedef struct {
     PyObject_HEAD
-    int di_size;	/* -1 means recompute */
+    int di_size;        /* -1 means recompute */
     GDBM_FILE di_dbm;
 } dbmobject;
 
@@ -177,7 +177,7 @@ dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
 }
 
 static PyMappingMethods dbm_as_mapping = {
-    (lenfunc)dbm_length,		/*mp_length*/
+    (lenfunc)dbm_length,                /*mp_length*/
     (binaryfunc)dbm_subscript,          /*mp_subscript*/
     (objobjargproc)dbm_ass_sub,         /*mp_ass_subscript*/
 };
@@ -247,15 +247,15 @@ dbm_contains(PyObject *self, PyObject *arg)
     datum key;
 
     if ((dp)->di_dbm == NULL) {
-	PyErr_SetString(DbmError,
-			"GDBM object has already been closed");
-	return -1;
+        PyErr_SetString(DbmError,
+                        "GDBM object has already been closed");
+        return -1;
     }
     if (!PyBytes_Check(arg)) {
-	PyErr_Format(PyExc_TypeError,
-		     "gdbm key must be bytes, not %.100s",
-		     arg->ob_type->tp_name);
-	return -1;
+        PyErr_Format(PyExc_TypeError,
+                     "gdbm key must be bytes, not %.100s",
+                     arg->ob_type->tp_name);
+        return -1;
     }
     key.dptr = PyBytes_AS_STRING(arg);
     key.dsize = PyBytes_GET_SIZE(arg);
@@ -263,16 +263,16 @@ dbm_contains(PyObject *self, PyObject *arg)
 }
 
 static PySequenceMethods dbm_as_sequence = {
-	0,			/* sq_length */
-	0,			/* sq_concat */
-	0,			/* sq_repeat */
-	0,			/* sq_item */
-	0,			/* sq_slice */
-	0,			/* sq_ass_item */
-	0,			/* sq_ass_slice */
-	dbm_contains,		/* sq_contains */
-	0,			/* sq_inplace_concat */
-	0,			/* sq_inplace_repeat */
+        0,                      /* sq_length */
+        0,                      /* sq_concat */
+        0,                      /* sq_repeat */
+        0,                      /* sq_item */
+        0,                      /* sq_slice */
+        0,                      /* sq_ass_item */
+        0,                      /* sq_ass_slice */
+        dbm_contains,           /* sq_contains */
+        0,                      /* sq_inplace_concat */
+        0,                      /* sq_inplace_repeat */
 };
 
 PyDoc_STRVAR(dbm_firstkey__doc__,
@@ -372,13 +372,13 @@ dbm_sync(register dbmobject *dp, PyObject *unused)
 }
 
 static PyMethodDef dbm_methods[] = {
-    {"close",	  (PyCFunction)dbm_close,   METH_NOARGS, dbm_close__doc__},
-    {"keys",	  (PyCFunction)dbm_keys,    METH_NOARGS, dbm_keys__doc__},
+    {"close",     (PyCFunction)dbm_close,   METH_NOARGS, dbm_close__doc__},
+    {"keys",      (PyCFunction)dbm_keys,    METH_NOARGS, dbm_keys__doc__},
     {"firstkey",  (PyCFunction)dbm_firstkey,METH_NOARGS, dbm_firstkey__doc__},
-    {"nextkey",	  (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__},
+    {"nextkey",   (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__},
     {"reorganize",(PyCFunction)dbm_reorganize,METH_NOARGS, dbm_reorganize__doc__},
     {"sync",      (PyCFunction)dbm_sync,    METH_NOARGS, dbm_sync__doc__},
-    {NULL,		NULL}		/* sentinel */
+    {NULL,              NULL}           /* sentinel */
 };
 
 static PyTypeObject Dbmtype = {
@@ -486,7 +486,7 @@ dbmopen(PyObject *self, PyObject *args)
 #endif
             default:
                 PyOS_snprintf(buf, sizeof(buf), "Flag '%c' is not supported.",
-                	      *flags);
+                              *flags);
                 PyErr_SetString(DbmError, buf);
                 return NULL;
         }
@@ -514,15 +514,15 @@ static PyMethodDef dbmmodule_methods[] = {
 
 
 static struct PyModuleDef _gdbmmodule = {
-	PyModuleDef_HEAD_INIT,
-	"_gdbm",
-	gdbmmodule__doc__,
-	-1,
-	dbmmodule_methods,
-	NULL,
-	NULL,
-	NULL,
-	NULL
+        PyModuleDef_HEAD_INIT,
+        "_gdbm",
+        gdbmmodule__doc__,
+        -1,
+        dbmmodule_methods,
+        NULL,
+        NULL,
+        NULL,
+        NULL
 };
 
 PyMODINIT_FUNC
@@ -530,10 +530,10 @@ PyInit__gdbm(void) {
     PyObject *m, *d, *s;
 
     if (PyType_Ready(&Dbmtype) < 0)
-	    return NULL;
+            return NULL;
     m = PyModule_Create(&_gdbmmodule);
     if (m == NULL)
-	return NULL;
+        return NULL;
     d = PyModule_GetDict(m);
     DbmError = PyErr_NewException("_gdbm.error", PyExc_IOError, NULL);
     if (DbmError != NULL) {

Modules/_multiprocessing/multiprocessing.h

@@ -15,7 +15,7 @@
 #  define WIN32_LEAN_AND_MEAN
 #  include <windows.h>
 #  include <winsock2.h>
-#  include <process.h>		     /* getpid() */
+#  include <process.h>               /* getpid() */
 #  ifdef Py_DEBUG
 #    include <crtdbg.h>
 #  endif
@@ -45,15 +45,15 @@
  * Issue 3110 - Solaris does not define SEM_VALUE_MAX
  */
 #ifndef SEM_VALUE_MAX
-	#if defined(HAVE_SYSCONF) && defined(_SC_SEM_VALUE_MAX)
-		# define SEM_VALUE_MAX sysconf(_SC_SEM_VALUE_MAX)
-	#elif defined(_SEM_VALUE_MAX)
-		# define SEM_VALUE_MAX _SEM_VALUE_MAX
-	#elif defined(_POSIX_SEM_VALUE_MAX)
-		# define SEM_VALUE_MAX _POSIX_SEM_VALUE_MAX
-	#else
-		# define SEM_VALUE_MAX INT_MAX
-	#endif
+    #if defined(HAVE_SYSCONF) && defined(_SC_SEM_VALUE_MAX)
+        # define SEM_VALUE_MAX sysconf(_SC_SEM_VALUE_MAX)
+    #elif defined(_SEM_VALUE_MAX)
+        # define SEM_VALUE_MAX _SEM_VALUE_MAX
+    #elif defined(_POSIX_SEM_VALUE_MAX)
+        # define SEM_VALUE_MAX _POSIX_SEM_VALUE_MAX
+    #else
+        # define SEM_VALUE_MAX INT_MAX
+    #endif
 #endif
 
 
@@ -162,11 +162,11 @@ extern HANDLE sigint_event;
 #define CONNECTION_BUFFER_SIZE 1024
 
 typedef struct {
-	PyObject_HEAD
-	HANDLE handle;
-	int flags;
-	PyObject *weakreflist;
-	char buffer[CONNECTION_BUFFER_SIZE];
+    PyObject_HEAD
+    HANDLE handle;
+    int flags;
+    PyObject *weakreflist;
+    char buffer[CONNECTION_BUFFER_SIZE];
 } ConnectionObject;
 
 /*