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.
........

1 files changed, 178 insertions, 178 deletions

diff --git a/Python/thread_nt.h b/Python/thread_nt.h
index e2e4443..2fd7098 100644
--- a/Python/thread_nt.h
+++ b/Python/thread_nt.h
@@ -10,81 +10,81 @@
 #endif
 
 typedef struct NRMUTEX {
-	LONG   owned ;
-	DWORD  thread_id ;
-	HANDLE hevent ;
+    LONG   owned ;
+    DWORD  thread_id ;
+    HANDLE hevent ;
 } NRMUTEX, *PNRMUTEX ;
 
 
 BOOL
 InitializeNonRecursiveMutex(PNRMUTEX mutex)
 {
-	mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */
-	mutex->thread_id = 0 ;
-	mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
-	return mutex->hevent != NULL ;	/* TRUE if the mutex is created */
+    mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */
+    mutex->thread_id = 0 ;
+    mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
+    return mutex->hevent != NULL ;      /* TRUE if the mutex is created */
 }
 
 VOID
 DeleteNonRecursiveMutex(PNRMUTEX mutex)
 {
-	/* No in-use check */
-	CloseHandle(mutex->hevent) ;
-	mutex->hevent = NULL ; /* Just in case */
+    /* No in-use check */
+    CloseHandle(mutex->hevent) ;
+    mutex->hevent = NULL ; /* Just in case */
 }
 
 DWORD
 EnterNonRecursiveMutex(PNRMUTEX mutex, DWORD milliseconds)
 {
-	/* Assume that the thread waits successfully */
-	DWORD ret ;
-
-	/* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
-	if (milliseconds == 0)
-	{
-		if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)
-			return WAIT_TIMEOUT ;
-		ret = WAIT_OBJECT_0 ;
-	}
-	else
-		ret = InterlockedIncrement(&mutex->owned) ?
-			/* Some thread owns the mutex, let's wait... */
-			WaitForSingleObject(mutex->hevent, milliseconds) : WAIT_OBJECT_0 ;
-
-	mutex->thread_id = GetCurrentThreadId() ; /* We own it */
-	return ret ;
+    /* Assume that the thread waits successfully */
+    DWORD ret ;
+
+    /* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
+    if (milliseconds == 0)
+    {
+        if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)
+            return WAIT_TIMEOUT ;
+        ret = WAIT_OBJECT_0 ;
+    }
+    else
+        ret = InterlockedIncrement(&mutex->owned) ?
+            /* Some thread owns the mutex, let's wait... */
+            WaitForSingleObject(mutex->hevent, milliseconds) : WAIT_OBJECT_0 ;
+
+    mutex->thread_id = GetCurrentThreadId() ; /* We own it */
+    return ret ;
 }
 
 BOOL
 LeaveNonRecursiveMutex(PNRMUTEX mutex)
 {
-	/* We don't own the mutex */
-	mutex->thread_id = 0 ;
-	return
-		InterlockedDecrement(&mutex->owned) < 0 ||
-		SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
+    /* We don't own the mutex */
+    mutex->thread_id = 0 ;
+    return
+        InterlockedDecrement(&mutex->owned) < 0 ||
+        SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
 }
 
 PNRMUTEX
 AllocNonRecursiveMutex(void)
 {
-	PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
-	if (mutex && !InitializeNonRecursiveMutex(mutex))
-	{
-		free(mutex) ;
-		mutex = NULL ;
-	}
-	return mutex ;
+    PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
+    if (mutex && !InitializeNonRecursiveMutex(mutex))
+    {
+        free(mutex) ;
+        mutex = NULL ;
+    }
+    return mutex ;
 }
 
 void
 FreeNonRecursiveMutex(PNRMUTEX mutex)
 {
-	if (mutex)
-	{
-		DeleteNonRecursiveMutex(mutex) ;
-		free(mutex) ;
-	}
+    if (mutex)
+    {
+        DeleteNonRecursiveMutex(mutex) ;
+        free(mutex) ;
+    }
 }
 
 long PyThread_get_thread_ident(void);
