--- a/msvc/include/pthreads/pthread.h
+++ b/msvc/include/pthreads/pthread.h
@@ -41,57 +41,57 @@
  *
  *              POSIX 1003.1c-1995      (POSIX.1c)
  *
- *	Parts of the implementation also comply with the
- *	Open Group Unix 98 specification in order to enhance
- *	code portability between Windows, various commercial
- *	Unix implementations, and Linux.
+ *      Parts of the implementation also comply with the
+ *      Open Group Unix 98 specification in order to enhance
+ *      code portability between Windows, various commercial
+ *      Unix implementations, and Linux.
  *
  * Authors:
- *	There have been many contributors to this library.
- *	The initial implementation was contributed by
- *	John Bossom, and several others have provided major
- *	sections or revisions of parts of the implementation.
- *	Often significant effort has been contributed to
- *	find and fix important bugs and other problems to
- *	improve the reliability of the library, which sometimes
- *	is not reflected in the amount of code which changed as
- *	result.
- *	As much as possible, the contributors are acknowledged
- *	in the ChangeLog file in the source code distribution
- *	where their changes are noted in detail.
+ *      There have been many contributors to this library.
+ *      The initial implementation was contributed by
+ *      John Bossom, and several others have provided major
+ *      sections or revisions of parts of the implementation.
+ *      Often significant effort has been contributed to
+ *      find and fix important bugs and other problems to
+ *      improve the reliability of the library, which sometimes
+ *      is not reflected in the amount of code which changed as
+ *      result.
+ *      As much as possible, the contributors are acknowledged
+ *      in the ChangeLog file in the source code distribution
+ *      where their changes are noted in detail.
  *
  *      Contributors are listed in the MAINTAINERS file.
  *
- *	As usual, all bouquets go to the contributors, and all
- *	brickbats go to the project maintainer.
+ *      As usual, all bouquets go to the contributors, and all
+ *      brickbats go to the project maintainer.
  *
  * Maintainer:
- *	The code base for this project is coordinated and
- *	eventually pre-tested, packaged, and made available by
- *
- *		Ross Johnson <rpj@ise.canberra.edu.au>
+ *      The code base for this project is coordinated and
+ *      eventually pre-tested, packaged, and made available by
+ *
+ *              Ross Johnson <rpj@ise.canberra.edu.au>
  *
  * QA Testers:
- *	Ultimately, the library is tested in the real world by
- *	a host of competent and demanding scientists and
- *	engineers who report bugs and/or provide solutions
- *	which are then fixed or incorporated into subsequent
- *	versions of the library. Each time a bug is fixed, a
- *	test case is written to prove the fix and ensure
- *	that later changes to the code don't reintroduce the
- *	same error. The number of test cases is slowly growing
- *	and therefore so is the code reliability.
+ *      Ultimately, the library is tested in the real world by
+ *      a host of competent and demanding scientists and
+ *      engineers who report bugs and/or provide solutions
+ *      which are then fixed or incorporated into subsequent
+ *      versions of the library. Each time a bug is fixed, a
+ *      test case is written to prove the fix and ensure
+ *      that later changes to the code don't reintroduce the
+ *      same error. The number of test cases is slowly growing
+ *      and therefore so is the code reliability.
  *
  * Compliance:
- *	See the file ANNOUNCE for the list of implemented
- *	and not-implemented routines and defined options.
- *	Of course, these are all defined is this file as well.
+ *      See the file ANNOUNCE for the list of implemented
+ *      and not-implemented routines and defined options.
+ *      Of course, these are all defined is this file as well.
  *
  * Web site:
- *	The source code and other information about this library
- *	are available from
- *
- *		http://sources.redhat.com/pthreads-win32/
+ *      The source code and other information about this library
+ *      are available from
+ *
+ *              http://sources.redhat.com/pthreads-win32/
  *
  * -------------------------------------------------------------
  */
@@ -122,8 +122,8 @@
 
 #ifndef HAVE_STRUCT_TIMESPEC
 struct timespec {
-	long tv_sec;
-	long tv_nsec;
+        long tv_sec;
+        long tv_nsec;
 };
 #endif /* HAVE_STRUCT_TIMESPEC */
 
