Untabify C files. Will watch buildbots.

1 files changed, 155 insertions, 155 deletions

diff --git a/Python/thread_beos.h b/Python/thread_beos.h
index d12d562f9d..65dc470bcd 100644
--- a/Python/thread_beos.h
+++ b/Python/thread_beos.h
@@ -7,8 +7,8 @@
  * in the Be Developer's Newsletter, Issue #26 (http://www.be.com/).
  */
 typedef struct benaphore {
-	sem_id _sem;
-	int32  _atom;
+    sem_id _sem;
+    int32  _atom;
 } benaphore_t;
 
 static status_t benaphore_create( const char *name, benaphore_t *ben );
@@ -19,79 +19,79 @@ static status_t benaphore_unlock( benaphore_t *ben );
 
 static status_t benaphore_create( const char *name, benaphore_t *ben )
 {
-	if( ben != NULL ) {
-		ben->_atom = 0;
-		ben->_sem = create_sem( 0, name );
-		
-		if( ben->_sem < B_NO_ERROR ) {
-			return B_BAD_SEM_ID;
-		}
-	} else {
-		return EFAULT;
-	}
-	
-	return EOK;
+    if( ben != NULL ) {
+        ben->_atom = 0;
+        ben->_sem = create_sem( 0, name );
+
+        if( ben->_sem < B_NO_ERROR ) {
+            return B_BAD_SEM_ID;
+        }
+    } else {
+        return EFAULT;
+    }
+
+    return EOK;
 }
 
 static status_t benaphore_destroy( benaphore_t *ben )
 {
-	if( ben->_sem >= B_NO_ERROR ) {
-		status_t retval = benaphore_timedlock( ben, 0 );
-		
-		if( retval == EOK || retval == EWOULDBLOCK ) {
-			status_t del_retval = delete_sem( ben->_sem );
-			
-			return del_retval;
-		}
-	}
-
-	return B_BAD_SEM_ID;
+    if( ben->_sem >= B_NO_ERROR ) {
+        status_t retval = benaphore_timedlock( ben, 0 );
+
+        if( retval == EOK || retval == EWOULDBLOCK ) {
+            status_t del_retval = delete_sem( ben->_sem );
+
+            return del_retval;
+        }
+    }
+
+    return B_BAD_SEM_ID;
 }
 
 static status_t benaphore_lock( benaphore_t *ben )
 {
-	int32 prev = atomic_add( &(ben->_atom), 1 );
-	
-	if( prev > 0 ) {
-		return acquire_sem( ben->_sem );
-	}
-	
-	return EOK;
+    int32 prev = atomic_add( &(ben->_atom), 1 );
+
+    if( prev > 0 ) {
+        return acquire_sem( ben->_sem );
+    }
+
+    return EOK;
 }
 
 static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros )
 {
-	int32 prev = atomic_add( &(ben->_atom), 1 );
-	
-	if( prev > 0 ) {
-		status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );
-		
-		switch( retval ) {
-		case B_WOULD_BLOCK:	/* Fall through... */
-		case B_TIMED_OUT:
-			return EWOULDBLOCK;
-			break;
-		case B_OK:
-			return EOK;
-			break;
-		default:
-			return retval;
-			break;
-		}
-	}
-	
-	return EOK;
+    int32 prev = atomic_add( &(ben->_atom), 1 );
+
+    if( prev > 0 ) {
+        status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );
+
+        switch( retval ) {
+        case B_WOULD_BLOCK:             /* Fall through... */
+        case B_TIMED_OUT:
+            return EWOULDBLOCK;
+            break;
+        case B_OK:
+            return EOK;
+            break;
+        default:
+            return retval;
+            break;
+        }
+    }
+
+    return EOK;
 }
 
 static status_t benaphore_unlock( benaphore_t *ben )
 {
-	int32 prev = atomic_add( &(ben->_atom), -1 );
-	
-	if( prev > 1 ) {
-		return release_sem( ben->_sem );
-	}
-	
-	return EOK;
+    int32 prev = atomic_add( &(ben->_atom), -1 );
+
+    if( prev > 1 ) {
+        return release_sem( ben->_sem );
+    }
+
+    return EOK;
 }
 
 /* ----------------------------------------------------------------------
@@ -99,8 +99,8 @@ static status_t benaphore_unlock( benaphore_t *ben )
  */
 static void PyThread__init_thread( void )
 {
-	/* Do nothing. */
-	return;
+    /* Do nothing. */
+    return;
 }
 
 /* ----------------------------------------------------------------------
@@ -114,52 +114,52 @@ static int32 thread_count = 0;
 
 long PyThread_start_new_thread( void (*func)(void *), void *arg )
 {
-	status_t success = 0;
-	thread_id tid;
-	char name[B_OS_NAME_LENGTH];
-	int32 this_thread;
+    status_t success = 0;
+    thread_id tid;
+    char name[B_OS_NAME_LENGTH];
+    int32 this_thread;
 
-	dprintf(("PyThread_start_new_thread called\n"));
+    dprintf(("PyThread_start_new_thread called\n"));
 
-	/* We are so very thread-safe... */
-	this_thread = atomic_add( &thread_count, 1 );
-	PyOS_snprintf(name, sizeof(name),
-		      "python thread (%d)", this_thread );
+    /* We are so very thread-safe... */
+    this_thread = atomic_add( &thread_count, 1 );
+    PyOS_snprintf(name, sizeof(name),
+                  "python thread (%d)", this_thread );
 
