reformat for PEP-7 style conformance

Python/thread_os2.h

@@ -28,85 +28,86 @@ PyThread__init_thread(void)
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-  int aThread;
-  int success = 0;
+	int aThread;
+	int success = 0;
 
-  aThread = _beginthread(func,NULL,65536,arg);
+	aThread = _beginthread(func,NULL,65536,arg);
 
-  if( aThread == -1 ) {
-    success = -1;
-    fprintf(stderr,"aThread failed == %d",aThread);
-    dprintf(("_beginthread failed. return %ld\n", errno));
-  }
+	if (aThread == -1) {
+		success = -1;
+		fprintf(stderr, "aThread failed == %d", aThread);
+		dprintf(("_beginthread failed. return %ld\n", errno));
+	}
 
-  return success;
+	return success;
 }
 
 long
 PyThread_get_thread_ident(void)
 {
 #if !defined(PYCC_GCC)
-  PPIB pib;
-  PTIB tib;
+	PPIB pib;
+	PTIB tib;
 #endif
 
-  if (!initialized)
-    PyThread_init_thread();
-        
+	if (!initialized)
+		PyThread_init_thread();
+
 #if defined(PYCC_GCC)
-  return _gettid();
+	return _gettid();
 #else
-  DosGetInfoBlocks(&tib,&pib);
-  return tib->tib_ptib2->tib2_ultid;
+	DosGetInfoBlocks(&tib, &pib);
+	return tib->tib_ptib2->tib2_ultid;
 #endif
 }
 
 static void
 do_PyThread_exit_thread(int no_cleanup)
 {
-  dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
-  if (!initialized)
-    if (no_cleanup)
-      _exit(0);
-    else
-      exit(0);
-  _endthread();
+	dprintf(("%ld: PyThread_exit_thread called\n",
+		 PyThread_get_thread_ident()));
+	if (!initialized)
+		if (no_cleanup)
+			_exit(0);
+		else
+			exit(0);
+	_endthread();
 }
 
 void 
 PyThread_exit_thread(void)
 {
-  do_PyThread_exit_thread(0);
+	do_PyThread_exit_thread(0);
 }
 
 void 
 PyThread__exit_thread(void)
 {
-  do_PyThread_exit_thread(1);
+	do_PyThread_exit_thread(1);
 }
 
 #ifndef NO_EXIT_PROG
 static void 
 do_PyThread_exit_prog(int status, int no_cleanup)
 {
-  dprintf(("PyThread_exit_prog(%d) called\n", status));
-  if (!initialized)
-    if (no_cleanup)
-      _exit(status);
-    else
-      exit(status);
+	dprintf(("PyThread_exit_prog(%d) called\n", status));
+	if (!initialized)
+		if (no_cleanup)
+			_exit(status);
+		else
+			exit(status);
 }
 
 void 
 PyThread_exit_prog(int status)
 {
-  do_PyThread_exit_prog(status, 0);
+	do_PyThread_exit_prog(status, 0);
 }
 
 void 
 PyThread__exit_prog(int status)
 {
-  do_PyThread_exit_prog(status, 1);
+	do_PyThread_exit_prog(status, 1);
 }
 #endif /* NO_EXIT_PROG */
 
@@ -117,42 +118,42 @@ PyThread__exit_prog(int status)
  */
 
 typedef struct os2_lock_t {
-  int is_set;
-  HEV changed;
+	int is_set;
+	HEV changed;
 } *type_os2_lock;
 
 PyThread_type_lock 
 PyThread_allocate_lock(void)
 {
 #if defined(PYCC_GCC)
-  _fmutex *sem = malloc(sizeof(_fmutex));
-  if (!initialized)
-    PyThread_init_thread();
-  dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
-    PyThread_get_thread_ident(),
-    (long)sem));
-  if (_fmutex_create(sem, 0)) {
-    free(sem);
-    sem = NULL;
-  }
-  return (PyThread_type_lock) sem;
+	_fmutex *sem = malloc(sizeof(_fmutex));
+	if (!initialized)
+		PyThread_init_thread();
+	dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
+		 PyThread_get_thread_ident(),
+		 (long)sem));
+	if (_fmutex_create(sem, 0)) {
+		free(sem);
+		sem = NULL;
+	}
+	return (PyThread_type_lock)sem;
 #else
-  APIRET rc;
-  type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
+	APIRET rc;
+	type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
 
-  dprintf(("PyThread_allocate_lock called\n"));
-  if (!initialized)
-    PyThread_init_thread();
+	dprintf(("PyThread_allocate_lock called\n"));
+	if (!initialized)
+		PyThread_init_thread();
 
-  lock->is_set = 0;
+	lock->is_set = 0;
 