@@ -170,7 +170,7 @@
 #ifdef __cplusplus
 extern "C"
 {
-#endif				/* __cplusplus */
+#endif                          /* __cplusplus */
 
 /*
  * -------------------------------------------------------------
@@ -313,7 +313,7 @@
 #define _POSIX_THREAD_PRIO_PROTECT
 #define _POSIX_THREAD_PROCESS_SHARED
 
-#endif				/* KLUDGE */
+#endif                          /* KLUDGE */
 
 /*
  * POSIX Limits
@@ -341,14 +341,14 @@
  *              revealed this approximate number.
  *
  */
-#define PTHREAD_DESTRUCTOR_ITERATIONS	                   4
-#define PTHREAD_KEYS_MAX				  64
-#define PTHREAD_STACK_MIN				   0
-#define PTHREAD_THREADS_MAX				2019
+#define PTHREAD_DESTRUCTOR_ITERATIONS                      4
+#define PTHREAD_KEYS_MAX                                  64
+#define PTHREAD_STACK_MIN                                  0
+#define PTHREAD_THREADS_MAX                             2019
 
 
 #ifdef _UWIN
-#   include	<sys/types.h>
+#   include     <sys/types.h>
 #else
 typedef struct pthread_t_ *pthread_t;
 typedef struct pthread_attr_t_ *pthread_attr_t;
@@ -377,39 +377,39 @@
 /*
  * pthread_attr_{get,set}detachstate
  */
-  PTHREAD_CREATE_JOINABLE	= 0,  /* Default */
-  PTHREAD_CREATE_DETACHED	= 1,
+  PTHREAD_CREATE_JOINABLE       = 0,  /* Default */
+  PTHREAD_CREATE_DETACHED       = 1,
 
 /*
  * pthread_attr_{get,set}inheritsched
  */
-  PTHREAD_INHERIT_SCHED		= 0,
-  PTHREAD_EXPLICIT_SCHED	= 1,  /* Default */
+  PTHREAD_INHERIT_SCHED         = 0,
+  PTHREAD_EXPLICIT_SCHED        = 1,  /* Default */
 
 /*
  * pthread_{get,set}scope
  */
-  PTHREAD_SCOPE_PROCESS		= 0,
-  PTHREAD_SCOPE_SYSTEM		= 1,  /* Default */
+  PTHREAD_SCOPE_PROCESS         = 0,
+  PTHREAD_SCOPE_SYSTEM          = 1,  /* Default */
 
 /*
  * pthread_setcancelstate paramters
  */
-  PTHREAD_CANCEL_ENABLE		= 0,  /* Default */
-  PTHREAD_CANCEL_DISABLE	= 1,
+  PTHREAD_CANCEL_ENABLE         = 0,  /* Default */
+  PTHREAD_CANCEL_DISABLE        = 1,
 
 /*
  * pthread_setcanceltype parameters
  */
-  PTHREAD_CANCEL_ASYNCHRONOUS	= 0,
-  PTHREAD_CANCEL_DEFERRED	= 1,  /* Default */
+  PTHREAD_CANCEL_ASYNCHRONOUS   = 0,
+  PTHREAD_CANCEL_DEFERRED       = 1,  /* Default */
 
 /*
  * pthread_mutexattr_{get,set}pshared
  * pthread_condattr_{get,set}pshared
  */
-  PTHREAD_PROCESS_PRIVATE	= 0,
-  PTHREAD_PROCESS_SHARED	= 1,
+  PTHREAD_PROCESS_PRIVATE       = 0,
+  PTHREAD_PROCESS_SHARED        = 1,
 
 /*
  * pthread_barrier_wait
@@ -522,125 +522,125 @@
 };
 
 #ifdef __CLEANUP_SEH
-	/*
-	 * WIN32 SEH version of cancel cleanup.
-	 */
+        /*
+         * WIN32 SEH version of cancel cleanup.
+         */
 
 #define pthread_cleanup_push( _rout, _arg ) \
-	{ \
-	    ptw32_cleanup_t	_cleanup; \
-	    \
-        _cleanup.routine	= (ptw32_cleanup_callback_t)(_rout); \
-	    _cleanup.arg	= (_arg); \
-	    __try \
-	      { \
+        { \
+            ptw32_cleanup_t     _cleanup; \
+            \
+        _cleanup.routine        = (ptw32_cleanup_callback_t)(_rout); \
+            _cleanup.arg        = (_arg); \
+            __try \
+              { \
 
 #define pthread_cleanup_pop( _execute ) \
-	      } \
-	    __finally \
-		{ \
-		    if( _execute || AbnormalTermination()) \
-		      { \
-			  (*(_cleanup.routine))( _cleanup.arg ); \
-		      } \
-		} \
-	}
+              } \
+            __finally \
+                { \
+                    if( _execute || AbnormalTermination()) \
+                      { \
+                          (*(_cleanup.routine))( _cleanup.arg ); \
+                      } \
+                } \
+        }
 
 #else /* __CLEANUP_SEH */
 
 #ifdef __CLEANUP_C
 
-	/*
-	 * C implementation of PThreads cancel cleanup
-	 */
+        /*
+         * C implementation of PThreads cancel cleanup
+         */
 
 #define pthread_cleanup_push( _rout, _arg ) \
-	{ \
-	    ptw32_cleanup_t	_cleanup; \
+        { \
+            ptw32_cleanup_t     _cleanup; \
             \
-	    ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); \
+            ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); \
 
 #define pthread_cleanup_pop( _execute ) \
-	    (void) ptw32_pop_cleanup( _execute ); \
-	}
+            (void) ptw32_pop_cleanup( _execute ); \
+        }
 
 #else /* __CLEANUP_C */
 
 #ifdef __CLEANUP_CXX
 
