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, 47 insertions, 47 deletions

diff --git a/Python/thread_cthread.h b/Python/thread_cthread.h
index 7163412..1b3e390 100644
--- a/Python/thread_cthread.h
+++ b/Python/thread_cthread.h
@@ -14,12 +14,12 @@ static void
 PyThread__init_thread(void)
 {
 #ifndef HURD_C_THREADS
-	/* Roland McGrath said this should not be used since this is
-	done while linking to threads */
-	cthread_init(); 
+    /* Roland McGrath said this should not be used since this is
+    done while linking to threads */
+    cthread_init();
 #else
 /* do nothing */
-	;
+    ;
 #endif
 }
 
@@ -29,34 +29,34 @@ PyThread__init_thread(void)
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	int success = 0;	/* init not needed when SOLARIS_THREADS and */
-				/* C_THREADS implemented properly */
+    int success = 0;            /* init not needed when SOLARIS_THREADS and */
+                /* C_THREADS implemented properly */
 
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-	/* looks like solaris detaches the thread to never rejoin
-	 * so well do it here
-	 */
-	cthread_detach(cthread_fork((cthread_fn_t) func, arg));
-	return success < 0 ? -1 : 0;
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+    /* looks like solaris detaches the thread to never rejoin
+     * so well do it here
+     */
+    cthread_detach(cthread_fork((cthread_fn_t) func, arg));
+    return success < 0 ? -1 : 0;
 }
 
 long
 PyThread_get_thread_ident(void)
 {
-	if (!initialized)
-		PyThread_init_thread();
-	return (long) cthread_self();
+    if (!initialized)
+        PyThread_init_thread();
+    return (long) cthread_self();
 }
 
 void
 PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized)
-		exit(0);
-	cthread_exit(0);
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized)
+        exit(0);
+    cthread_exit(0);
 }
 
 /*
@@ -65,48 +65,48 @@ PyThread_exit_thread(void)
 PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-	mutex_t lock;
+    mutex_t lock;
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	lock = mutex_alloc();
-	if (mutex_init(lock)) {
-		perror("mutex_init");
-		free((void *) lock);
-		lock = 0;
-	}
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    lock = mutex_alloc();
+    if (mutex_init(lock)) {
+        perror("mutex_init");
+        free((void *) lock);
+        lock = 0;
+    }
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void
 PyThread_free_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
-	mutex_free(lock);
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+    mutex_free(lock);
 }
 
 int
 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success = FALSE;
+    int success = FALSE;
 
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-	if (waitflag) { 	/* blocking */
-		mutex_lock((mutex_t)lock);
-		success = TRUE;
-	} else {		/* non blocking */
-		success = mutex_try_lock((mutex_t)lock);
-	}
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+    if (waitflag) {             /* blocking */
+        mutex_lock((mutex_t)lock);
+        success = TRUE;
+    } else {                    /* non blocking */
+        success = mutex_try_lock((mutex_t)lock);
+    }
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void
 PyThread_release_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
-	mutex_unlock((mutex_t )lock);
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+    mutex_unlock((mutex_t )lock);
 }