@@ -102,8 +102,8 @@ PyThread__init_thread(void)
  */
 
 typedef struct {
-	void (*func)(void*);
-	void *arg;
+    void (*func)(void*);
+    void *arg;
 } callobj;
 
 /* thunker to call adapt between the function type used by the system's
@@ -115,66 +115,66 @@ static unsigned __stdcall
 #endif
 bootstrap(void *call)
 {
-	callobj *obj = (callobj*)call;
-	void (*func)(void*) = obj->func;
-	void *arg = obj->arg;
-	HeapFree(GetProcessHeap(), 0, obj);
-	func(arg);
-	return 0;
+    callobj *obj = (callobj*)call;
+    void (*func)(void*) = obj->func;
+    void *arg = obj->arg;
+    HeapFree(GetProcessHeap(), 0, obj);
+    func(arg);
+    return 0;
 }
 
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	HANDLE hThread;
-	unsigned threadID;
-	callobj *obj;
-	
-	dprintf(("%ld: PyThread_start_new_thread called\n",
-		 PyThread_get_thread_ident()));
-	if (!initialized)
-		PyThread_init_thread();
-
-	obj = (callobj*)HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
-	if (!obj)
-		return -1;
-	obj->func = func;
-	obj->arg = arg;
+    HANDLE hThread;
+    unsigned threadID;
+    callobj *obj;
+
+    dprintf(("%ld: PyThread_start_new_thread called\n",
+             PyThread_get_thread_ident()));
+    if (!initialized)
+        PyThread_init_thread();
+
+    obj = (callobj*)HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
+    if (!obj)
+        return -1;
+    obj->func = func;
+    obj->arg = arg;
 #if defined(MS_WINCE)
-	hThread = CreateThread(NULL,
-	                       Py_SAFE_DOWNCAST(_pythread_stacksize, Py_ssize_t, SIZE_T),
-	                       bootstrap, obj, 0, &threadID);
+    hThread = CreateThread(NULL,
+                           Py_SAFE_DOWNCAST(_pythread_stacksize, Py_ssize_t, SIZE_T),
+                           bootstrap, obj, 0, &threadID);
 #else
-	hThread = (HANDLE)_beginthreadex(0,
-			  Py_SAFE_DOWNCAST(_pythread_stacksize,
-					   Py_ssize_t, unsigned int),
-			  bootstrap, obj,
-			  0, &threadID);
+    hThread = (HANDLE)_beginthreadex(0,
+                      Py_SAFE_DOWNCAST(_pythread_stacksize,
+                                       Py_ssize_t, unsigned int),
+                      bootstrap, obj,
+                      0, &threadID);
 #endif
-	if (hThread == 0) {
+    if (hThread == 0) {
 #if defined(MS_WINCE)
-		/* Save error in variable, to prevent PyThread_get_thread_ident
-		   from clobbering it. */
-		unsigned e = GetLastError();
-		dprintf(("%ld: PyThread_start_new_thread failed, win32 error code %u\n",
-		         PyThread_get_thread_ident(), e));
+        /* Save error in variable, to prevent PyThread_get_thread_ident
+           from clobbering it. */
+        unsigned e = GetLastError();
+        dprintf(("%ld: PyThread_start_new_thread failed, win32 error code %u\n",
+                 PyThread_get_thread_ident(), e));
 #else
-		/* I've seen errno == EAGAIN here, which means "there are
-		 * too many threads".
-		 */
-		int e = errno;
-		dprintf(("%ld: PyThread_start_new_thread failed, errno %d\n",
-		         PyThread_get_thread_ident(), e));
+        /* I've seen errno == EAGAIN here, which means "there are
+         * too many threads".
+         */
+        int e = errno;
+        dprintf(("%ld: PyThread_start_new_thread failed, errno %d\n",
+                 PyThread_get_thread_ident(), e));
 #endif