-	/*
-	 * C++ version of cancel cleanup.
-	 * - John E. Bossom.
-	 */
-
-	class PThreadCleanup {
-	  /*
-	   * PThreadCleanup
-	   *
-	   * Purpose
-	   *      This class is a C++ helper class that is
-	   *      used to implement pthread_cleanup_push/
-	   *      pthread_cleanup_pop.
-	   *      The destructor of this class automatically
-	   *      pops the pushed cleanup routine regardless
-	   *      of how the code exits the scope
-	   *      (i.e. such as by an exception)
-	   */
+        /*
+         * C++ version of cancel cleanup.
+         * - John E. Bossom.
+         */
+
+        class PThreadCleanup {
+          /*
+           * PThreadCleanup
+           *
+           * Purpose
+           *      This class is a C++ helper class that is
+           *      used to implement pthread_cleanup_push/
+           *      pthread_cleanup_pop.
+           *      The destructor of this class automatically
+           *      pops the pushed cleanup routine regardless
+           *      of how the code exits the scope
+           *      (i.e. such as by an exception)
+           */
       ptw32_cleanup_callback_t cleanUpRout;
-	  void    *       obj;
-	  int             executeIt;
-
-	public:
-	  PThreadCleanup() :
-	    cleanUpRout( NULL ),
-	    obj( NULL ),
-	    executeIt( 0 )
-	    /*
-	     * No cleanup performed
-	     */
-	    {
-	    }
-
-	  PThreadCleanup(
+          void    *       obj;
+          int             executeIt;
+
+        public:
+          PThreadCleanup() :
+            cleanUpRout( NULL ),
+            obj( NULL ),
+            executeIt( 0 )
+            /*
+             * No cleanup performed
+             */
+            {
+            }
+
+          PThreadCleanup(
              ptw32_cleanup_callback_t routine,
-			 void    *       arg ) :
-	    cleanUpRout( routine ),
-	    obj( arg ),
-	    executeIt( 1 )
-	    /*
+                         void    *       arg ) :
+            cleanUpRout( routine ),
+            obj( arg ),
+            executeIt( 1 )
+            /*
              * Registers a cleanup routine for 'arg'
              */
-	    {
-	    }
-
-	  ~PThreadCleanup()
-	    {
-	      if ( executeIt && ((void *) cleanUpRout != NULL) )
-		{
+            {
+            }
+
+          ~PThreadCleanup()
+            {
+              if ( executeIt && ((void *) cleanUpRout != NULL) )
+                {
                   (void) (*cleanUpRout)( obj );
-		}
-	    }
-
-	  void execute( int exec )
-	    {
-	      executeIt = exec;
-	    }
-	};
-
-	/*
-	 * C++ implementation of PThreads cancel cleanup;
-	 * This implementation takes advantage of a helper
-	 * class who's destructor automatically calls the
-	 * cleanup routine if we exit our scope weirdly
-	 */
+                }
+            }
+
+          void execute( int exec )
+            {
+              executeIt = exec;
+            }
+        };
+
+        /*
+         * C++ implementation of PThreads cancel cleanup;
+         * This implementation takes advantage of a helper
+         * class who's destructor automatically calls the
+         * cleanup routine if we exit our scope weirdly
+         */
 #define pthread_cleanup_push( _rout, _arg ) \
         { \
-	    PThreadCleanup  cleanup((ptw32_cleanup_callback_t)(_rout), \
-				    (void *) (_arg) );
+            PThreadCleanup  cleanup((ptw32_cleanup_callback_t)(_rout), \
+                                    (void *) (_arg) );
 
 #define pthread_cleanup_pop( _execute ) \
-	    cleanup.execute( _execute ); \
-	}
+            cleanup.execute( _execute ); \
+        }
 
 #else
 