-  DosCreateEventSem(NULL, &lock->changed, 0, 0);
+	DosCreateEventSem(NULL, &lock->changed, 0, 0);
 
-  dprintf(("%ld: PyThread_allocate_lock() -> %p\n", 
-           PyThread_get_thread_ident(), 
-           lock->changed));
+	dprintf(("%ld: PyThread_allocate_lock() -> %p\n", 
+		 PyThread_get_thread_ident(), 
+        	 lock->changed));
 
-  return (PyThread_type_lock) lock;
+	return (PyThread_type_lock)lock;
 #endif
 }
 
@@ -160,19 +161,20 @@ void
 PyThread_free_lock(PyThread_type_lock aLock)
 {
 #if !defined(PYCC_GCC)
-  type_os2_lock lock = (type_os2_lock)aLock;
+	type_os2_lock lock = (type_os2_lock)aLock;
 #endif
 
-  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));
 
 #if defined(PYCC_GCC)
-  if (aLock) {
-    _fmutex_close((_fmutex *)aLock);
-    free((_fmutex *)aLock);
-  }
+	if (aLock) {
+		_fmutex_close((_fmutex *)aLock);
+		free((_fmutex *)aLock);
+	}
 #else
-  DosCloseEventSem(lock->changed);
-  free(aLock);
+	DosCloseEventSem(lock->changed);
+	free(aLock);
 #endif
 }
 
@@ -185,77 +187,86 @@ int
 PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 {
 #if !defined(PYCC_GCC)
-  int   done = 0;
-  ULONG count;
-  PID   pid = 0;
-  TID   tid = 0;
-  type_os2_lock lock = (type_os2_lock)aLock;
+	int   done = 0;
+	ULONG count;
+	PID   pid = 0;
+	TID   tid = 0;
+	type_os2_lock lock = (type_os2_lock)aLock;
 #endif
 
-  dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),
-           aLock, waitflag));
+	dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",
+		 PyThread_get_thread_ident(),
+		 aLock,
+		 waitflag));
 
 #if defined(PYCC_GCC)
-  /* always successful if the lock doesn't exist */
-  if (aLock && _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
-      return 0;
+	/* always successful if the lock doesn't exist */
+	if (aLock &&
+	    _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
+		return 0;
 #else
-  while (!done) {
-    /* if the lock is currently set, we have to wait for the state to change */
-    if (lock->is_set) {
-      if (!waitflag)
-        return 0;
-      DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
-    }
-    
-    /* 
-     * enter a critical section and try to get the semaphore.  If
-     * it is still locked, we will try again.
-     */
-    if (DosEnterCritSec())
-      return 0;
-
-    if (!lock->is_set) {
-      lock->is_set = 1;
-      DosResetEventSem(lock->changed, &count);
-      done = 1;
-    }
-
-    DosExitCritSec();
-  }
+	while (!done) {
+		/* if the lock is currently set, we have to wait for
+		 * the state to change
+		 */
+		if (lock->is_set) {
+			if (!waitflag)
+				return 0;
+			DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
+		}
+
+		/* enter a critical section and try to get the semaphore.  If
+		 * it is still locked, we will try again.
+		 */
+		if (DosEnterCritSec())
+			return 0;
+
+		if (!lock->is_set) {
+			lock->is_set = 1;
+			DosResetEventSem(lock->changed, &count);
+			done = 1;
+		}
+
+		DosExitCritSec();
+	}
 #endif
 
-  return 1;
+	return 1;
 }
 
 void PyThread_release_lock(PyThread_type_lock aLock)
 {
 #if !defined(PYCC_GCC)
-  type_os2_lock lock = (type_os2_lock)aLock;
+	type_os2_lock lock = (type_os2_lock)aLock;
 #endif
 
-  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 defined(PYCC_GCC)
-  if (aLock)
-    _fmutex_release((_fmutex *)aLock);
+	if (aLock)
+		_fmutex_release((_fmutex *)aLock);
 #else
-  if (!lock->is_set) {
-    dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
-             PyThread_get_thread_ident(), aLock, GetLastError()));
-    return;
-  }
-
-
-  if (DosEnterCritSec()) {
-    dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
-             PyThread_get_thread_ident(), aLock, GetLastError()));
-    return;
-  }
-  
-  lock->is_set = 0;
-  DosPostEventSem(lock->changed);
-  
-  DosExitCritSec();
+	if (!lock->is_set) {
+		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
+			 PyThread_get_thread_ident(),
+			 aLock,
+			 GetLastError()));
+		return;
+	}
+
+	if (DosEnterCritSec()) {
+		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
+			 PyThread_get_thread_ident(),
+			 aLock,
+			 GetLastError()));
+		return;
+	}
+
+	lock->is_set = 0;
+	DosPostEventSem(lock->changed);
+
+	DosExitCritSec();
 #endif
 }