-		threadID = (unsigned)-1;
-		HeapFree(GetProcessHeap(), 0, obj);
-	}
-	else {
-		dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
-		         PyThread_get_thread_ident(), (void*)hThread));
-		CloseHandle(hThread);
-	}
-	return (long) threadID;
+        threadID = (unsigned)-1;
+        HeapFree(GetProcessHeap(), 0, obj);
+    }
+    else {
+        dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
+                 PyThread_get_thread_ident(), (void*)hThread));
+        CloseHandle(hThread);
+    }
+    return (long) threadID;
 }
 
 /*
@@ -184,22 +184,22 @@ PyThread_start_new_thread(void (*func)(void *), void *arg)
 long
 PyThread_get_thread_ident(void)
 {
-	if (!initialized)
-		PyThread_init_thread();
+    if (!initialized)
+        PyThread_init_thread();
 
-	return GetCurrentThreadId();
+    return GetCurrentThreadId();
 }
 
 void
 PyThread_exit_thread(void)
 {
-	dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
-	if (!initialized)
-		exit(0);
+    dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
+    if (!initialized)
+        exit(0);
 #if defined(MS_WINCE)
-	ExitThread(0);
+    ExitThread(0);
 #else
-	_endthreadex(0);
+    _endthreadex(0);
 #endif
 }
 
@@ -211,25 +211,25 @@ PyThread_exit_thread(void)
 PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-	PNRMUTEX aLock;
+    PNRMUTEX aLock;
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	aLock = AllocNonRecursiveMutex() ;
+    aLock = AllocNonRecursiveMutex() ;
 
-	dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
+    dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
 
-	return (PyThread_type_lock) aLock;
+    return (PyThread_type_lock) aLock;
 }
 
 void
 PyThread_free_lock(PyThread_type_lock aLock)
 {
-	dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+    dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
-	FreeNonRecursiveMutex(aLock) ;
+    FreeNonRecursiveMutex(aLock) ;
 }
 
 /*
@@ -241,48 +241,48 @@ PyThread_free_lock(PyThread_type_lock aLock)
 int
 PyThread_acquire_lock_timed(PyThread_type_lock aLock, PY_TIMEOUT_T microseconds)
 {
-	int success ;
-	PY_TIMEOUT_T milliseconds;
+    int success ;
+    PY_TIMEOUT_T milliseconds;
 
-	if (microseconds >= 0) {
-		milliseconds = microseconds / 1000;
-		if (microseconds % 1000 > 0)
-			++milliseconds;
-		if ((DWORD) milliseconds != milliseconds)
-			Py_FatalError("Timeout too large for a DWORD, "
-				       "please check PY_TIMEOUT_MAX");
-	}
-	else
-		milliseconds = INFINITE;
+    if (microseconds >= 0) {
+        milliseconds = microseconds / 1000;
+        if (microseconds % 1000 > 0)
+            ++milliseconds;
+        if ((DWORD) milliseconds != milliseconds)
+            Py_FatalError("Timeout too large for a DWORD, "
+                           "please check PY_TIMEOUT_MAX");
+    }
+    else
+        milliseconds = INFINITE;
 
-	dprintf(("%ld: PyThread_acquire_lock_timed(%p, %lld) called\n",
-		 PyThread_get_thread_ident(), aLock, microseconds));
+    dprintf(("%ld: PyThread_acquire_lock_timed(%p, %lld) called\n",
+             PyThread_get_thread_ident(), aLock, microseconds));
 
-	success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (DWORD) milliseconds) == WAIT_OBJECT_0 ;
+    success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (DWORD) milliseconds) == WAIT_OBJECT_0 ;
 
-	dprintf(("%ld: PyThread_acquire_lock(%p, %lld) -> %d\n",
-		 PyThread_get_thread_ident(), aLock, microseconds, success));
+    dprintf(("%ld: PyThread_acquire_lock(%p, %lld) -> %d\n",
+             PyThread_get_thread_ident(), aLock, microseconds, success));
 
-	return success;
+    return success;
 }
 int
 PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 {
-	return PyThread_acquire_lock_timed(aLock, waitflag ? -1 : 0);
+    return PyThread_acquire_lock_timed(aLock, waitflag ? -1 : 0);
 }
 
 void
 PyThread_release_lock(PyThread_type_lock aLock)
 {
-	dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+    dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
-	if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
-		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
+    if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
+        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 }
 
 /* minimum/maximum thread stack sizes supported */