@@ -668,22 +668,22 @@
 int pthread_attr_destroy (pthread_attr_t * attr);
 
 int pthread_attr_getdetachstate (const pthread_attr_t * attr,
-				 int *detachstate);
+                                 int *detachstate);
 
 int pthread_attr_getstackaddr (const pthread_attr_t * attr,
-			       void **stackaddr);
+                               void **stackaddr);
 
 int pthread_attr_getstacksize (const pthread_attr_t * attr,
-			       size_t * stacksize);
+                               size_t * stacksize);
 
 int pthread_attr_setdetachstate (pthread_attr_t * attr,
-				 int detachstate);
+                                 int detachstate);
 
 int pthread_attr_setstackaddr (pthread_attr_t * attr,
-			       void *stackaddr);
+                               void *stackaddr);
 
 int pthread_attr_setstacksize (pthread_attr_t * attr,
-			       size_t stacksize);
+                               size_t stacksize);
 
 int pthread_attr_getschedparam (const pthread_attr_t *attr,
                                 struct sched_param *param);
@@ -713,51 +713,51 @@
  * PThread Functions
  */
 int pthread_create (pthread_t * tid,
-		    const pthread_attr_t * attr,
-		    void *(*start) (void *),
-		    void *arg);
+                    const pthread_attr_t * attr,
+                    void *(*start) (void *),
+                    void *arg);
 
 int pthread_detach (pthread_t tid);
 
 int pthread_equal (pthread_t t1,
-		   pthread_t t2);
+                   pthread_t t2);
 
 void pthread_exit (void *value_ptr);
 
 int pthread_join (pthread_t thread,
-		  void **value_ptr);
+                  void **value_ptr);
 
 pthread_t pthread_self (void);
 
 int pthread_cancel (pthread_t thread);
 
 int pthread_setcancelstate (int state,
-			    int *oldstate);
+                            int *oldstate);
 
 int pthread_setcanceltype (int type,
-			   int *oldtype);
+                           int *oldtype);
 
 void pthread_testcancel (void);
 
 int pthread_once (pthread_once_t * once_control,
-		  void (*init_routine) (void));
+                  void (*init_routine) (void));
 
 ptw32_cleanup_t *ptw32_pop_cleanup (int execute);
 
 void ptw32_push_cleanup (ptw32_cleanup_t * cleanup,
-			   void (*routine) (void *),
-			   void *arg);
+                           void (*routine) (void *),
+                           void *arg);
 
 /*
  * Thread Specific Data Functions
  */
 int pthread_key_create (pthread_key_t * key,
-			void (*destructor) (void *));
+                        void (*destructor) (void *));
 
 int pthread_key_delete (pthread_key_t key);
 
 int pthread_setspecific (pthread_key_t key,
-			 const void *value);
+                         const void *value);
 
 void *pthread_getspecific (pthread_key_t key);
 
@@ -770,11 +770,11 @@
 int pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
 
 int pthread_mutexattr_getpshared (const pthread_mutexattr_t
-				  * attr,
-				  int *pshared);
+                                  * attr,
+                                  int *pshared);
 
 int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
-				  int pshared);
+                                  int pshared);
 
 int pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind);
 int pthread_mutexattr_gettype (pthread_mutexattr_t * attr, int *kind);
@@ -787,17 +787,17 @@
 int pthread_barrierattr_destroy (pthread_barrierattr_t * attr);
 
 int pthread_barrierattr_getpshared (const pthread_barrierattr_t
-				    * attr,
-				    int *pshared);
+                                    * attr,
+                                    int *pshared);
 
 int pthread_barrierattr_setpshared (pthread_barrierattr_t * attr,
-				    int pshared);
+                                    int pshared);
 
 /*
  * Mutex Functions
  */
 int pthread_mutex_init (pthread_mutex_t * mutex,
-			const pthread_mutexattr_t * attr);
+                        const pthread_mutexattr_t * attr);
 
 int pthread_mutex_destroy (pthread_mutex_t * mutex);
 