-	tid = spawn_thread( (thread_func)func, name,
-	                    B_NORMAL_PRIORITY, arg );
-	if( tid > B_NO_ERROR ) {
-		success = resume_thread( tid );
-	}
+    tid = spawn_thread( (thread_func)func, name,
+                        B_NORMAL_PRIORITY, arg );
+    if( tid > B_NO_ERROR ) {
+        success = resume_thread( tid );
+    }
 
-	return ( success == B_NO_ERROR ? tid : -1 );
+    return ( success == B_NO_ERROR ? tid : -1 );
 }
 
 long PyThread_get_thread_ident( void )
 {
-	/* Presumed to return the current thread's ID... */
-	thread_id tid;
-	tid = find_thread( NULL );
-	
-	return ( tid != B_NAME_NOT_FOUND ? tid : -1 );
+    /* Presumed to return the current thread's ID... */
+    thread_id tid;
+    tid = find_thread( NULL );
+
+    return ( tid != B_NAME_NOT_FOUND ? tid : -1 );
 }
 
 void PyThread_exit_thread( void )
 {
-	int32 threads;
+    int32 threads;
 
-	dprintf(("PyThread_exit_thread called\n"));
+    dprintf(("PyThread_exit_thread called\n"));
 
-	/* Thread-safe way to read a variable without a mutex: */
-	threads = atomic_add( &thread_count, 0 );
+    /* Thread-safe way to read a variable without a mutex: */
+    threads = atomic_add( &thread_count, 0 );
 
-	if( threads == 0 ) {
-		/* No threads around, so exit main(). */
-		exit(0);
-	} else {
-		/* Oh, we're a thread, let's try to exit gracefully... */
-		exit_thread( B_NO_ERROR );
-	}
+    if( threads == 0 ) {
+        /* No threads around, so exit main(). */
+        exit(0);
+    } else {
+        /* Oh, we're a thread, let's try to exit gracefully... */
+        exit_thread( B_NO_ERROR );
+    }
 }
 
 /* ----------------------------------------------------------------------
@@ -170,79 +170,79 @@ static int32 lock_count = 0;
 
 PyThread_type_lock PyThread_allocate_lock( void )
 {
-	benaphore_t *lock;
-	status_t retval;
-	char name[B_OS_NAME_LENGTH];
-	int32 this_lock;
-	
-	dprintf(("PyThread_allocate_lock called\n"));
-
-	lock = (benaphore_t *)malloc( sizeof( benaphore_t ) );
-	if( lock == NULL ) {
-		/* TODO: that's bad, raise MemoryError */
-		return (PyThread_type_lock)NULL;
-	}
-
-	this_lock = atomic_add( &lock_count, 1 );
-	PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
-
-	retval = benaphore_create( name, lock );
-	if( retval != EOK ) {
-		/* TODO: that's bad, raise an exception */
-		return (PyThread_type_lock)NULL;
-	}
-
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    benaphore_t *lock;
+    status_t retval;
+    char name[B_OS_NAME_LENGTH];
+    int32 this_lock;
+
+    dprintf(("PyThread_allocate_lock called\n"));
+
+    lock = (benaphore_t *)malloc( sizeof( benaphore_t ) );
+    if( lock == NULL ) {
+        /* TODO: that's bad, raise MemoryError */
+        return (PyThread_type_lock)NULL;
+    }
+
+    this_lock = atomic_add( &lock_count, 1 );
+    PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
+
+    retval = benaphore_create( name, lock );
+    if( retval != EOK ) {
+        /* TODO: that's bad, raise an exception */
+        return (PyThread_type_lock)NULL;
+    }
+
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void PyThread_free_lock( PyThread_type_lock lock )
 {
-	status_t retval;
-
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
-	
-	retval = benaphore_destroy( (benaphore_t *)lock );
-	if( retval != EOK ) {
-		/* TODO: that's bad, raise an exception */
-		return;
-	}
+    status_t retval;
+
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+
+    retval = benaphore_destroy( (benaphore_t *)lock );
+    if( retval != EOK ) {
+        /* TODO: that's bad, raise an exception */
+        return;
+    }
 }
 
 int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )
 {
-	int success;
-	status_t retval;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-
-	if( waitflag ) {
-		retval = benaphore_lock( (benaphore_t *)lock );
-	} else {
-		retval = benaphore_timedlock( (benaphore_t *)lock, 0 );
-	}
-	
-	if( retval == EOK ) {
-		success = 1;
-	} else {
-		success = 0;
-		
-		/* TODO: that's bad, raise an exception */
-	}
-
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    int success;
+    status_t retval;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+
+    if( waitflag ) {
+        retval = benaphore_lock( (benaphore_t *)lock );
+    } else {
+        retval = benaphore_timedlock( (benaphore_t *)lock, 0 );
+    }
+
+    if( retval == EOK ) {
+        success = 1;
+    } else {
+        success = 0;
+
+        /* TODO: that's bad, raise an exception */
+    }
+
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void PyThread_release_lock( PyThread_type_lock lock )
 {
-	status_t retval;
-	
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
-	
-	retval = benaphore_unlock( (benaphore_t *)lock );
-	if( retval != EOK ) {
-		/* TODO: that's bad, raise an exception */
-		return;
-	}
+    status_t retval;
+
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+
+    retval = benaphore_unlock( (benaphore_t *)lock );
+    if( retval != EOK ) {
+        /* TODO: that's bad, raise an exception */
+        return;
+    }
 }