-#define THREAD_MIN_STACKSIZE	0x8000		/* 32kB */
-#define THREAD_MAX_STACKSIZE	0x10000000	/* 256MB */
+#define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
+#define THREAD_MAX_STACKSIZE    0x10000000      /* 256MB */
 
 /* set the thread stack size.
  * Return 0 if size is valid, -1 otherwise.
@@ -290,22 +290,22 @@ PyThread_release_lock(PyThread_type_lock aLock)
 static int
 _pythread_nt_set_stacksize(size_t size)
 {
-	/* set to default */
-	if (size == 0) {
-		_pythread_stacksize = 0;
-		return 0;
-	}
-
-	/* valid range? */
-	if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
-		_pythread_stacksize = size;
-		return 0;
-	}
-
-	return -1;
+    /* set to default */
+    if (size == 0) {
+        _pythread_stacksize = 0;
+        return 0;
+    }
+
+    /* valid range? */
+    if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
+        _pythread_stacksize = size;
+        return 0;
+    }
+
+    return -1;
 }
 
-#define THREAD_SET_STACKSIZE(x)	_pythread_nt_set_stacksize(x)
+#define THREAD_SET_STACKSIZE(x) _pythread_nt_set_stacksize(x)
 
 
 /* use native Windows TLS functions */
@@ -315,13 +315,13 @@ _pythread_nt_set_stacksize(size_t size)
 int
 PyThread_create_key(void)
 {
-	return (int) TlsAlloc();
+    return (int) TlsAlloc();
 }
 
 void
 PyThread_delete_key(int key)
 {
-	TlsFree(key);
+    TlsFree(key);
 }
 
 /* We must be careful to emulate the strange semantics implemented in thread.c,
@@ -330,42 +330,42 @@ PyThread_delete_key(int key)
 int
 PyThread_set_key_value(int key, void *value)
 {
-	BOOL ok;
-	void *oldvalue;
-
-	assert(value != NULL);
-	oldvalue = TlsGetValue(key);
-	if (oldvalue != NULL)
-		/* ignore value if already set */
-		return 0;
-	ok = TlsSetValue(key, value);
-	if (!ok)
-		return -1;
-	return 0;
+    BOOL ok;
+    void *oldvalue;
+
+    assert(value != NULL);
+    oldvalue = TlsGetValue(key);
+    if (oldvalue != NULL)
+        /* ignore value if already set */
+        return 0;
+    ok = TlsSetValue(key, value);
+    if (!ok)
+        return -1;
+    return 0;
 }
 
 void *
 PyThread_get_key_value(int key)
 {
-	/* because TLS is used in the Py_END_ALLOW_THREAD macro,
-	 * it is necessary to preserve the windows error state, because
-	 * it is assumed to be preserved across the call to the macro.
-	 * Ideally, the macro should be fixed, but it is simpler to
-	 * do it here.
-	 */
-	DWORD error = GetLastError();
-	void *result = TlsGetValue(key);
-	SetLastError(error);
-	return result;
+    /* because TLS is used in the Py_END_ALLOW_THREAD macro,
+     * it is necessary to preserve the windows error state, because
+     * it is assumed to be preserved across the call to the macro.
+     * Ideally, the macro should be fixed, but it is simpler to
+     * do it here.
+     */
+    DWORD error = GetLastError();
+    void *result = TlsGetValue(key);
+    SetLastError(error);
+    return result;
 }
 
 void
 PyThread_delete_key_value(int key)
 {
-	/* NULL is used as "key missing", and it is also the default
-	 * given by TlsGetValue() if nothing has been set yet.
-	 */
-	TlsSetValue(key, NULL);
+    /* NULL is used as "key missing", and it is also the default
+     * given by TlsGetValue() if nothing has been set yet.
+     */
+    TlsSetValue(key, NULL);
 }
 
 /* reinitialization of TLS is not necessary after fork when using