@@ -824,7 +824,7 @@
  * Barrier Functions
  */
 int pthread_barrier_init (pthread_barrier_t * barrier,
-			  const pthread_barrierattr_t * attr,
+                          const pthread_barrierattr_t * attr,
                           unsigned int count);
 
 int pthread_barrier_destroy (pthread_barrier_t * barrier);
@@ -839,25 +839,25 @@
 int pthread_condattr_destroy (pthread_condattr_t * attr);
 
 int pthread_condattr_getpshared (const pthread_condattr_t * attr,
-				 int *pshared);
+                                 int *pshared);
 
 int pthread_condattr_setpshared (pthread_condattr_t * attr,
-				 int pshared);
+                                 int pshared);
 
 /*
  * Condition Variable Functions
  */
 int pthread_cond_init (pthread_cond_t * cond,
-		       const pthread_condattr_t * attr);
+                       const pthread_condattr_t * attr);
 
 int pthread_cond_destroy (pthread_cond_t * cond);
 
 int pthread_cond_wait (pthread_cond_t * cond,
-		       pthread_mutex_t * mutex);
+                       pthread_mutex_t * mutex);
 
 int pthread_cond_timedwait (pthread_cond_t * cond,
-			    pthread_mutex_t * mutex,
-			    const struct timespec *abstime);
+                            pthread_mutex_t * mutex,
+                            const struct timespec *abstime);
 
 int pthread_cond_signal (pthread_cond_t * cond);
 
@@ -867,12 +867,12 @@
  * Scheduling
  */
 int pthread_setschedparam (pthread_t thread,
-			   int policy,
-			   const struct sched_param *param);
+                           int policy,
+                           const struct sched_param *param);
 
 int pthread_getschedparam (pthread_t thread,
-			   int *policy,
-			   struct sched_param *param);
+                           int *policy,
+                           struct sched_param *param);
 
 int pthread_setconcurrency (int);
 
@@ -980,27 +980,27 @@
 
 #if !defined(__MINGW32__)
 #define strtok_r( _s, _sep, _lasts ) \
-	( *(_lasts) = strtok( (_s), (_sep) ) )
+        ( *(_lasts) = strtok( (_s), (_sep) ) )
 #endif /* !__MINGW32__ */
 
 #define asctime_r( _tm, _buf ) \
-	( strcpy( (_buf), asctime( (_tm) ) ), \
-	  (_buf) )
+        ( strcpy( (_buf), asctime( (_tm) ) ), \
+          (_buf) )
 
 #define ctime_r( _clock, _buf ) \
-	( strcpy( (_buf), ctime( (_clock) ) ),  \
+        ( strcpy( (_buf), ctime( (_clock) ) ),  \
           (_buf) )
 
 #define gmtime_r( _clock, _result ) \
-	( *(_result) = *gmtime( (_clock) ), \
-	  (_result) )
+        ( *(_result) = *gmtime( (_clock) ), \
+          (_result) )
 
 #define localtime_r( _clock, _result ) \
-	( *(_result) = *localtime( (_clock) ), \
-	  (_result) )
+        ( *(_result) = *localtime( (_clock) ), \
+          (_result) )
 
 #define rand_r( _seed ) \
-	( _seed == _seed? rand() : rand() )
+        ( _seed == _seed? rand() : rand() )
 
 
 #ifdef __cplusplus
@@ -1030,7 +1030,7 @@
  */
 #define __except( E ) \
         __except( ( GetExceptionCode() == ptw32_get_exception_services_code() ) \
-		 ? EXCEPTION_CONTINUE_SEARCH : ( E ) )
+                 ? EXCEPTION_CONTINUE_SEARCH : ( E ) )
 
 #endif /* __CLEANUP_SEH */
 
@@ -1071,7 +1071,7 @@
 #endif /* ! PTW32_BUILD */
 
 #ifdef __cplusplus
-}				/* End of extern "C" */
-#endif				/* __cplusplus */
+}                               /* End of extern "C" */
+#endif                          /* __cplusplus */
 
 #endif /* PTHREAD_H */