upgrade libuv to a6ed175

14 years ago · 1088638725
196 changed files with 487 additions and 35809 deletions
--- a/deps/uv/LICENSE
+++ b/deps/uv/LICENSE
@ -38,11 +38,3 @@ The externally maintained libraries used by libuv are:
  - libeio, located at eio/ is copyright Marc Alexander Lehmann, and
    dual-licensed under the MIT license and GPL2.
  - deps/pthread-win32 is a POSIX threads library for
    Microsoft Windows and is used for the Windows build and statically
    linked into the Node executable. This software is freely available at
    http://sourceware.org/pthreads-win32/ It is Copyright 1998 John E.
    Bossom and 1999,2006 Pthreads-win32 contributors and licensed under the
    LGPL. See deps/pthread-win32/COPYING.LIB for more details.
--- a/deps/uv/deps/pthread-win32/.gitignore
+++ b/deps/uv/deps/pthread-win32/.gitignore
@ -1,5 +0,0 @@
 CVS
 *.obj
 *.dll
 *.lib
 *.res
--- a/deps/uv/deps/pthread-win32/ANNOUNCE
+++ b/deps/uv/deps/pthread-win32/ANNOUNCE
@ -1,482 +0,0 @@
 	     PTHREADS-WIN32 RELEASE 2.9.0 (2007-??-??)
 	     -----------------------------------------
 	 Web Site: http://sources.redhat.com/pthreads-win32/
 	FTP Site: ftp://sources.redhat.com/pub/pthreads-win32
 	 Maintainer: Ross Johnson <rpj@callisto.canberra.edu.au>
 We are pleased to announce the availability of a new release of
 Pthreads-win32, an Open Source Software implementation of the
 Threads component of the POSIX 1003.1 2001 Standard for Microsoft's
 Win32 environment. Some functions from other sections of POSIX
 1003.1 2001 are also supported including semaphores and scheduling
 functions.
 Some common non-portable functions are also implemented for
 additional compatibility, as are a few functions specific
 to pthreads-win32 for easier integration with Win32 applications.
 Pthreads-win32 is free software, distributed under the GNU Lesser
 General Public License (LGPL).
 Acknowledgements
 ----------------
 This library is based originally on a Win32 pthreads
 implementation contributed by John Bossom <John.Bossom@cognos.com>.
 The implementation of Condition Variables uses algorithms developed
 by Alexander Terekhov and Louis Thomas.
 The implementation of POSIX mutexes has been improved by Thomas Pfaff
 and later by Alexander Terekhov.
 The implementation of Spinlocks and Barriers was contributed
 by Ross Johnson.
 The implementation of read/write locks was contributed by
 Aurelio Medina and improved by Alexander Terekhov.
 Many others have contributed significant time and effort to solve crutial
 problems in order to make the library workable, robust and reliable.
 Thanks to Xavier Leroy for granting permission to use and modify his
 LinuxThreads manual pages.
 Thanks to The Open Group for making the Single Unix Specification
 publicly available - many of the manual pages included in the package
 were extracted from it.
 There is also a separate CONTRIBUTORS file. This file and others are
 on the web site:
 	http://sources.redhat.com/pthreads-win32
 As much as possible, the ChangeLog file acknowledges contributions to the
 code base in more detail.
 Changes since the last release
 ------------------------------
 These are now documented in the NEWS file.
 See the ChangeLog file also.
 Known Bugs
 ----------
 These are now documented in the BUGS file.
 Level of standards conformance
 ------------------------------
 The following POSIX 1003.1 2001 options are defined and set to 200112L:
      _POSIX_THREADS
      _POSIX_THREAD_SAFE_FUNCTIONS
      _POSIX_THREAD_ATTR_STACKSIZE
      _POSIX_THREAD_PRIORITY_SCHEDULING
      _POSIX_SEMAPHORES
      _POSIX_READER_WRITER_LOCKS
      _POSIX_SPIN_LOCKS
      _POSIX_BARRIERS
 The following POSIX 1003.1 2001 options are defined and set to -1:
      _POSIX_THREAD_ATTR_STACKADDR
      _POSIX_THREAD_PRIO_INHERIT
      _POSIX_THREAD_PRIO_PROTECT
      _POSIX_THREAD_PROCESS_SHARED
 The following POSIX 1003.1 2001 limits are defined and set:
      _POSIX_THREAD_THREADS_MAX
      _POSIX_SEM_VALUE_MAX
      _POSIX_SEM_NSEMS_MAX
      _POSIX_THREAD_KEYS_MAX
      _POSIX_THREAD_DESTRUCTOR_ITERATIONS
      PTHREAD_STACK_MIN
      PTHREAD_THREADS_MAX
      SEM_VALUE_MAX
      SEM_NSEMS_MAX
      PTHREAD_KEYS_MAX
      PTHREAD_DESTRUCTOR_ITERATIONS
 The following functions are implemented:
      ---------------------------
      PThreads
      ---------------------------
      pthread_attr_init
      pthread_attr_destroy
      pthread_attr_getdetachstate
      pthread_attr_getstackaddr
      pthread_attr_getstacksize
      pthread_attr_setdetachstate
      pthread_attr_setstackaddr
      pthread_attr_setstacksize
      pthread_create
      pthread_detach
      pthread_equal
      pthread_exit
      pthread_join
      pthread_once
      pthread_self
      pthread_cancel
      pthread_cleanup_pop
      pthread_cleanup_push
      pthread_setcancelstate
      pthread_setcanceltype
      pthread_testcancel
      ---------------------------
      Thread Specific Data
      ---------------------------
      pthread_key_create
      pthread_key_delete
      pthread_setspecific
      pthread_getspecific
      ---------------------------
      Mutexes
      ---------------------------
      pthread_mutexattr_init
      pthread_mutexattr_destroy
      pthread_mutexattr_getpshared
      pthread_mutexattr_setpshared
      pthread_mutexattr_gettype
      pthread_mutexattr_settype (types: PTHREAD_MUTEX_DEFAULT
 					PTHREAD_MUTEX_NORMAL
 					PTHREAD_MUTEX_ERRORCHECK
 					PTHREAD_MUTEX_RECURSIVE  )
      pthread_mutexattr_getrobust
      pthread_mutexattr_setrobust (values: PTHREAD_MUTEX_STALLED
                                           PTHREAD_MUTEX_ROBUST)
      pthread_mutex_init
      pthread_mutex_destroy
      pthread_mutex_lock
      pthread_mutex_trylock
      pthread_mutex_timedlock
      pthread_mutex_unlock
      pthread_mutex_consistent
      ---------------------------
      Condition Variables
      ---------------------------
      pthread_condattr_init
      pthread_condattr_destroy
      pthread_condattr_getpshared
      pthread_condattr_setpshared
      pthread_cond_init
      pthread_cond_destroy
      pthread_cond_wait
      pthread_cond_timedwait
      pthread_cond_signal
      pthread_cond_broadcast
      ---------------------------
      Read/Write Locks
      ---------------------------
      pthread_rwlock_init
      pthread_rwlock_destroy
      pthread_rwlock_tryrdlock
      pthread_rwlock_trywrlock
      pthread_rwlock_rdlock
      pthread_rwlock_timedrdlock
      pthread_rwlock_rwlock
      pthread_rwlock_timedwrlock
      pthread_rwlock_unlock
      pthread_rwlockattr_init
      pthread_rwlockattr_destroy
      pthread_rwlockattr_getpshared
      pthread_rwlockattr_setpshared
      ---------------------------
      Spin Locks
      ---------------------------
      pthread_spin_init
      pthread_spin_destroy
      pthread_spin_lock
      pthread_spin_unlock
      pthread_spin_trylock
      ---------------------------
      Barriers
      ---------------------------
      pthread_barrier_init
      pthread_barrier_destroy
      pthread_barrier_wait
      pthread_barrierattr_init
      pthread_barrierattr_destroy
      pthread_barrierattr_getpshared
      pthread_barrierattr_setpshared
      ---------------------------
      Semaphores
      ---------------------------
      sem_init
      sem_destroy
      sem_post
      sem_wait
      sem_trywait
      sem_timedwait
      sem_getvalue	     (# free if +ve, # of waiters if -ve)
      sem_open		     (returns an error ENOSYS)
      sem_close 	     (returns an error ENOSYS)
      sem_unlink	     (returns an error ENOSYS)
      ---------------------------
      RealTime Scheduling
      ---------------------------
      pthread_attr_getschedparam
      pthread_attr_setschedparam
      pthread_attr_getinheritsched
      pthread_attr_setinheritsched
      pthread_attr_getschedpolicy (only supports SCHED_OTHER)
      pthread_attr_setschedpolicy (only supports SCHED_OTHER)
      pthread_getschedparam
      pthread_setschedparam
      pthread_getconcurrency
      pthread_setconcurrency
      pthread_attr_getscope
      pthread_attr_setscope  (only supports PTHREAD_SCOPE_SYSTEM)
      sched_get_priority_max
      sched_get_priority_min
      sched_rr_get_interval  (returns an error ENOTSUP)
      sched_setscheduler     (only supports SCHED_OTHER)
      sched_getscheduler     (only supports SCHED_OTHER)
      sched_yield
      ---------------------------
      Signals
      ---------------------------
      pthread_sigmask
      pthread_kill           (only supports zero sig value,
                              for thread validity checking)
      ---------------------------
      Non-portable routines (see the README.NONPORTABLE file for usage)
      ---------------------------
      pthread_getw32threadhandle_np
      pthread_timechange_handler_np
      pthread_delay_np
      pthread_getunique_np
      pthread_mutexattr_getkind_np
      pthread_mutexattr_setkind_np	(types: PTHREAD_MUTEX_FAST_NP,
 						PTHREAD_MUTEX_ERRORCHECK_NP,
 						PTHREAD_MUTEX_RECURSIVE_NP,
 						PTHREAD_MUTEX_ADAPTIVE_NP,
 						PTHREAD_MUTEX_TIMED_NP)
      pthread_num_processors_np
      pthread_win32_process_attach_np	(Required when statically linking
                                         the library)
      pthread_win32_process_detach_np	(Required when statically linking
                                         the library)
      pthread_win32_thread_attach_np	(Required when statically linking
                                         the library)
      pthread_win32_thread_detach_np	(Required when statically linking
                                         the library)
      ---------------------------
      Static Initializers
      ---------------------------
      PTHREAD_ONCE_INIT
      PTHREAD_MUTEX_INITIALIZER
      PTHREAD_RECURSIVE_MUTEX_INITIALIZER
      PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
      PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
      PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
      PTHREAD_COND_INITIALIZER
      PTHREAD_RWLOCK_INITIALIZER
      PTHREAD_SPINLOCK_INITIALIZER
 The library includes two non-API functions for creating cancellation
 points in applications and libraries:
      pthreadCancelableWait
      pthreadCancelableTimedWait
 The following functions are not implemented:
      ---------------------------
      RealTime Scheduling
      ---------------------------
      pthread_mutex_getprioceiling
      pthread_mutex_setprioceiling
      pthread_mutex_attr_getprioceiling
      pthread_mutex_attr_getprotocol
      pthread_mutex_attr_setprioceiling
      pthread_mutex_attr_setprotocol
      ---------------------------
      Fork Handlers
      ---------------------------
      pthread_atfork
      ---------------------------
      Stdio
      --------------------------- 
      flockfile
      ftrylockfile
      funlockfile
      getc_unlocked
      getchar_unlocked	
      putc_unlocked
      putchar_unlocked
      ---------------------------
      Thread-Safe C Runtime Library
      ---------------------------
      readdir_r
      getgrgid_r
      getgrnam_r
      getpwuid_r
      getpwnam_r
      ---------------------------
      Signals
      ---------------------------
      sigtimedwait
      sigwait
      sigwaitinfo
      ---------------------------
      General
      ---------------------------
      sysconf      
      ---------------------------
      Thread-Safe C Runtime Library (macros)
      ---------------------------
      strtok_r
      asctime_r
      ctime_r
      gmtime_r
      localtime_r
      rand_r
 Availability
 ------------ 
 The prebuilt DLL, export libs (for both MSVC and Mingw32), and the header
 files (pthread.h, semaphore.h, sched.h) are available along with the
 complete source code.
 The source code can be found at:
 	ftp://sources.redhat.com/pub/pthreads-win32
 and as individual source code files at
 	ftp://sources.redhat.com/pub/pthreads-win32/source
 The pre-built DLL, export libraries and include files can be found at:
 	ftp://sources.redhat.com/pub/pthreads-win32/dll-latest
 Mailing List 
 ------------  
 There is a mailing list for discussing pthreads on Win32. To join,
 send email to:
 	pthreads-win32-subscribe@sourceware.cygnus.com
 Application Development Environments
 ------------------------------------
 See the README file for more information.
 MSVC:
 MSVC using SEH works. Distribute pthreadVSE.dll with your application.
 MSVC using C++ EH works. Distribute pthreadVCE.dll with your application.
 MSVC using C setjmp/longjmp works. Distribute pthreadVC.dll with your application.
 Mingw32:
 See the FAQ, Questions 6 and 10.
 Mingw using C++ EH works. Distribute pthreadGCE.dll with your application.
 Mingw using C setjmp/longjmp works. Distribute pthreadGC.dll with your application.
 Cygwin: (http://sourceware.cygnus.com/cygwin/)
 Developers using Cygwin do not need pthreads-win32 since it has POSIX threads
 support. Refer to its documentation for details and extent.
 UWIN:
 UWIN is a complete Unix-like environment for Windows from AT&T. Pthreads-win32
 doesn't currently support UWIN (and vice versa), but that may change in the
 future.
 Generally:
 For convenience, the following pre-built files are available on the FTP site
 (see Availability above):
 	pthread.h	- for POSIX threads
 	semaphore.h	- for POSIX semaphores
 	sched.h 	- for POSIX scheduling
 	pthreadVCE.dll	- built with MSVC++ compiler using C++ EH
 	pthreadVCE.lib
 	pthreadVC.dll	- built with MSVC compiler using C setjmp/longjmp
 	pthreadVC.lib
 	pthreadVSE.dll	- built with MSVC compiler using SEH
 	pthreadVSE.lib
 	pthreadGCE.dll	- built with Mingw32 G++ 2.95.2-1
 	pthreadGC.dll	- built with Mingw32 GCC 2.95.2-1 using setjmp/longjmp
 	libpthreadGCE.a - derived from pthreadGCE.dll
 	libpthreadGC.a	- derived from pthreadGC.dll
 	gcc.dll 	- needed if distributing applications that use
 			  pthreadGCE.dll (but see the FAQ Q 10 for the latest
 			  related information)
 These are the only files you need in order to build POSIX threads
 applications for Win32 using either MSVC or Mingw32.
 See the FAQ file in the source tree for additional information.
 Documentation
 -------------
 For the authoritative reference, see the online POSIX
 standard reference at:
       http://www.OpenGroup.org
 For POSIX Thread API programming, several reference books are
 available:
       Programming with POSIX Threads
       David R. Butenhof
       Addison-Wesley (pub)
       Pthreads Programming
       By Bradford Nichols, Dick Buttlar & Jacqueline Proulx Farrell
       O'Reilly (pub)
 On the web: see the links at the bottom of the pthreads-win32 site:
       http://sources.redhat.com/pthreads-win32/
       Currently, there is no documentation included in the package apart
       from the copious comments in the source code.
 Enjoy!
 Ross Johnson
--- a/deps/uv/deps/pthread-win32/BUGS
+++ b/deps/uv/deps/pthread-win32/BUGS
@ -1,141 +0,0 @@
 ----------
 Known bugs
 ----------
 1. Not strictly a bug, more of a gotcha.
   Under MS VC++ (only tested with version 6.0), a term_func
   set via the standard C++ set_terminate() function causes the
   application to abort.
   Notes from the MSVC++ manual:
         1) A term_func() should call exit(), otherwise
            abort() will be called on return to the caller.
            A call to abort() raises SIGABRT and the default signal handler
            for all signals terminates the calling program with
            exit code 3.
         2) A term_func() must not throw an exception. Therefore
            term_func() should not call pthread_exit(), which
            works by throwing an exception (pthreadVCE or pthreadVSE)
            or by calling longjmp (pthreadVC).
   Workaround: avoid using pthread_exit() in C++ applications. Exit
   threads by dropping through the end of the thread routine.
 2. Cancellation problems in C++ builds
   - Milan Gardian
   [Note: It's not clear if this problem isn't simply due to the context
   switch in pthread_cancel() which occurs unless the QueueUserAPCEx
   library and driver are installed and used. Just like setjmp/longjmp,
   this is probably not going to work well in C++. In any case, unless for
   some very unusual reason you really must use the C++ build then please
   use the C build pthreadVC2.dll or pthreadGC2.dll, i.e. for C++
   applications.]
   This is suspected to be a compiler bug in VC6.0, and also seen in
   VC7.0 and VS .NET 2003. The GNU C++ compiler does not have a problem
   with this, and it has been reported that the Intel C++ 8.1 compiler
   and Visual C++ 2005 Express Edition Beta2 pass tests\semaphore4.c
   (which exposes the bug).
   Workaround [rpj - 2 Feb 2002]
   -----------------------------
   [Please note: this workaround did not solve a similar problem in
   snapshot-2004-11-03 or later, even though similar symptoms were seen.
   tests\semaphore4.c fails in that snapshot for the VCE version of the
   DLL.]
   The problem disappears when /Ob0 is used, i.e. /O2 /Ob0 works OK,
   but if you want to use inlining optimisation you can be much more
   specific about where it's switched off and on by using a pragma.
   So the inlining optimisation is interfering with the way that cleanup
   handlers are run. It appears to relate to auto-inlining of class methods
   since this is the only auto inlining that is performed at /O1 optimisation
   (functions with the "inline" qualifier are also inlined, but the problem
   doesn't appear to involve any such functions in the library or testsuite).
   In order to confirm the inlining culprit, the following use of pragmas
   eliminate the problem but I don't know how to make it transparent, putting
   it in, say, pthread.h where pthread_cleanup_push defined as a macro.
   #pragma inline_depth(0)
     pthread_cleanup_push(handlerFunc, (void *) &arg);
        /* ... */
     pthread_cleanup_pop(0);
   #pragma inline_depth()
   Note the empty () pragma value after the pop macro. This resets depth to the
   default. Or you can specify a non-zero depth here.
   The pragma is also needed (and now used) within the library itself wherever
   cleanup handlers are used (condvar.c and rwlock.c).
   Use of these pragmas allows compiler optimisations /O1 and /O2 to be
   used for either or both the library and applications.
   Experimenting further, I found that wrapping the actual cleanup handler
   function with #pragma auto_inline(off|on) does NOT work.
   MSVC6.0 doesn't appear to support the C99 standard's _Pragma directive,
   however, later versions may. This form is embeddable inside #define
   macros, which would be ideal because it would mean that it could be added
   to the push/pop macro definitions in pthread.h and hidden from the
   application programmer.
   [/rpj]
   Original problem description
   ----------------------------
   The cancellation (actually, cleanup-after-cancel) tests fail when using VC
   (professional) optimisation switches (/O1 or /O2) in pthreads library. I
   have not investigated which concrete optimisation technique causes this
   problem (/Og, /Oi, /Ot, /Oy, /Ob1, /Gs, /Gf, /Gy, etc.), but here is a
   summary of builds and corresponding failures:
     * pthreads VSE (optimised tests): OK
     * pthreads VCE (optimised tests): Failed "cleanup1" test (runtime)
     * pthreads VSE (DLL in CRT, optimised tests): OK
     * pthreads VCE (DLL in CRT, optimised tests): Failed "cleanup1" test
   (runtime)
   Please note that while in VSE version of the pthreads library the
   optimisation does not really have any impact on the tests (they pass OK), in
   VCE version addition of optimisation (/O2 in this case) causes the tests to
   fail uniformly - either in "cleanup0" or "cleanup1" test cases.
   Please note that all the tests above use default pthreads DLL (no
   optimisations, linked with either static or DLL CRT, based on test type).
   Therefore the problem lies not within the pthreads DLL but within the
   compiled client code (the application using pthreads -> involvement of
   "pthread.h").
   I think the message of this section is that usage of VCE version of pthreads
   in applications relying on cancellation/cleanup AND using optimisations for
   creation of production code is highly unreliable for the current version of
   the pthreads library.
 3. The Borland Builder 5.5 version of the library produces memory read exceptions
 in some tests.
 4. pthread_barrier_wait() can deadlock if the number of potential calling
 threads for a particular barrier is greater than the barrier count parameter
 given to pthread_barrier_init() for that barrier.
 This is due to the very lightweight implementation of pthread-win32 barriers.
 To cope with more than "count" possible waiters, barriers must effectively
 implement all the same safeguards as condition variables, making them much
 "heavier" than at present.
 The workaround is to ensure that no more than "count" threads attempt to wait
 at the barrier.
 5. Canceling a thread blocked on pthread_once appears not to work in the MSVC++
 version of the library "pthreadVCE.dll". The test case "once3.c" hangs. I have no
 clues on this at present. All other versions pass this test ok - pthreadsVC.dll,
 pthreadsVSE.dll, pthreadsGC.dll and pthreadsGCE.dll. 
--- a/deps/uv/deps/pthread-win32/Bmakefile
+++ b/deps/uv/deps/pthread-win32/Bmakefile
@ -1,268 +0,0 @@
 # This makefile is compatible with BCB make.  Use "make -fBMakefile" to compile.
 # 
 # The variables $DLLDEST and $LIBDEST hold the destination directories for the
 # dll and the lib, respectively. Probably all that needs to change is $DEVROOT.
 #
 # Currently only the recommended pthreadBC.dll is built by this makefile.
 #
 DLL_VER	= 2
 DEVROOT	= .
 DLLDEST	= $(DEVROOT)\DLL
 LIBDEST	= $(DEVROOT)\DLL
 DLLS	= pthreadBC$(DLL_VER).dll
 OPTIM	= /O2
 RC	= brcc32
 RCFLAGS	= -i.
 CFLAGS	= /q /I. /D_WIN32_WINNT=0x400 /DHAVE_PTW32_CONFIG_H=1 /4 /tWD /tWM \
 	  /w-aus /w-asc /w-par
 #C cleanup code
 BCFLAGS	= $(PTW32_FLAGS) $(CFLAGS)
 # Agregate modules for inlinability
 DLL_OBJS	= \
 		attr.obj \
 		barrier.obj \
 		cancel.obj \
 		cleanup.obj \
 		condvar.obj \
 		create.obj \
 		dll.obj \
 		errno.obj \
 		exit.obj \
 		fork.obj \
 		global.obj \
 		misc.obj \
 		mutex.obj \
 		nonportable.obj \
 		private.obj \
 		rwlock.obj \
 		sched.obj \
 		semaphore.obj \
 		signal.obj \
 		spin.obj \
 		sync.obj \
 		tsd.obj
 INCL	= config.h implement.h semaphore.h pthread.h need_errno.h
 ATTR_SRCS	= \
 		pthread_attr_init.c \
 		pthread_attr_destroy.c \
 		pthread_attr_getdetachstate.c \
 		pthread_attr_setdetachstate.c \
 		pthread_attr_getstackaddr.c \
 		pthread_attr_setstackaddr.c \
 		pthread_attr_getstacksize.c \
 		pthread_attr_setstacksize.c \
 		pthread_attr_getscope.c \
 		pthread_attr_setscope.c
 BARRIER_SRCS = \
 		pthread_barrier_init.c \
 		pthread_barrier_destroy.c \
 		pthread_barrier_wait.c \
 		pthread_barrierattr_init.c \
 		pthread_barrierattr_destroy.c \
 		pthread_barrierattr_setpshared.c \
 		pthread_barrierattr_getpshared.c
 CANCEL_SRCS	= \
 		pthread_setcancelstate.c \
 		pthread_setcanceltype.c \
 		pthread_testcancel.c \
 		pthread_cancel.c 
 CONDVAR_SRCS	= \
 		ptw32_cond_check_need_init.c \
 		pthread_condattr_destroy.c \
 		pthread_condattr_getpshared.c \
 		pthread_condattr_init.c \
 		pthread_condattr_setpshared.c \
 		pthread_cond_destroy.c \
 		pthread_cond_init.c \
 		pthread_cond_signal.c \
 		pthread_cond_wait.c
 EXIT_SRCS	= \
 		pthread_exit.c
 MISC_SRCS	= \
 		pthread_equal.c \
 		pthread_getconcurrency.c \
 		pthread_once.c \
 		pthread_self.c \
 		pthread_setconcurrency.c \
 		ptw32_calloc.c \
 		ptw32_MCS_lock.c \
 		ptw32_new.c \
 		w32_CancelableWait.c
 MUTEX_SRCS	= \
 		ptw32_mutex_check_need_init.c \
 		pthread_mutex_init.c \
 		pthread_mutex_destroy.c \
 		pthread_mutexattr_init.c \
 		pthread_mutexattr_destroy.c \
 		pthread_mutexattr_getpshared.c \
 		pthread_mutexattr_setpshared.c \
 		pthread_mutexattr_settype.c \
 		pthread_mutexattr_gettype.c \
 		pthread_mutexattr_setrobust.c \
 		pthread_mutexattr_getrobust.c \
 		pthread_mutex_lock.c \
 		pthread_mutex_timedlock.c \
 		pthread_mutex_unlock.c \
 		pthread_mutex_trylock.c \
 		pthread_mutex_consistent.c
 NONPORTABLE_SRCS = \
 		pthread_mutexattr_setkind_np.c \
 		pthread_mutexattr_getkind_np.c \
 		pthread_getw32threadhandle_np.c \
 		pthread_delay_np.c \
 		pthread_num_processors_np.c \
 		pthread_win32_attach_detach_np.c \
 		pthread_timechange_handler_np.c 
 PRIVATE_SRCS	= \
 		ptw32_is_attr.c \
 		ptw32_processInitialize.c \
 		ptw32_processTerminate.c \
 		ptw32_threadStart.c \
 		ptw32_threadDestroy.c \
 		ptw32_tkAssocCreate.c \
 		ptw32_tkAssocDestroy.c \
 		ptw32_callUserDestroyRoutines.c \
 		ptw32_timespec.c \
 		ptw32_relmillisecs.c \
 		ptw32_throw.c \
 		ptw32_getprocessors.c
 RWLOCK_SRCS	= \
 		ptw32_rwlock_check_need_init.c \
 		ptw32_rwlock_cancelwrwait.c \
 		pthread_rwlock_init.c \
 		pthread_rwlock_destroy.c \
 		pthread_rwlockattr_init.c \
 		pthread_rwlockattr_destroy.c \
 		pthread_rwlockattr_getpshared.c \
 		pthread_rwlockattr_setpshared.c \
 		pthread_rwlock_rdlock.c \
 		pthread_rwlock_timedrdlock.c \
 		pthread_rwlock_wrlock.c \
 		pthread_rwlock_timedwrlock.c \
 		pthread_rwlock_unlock.c \
 		pthread_rwlock_tryrdlock.c \
 		pthread_rwlock_trywrlock.c
 SCHED_SRCS	= \
 		pthread_attr_setschedpolicy.c \
 		pthread_attr_getschedpolicy.c \
 		pthread_attr_setschedparam.c \
 		pthread_attr_getschedparam.c \
 		pthread_attr_setinheritsched.c \
 		pthread_attr_getinheritsched.c \
 		pthread_setschedparam.c \
 		pthread_getschedparam.c \
 		sched_get_priority_max.c \
 		sched_get_priority_min.c \
 		sched_setscheduler.c \
 		sched_getscheduler.c \
 		sched_yield.c
 SEMAPHORE_SRCS = \
 		sem_init.c \
 		sem_destroy.c \
 		sem_trywait.c \
 		sem_timedwait.c \
 		sem_wait.c \
 		sem_post.c \
 		sem_post_multiple.c \
 		sem_getvalue.c \
 		sem_open.c \
 		sem_close.c \
 		sem_unlink.c
 SPIN_SRCS	= \
 		ptw32_spinlock_check_need_init.c \
 		pthread_spin_init.c \
 		pthread_spin_destroy.c \
 		pthread_spin_lock.c \
 		pthread_spin_unlock.c \
 		pthread_spin_trylock.c
 SYNC_SRCS	= \
 		pthread_detach.c \
 		pthread_join.c
 TSD_SRCS	= \
 		pthread_key_create.c \
 		pthread_key_delete.c \
 		pthread_setspecific.c \
 		pthread_getspecific.c
 all: clean $(DLLS)
 realclean: clean
 	if exist pthread*.dll del pthread*.dll
 	if exist pthread*.lib del pthread*.lib
 	if exist *.stamp del *.stamp
 clean:
 	if exist *.obj del *.obj
 	if exist *.ilk del *.ilk
 	if exist *.ilc del *.ilc
 	if exist *.ild del *.ild
 	if exist *.ilf del *.ilf
 	if exist *.ils del *.ils
 	if exist *.tds del *.tds
 	if exist *.pdb del *.pdb
 	if exist *.exp del *.exp
 	if exist *.map del *.map
 	if exist *.o del *.o
 	if exist *.i del *.i
 	if exist *.res del *.res
 install: $(DLLS)
 	copy pthread*.dll $(DLLDEST)
 	copy pthread*.lib $(LIBDEST)
 $(DLLS): $(DLL_OBJS) version.res
 	ilink32 /Tpd /Gi c0d32x.obj $(DLL_OBJS), \
 		$@, ,\
 		cw32mti.lib import32.lib, ,\
 		version.res
 .c.obj:
 	$(CC) $(OPTIM) $(BCFLAGS) -c $<
 .rc.res:
 	$(RC) $(RCFLAGS) $<
 attr.obj:	attr.c $(ATTR_SRCS) $(INCL)
 barrier.obj:	barrier.c $(BARRIER_SRCS) $(INCL)
 cancel.obj:	cancel.c $(CANCEL_SRCS) $(INCL)
 condvar.obj:	condvar.c $(CONDVAR_SRCS) $(INCL)
 exit.obj:	exit.c $(EXIT_SRCS) $(INCL)
 misc.obj:	misc.c $(MISC_SRCS) $(INCL)
 mutex.obj:	mutex.c $(MUTEX_SRCS) $(INCL)
 nonportable.obj:	nonportable.c $(NONPORTABLE_SRCS) $(INCL)
 private.obj:	private.c $(PRIVATE_SRCS) $(INCL)
 rwlock.obj:	rwlock.c $(RWLOCK_SRCS) $(INCL)
 sched.obj:	sched.c $(SCHED_SRCS) $(INCL)
 semaphore.obj:	semaphore.c $(SEMAPHORE_SRCS) $(INCL)
 spin.obj:	spin.c $(SPIN_SRCS) $(INCL)
 sync.obj:	sync.c $(SYNC_SRCS) $(INCL)
 tsd.obj:	tsd.c $(TSD_SRCS) $(INCL)
 version.res:	version.rc $(INCL)
--- a/deps/uv/deps/pthread-win32/CONTRIBUTORS
+++ b/deps/uv/deps/pthread-win32/CONTRIBUTORS
@ -1,140 +0,0 @@
 Contributors (in approximate order of appearance)
 [See also the ChangeLog file where individuals are
 attributed in log entries. Likewise in the FAQ file.]
 Ben Elliston		bje at cygnus dot com
 					Initiated the project;
 					setup the project infrastructure (CVS, web page, etc.);
 					early prototype routines.
 Ross Johnson		Ross dot Johnson at  dot homemail dot com dot au
 					early prototype routines;
 					ongoing project coordination/maintenance;
 					implementation of spin locks and barriers;
 					various enhancements;
 					bug fixes;
 					documentation;
 					testsuite.
 Robert Colquhoun	rjc at trump dot net dot au
 					Early bug fixes.
 John E. Bossom		John dot Bossom at cognos dot com
 					Contributed substantial original working implementation;
 					bug fixes;
 					ongoing guidance and standards interpretation.
 Anders Norlander	anorland at hem2 dot passagen dot se
 					Early enhancements and runtime checking for supported
 					Win32 routines.
 Tor Lillqvist		tml at iki dot fi
 					General enhancements;
 					early bug fixes to condition variables.
 Scott Lightner		scott at curriculum dot com
 					Bug fix.
 Kevin Ruland		Kevin dot Ruland at anheuser-busch dot com
 					Various bug fixes.
 Mike Russo		miker at eai dot com
 					Bug fix.
 Mark E. Armstrong	avail at pacbell dot net
 					Bug fixes.
 Lorin Hochstein 	lmh at xiphos dot ca
 					general bug fixes; bug fixes to condition variables.
 Peter Slacik		Peter dot Slacik at tatramed dot sk
 					Bug fixes.
 Mumit Khan		khan at xraylith dot wisc dot edu
 					Fixes to work with Mingw32.
 Milan Gardian		mg at tatramed dot sk
 					Bug fixes and reports/analyses of obscure problems.
 Aurelio Medina		aureliom at crt dot com
 					First implementation of read-write locks.
 Graham Dumpleton	Graham dot Dumpleton at ra dot pad dot otc dot telstra dot com dot au
 					Bug fix in condition variables.
 Tristan Savatier	tristan at mpegtv dot com
 					WinCE port.
 Erik Hensema		erik at hensema dot xs4all dot nl
 					Bug fixes.
 Rich Peters		rpeters at micro-magic dot com
 Todd Owen		towen at lucidcalm dot dropbear dot id dot au
 					Bug fixes to dll loading.
 Jason Nye		jnye at nbnet dot nb dot ca
 					Implementation of async cancelation.
 Fred Forester		fforest at eticomm dot net
 Kevin D. Clark		kclark at cabletron dot com
 David Baggett		dmb at itasoftware dot com
 					Bug fixes.
 Paul Redondo		paul at matchvision dot com
 Scott McCaskill 	scott at 3dfx dot com
 					Bug fixes.
 Jef Gearhart		jgearhart at tpssys dot com
 					Bug fix.
 Arthur Kantor		akantor at bexusa dot com
 					Mutex enhancements.
 Steven Reddie		smr at essemer dot com dot au
 					Bug fix.
 Alexander Terekhov	TEREKHOV at de dot ibm dot com
 					Re-implemented and improved read-write locks;
 					(with Louis Thomas) re-implemented and improved
 					condition variables;
 					enhancements to semaphores;
 					enhancements to mutexes;
 					new mutex implementation in 'futex' style;
 					suggested a robust implementation of pthread_once
 					similar to that implemented by V.Kliathcko;
 					system clock change handling re CV timeouts;
 					bug fixes.
 Thomas Pfaff		tpfaff at gmx dot net
 					Changes to make C version usable with C++ applications;
 					re-implemented mutex routines to avoid Win32 mutexes
 					and TryEnterCriticalSection;
 					procedure to fix Mingw32 thread-safety issues.
 Franco Bez		franco dot bez at gmx dot de
 					procedure to fix Mingw32 thread-safety issues.
 Louis Thomas		lthomas at arbitrade dot com
 					(with Alexander Terekhov) re-implemented and improved
 					condition variables.
 David Korn		dgk at research dot att dot com
 					Ported to UWIN.
 Phil Frisbie, Jr.	phil at hawksoft dot com
 					Bug fix.
 Ralf Brese		Ralf dot Brese at pdb4 dot siemens dot de
 					Bug fix.
 prionx at juno dot com 	prionx at juno dot com
 					Bug fixes.
 Max Woodbury		mtew at cds dot duke dot edu
 					POSIX versioning conditionals;
 					reduced namespace pollution;
 					idea to separate routines to reduce statically
 					linked image sizes.
 Rob Fanner		rfanner at stonethree dot com
 					Bug fix.
 Michael Johnson 	michaelj at maine dot rr dot com
 					Bug fix.
 Nicolas Barry		boozai at yahoo dot com
 					Bug fixes.
 Piet van Bruggen	pietvb at newbridges dot nl
 					Bug fix.
 Makoto Kato		raven at oldskool dot jp
 					AMD64 port.
 Panagiotis E. Hadjidoukas	peh at hpclab dot ceid dot upatras dot gr
                                phadjido at cs dot uoi dot gr
 					Contributed the QueueUserAPCEx package which
 					makes preemptive async cancelation possible.
 Will Bryant		will dot bryant at ecosm dot com
 					Borland compiler patch and makefile.
 Anuj Goyal		anuj dot goyal at gmail dot com
 					Port to Digital Mars compiler.
 Gottlob Frege		gottlobfrege at  gmail dot com
 					re-implemented pthread_once (version 2)
 					(pthread_once cancellation added by rpj).
 Vladimir Kliatchko	vladimir at kliatchko dot com
 					reimplemented pthread_once with the same form
 					as described by A.Terekhov (later version 2);
 					implementation of MCS (Mellor-Crummey/Scott) locks.
 Ramiro Polla		ramiro.polla at gmail dot com
 					static library auto init/cleanup on application
 					start/exit via RT hooks (MSC and GCC compilers only).
 Daniel Richard G.			skunk at iSKUNK dot org
 					Patches and cleanups for x86 and x64, particularly
 					across a range of MS build environments.
 John Kamp		john dot kamp at globalgraphics dot com
 					Patches to fix various problems on x64; brutal testing
 					particularly using high memory run environments.
--- a/deps/uv/deps/pthread-win32/COPYING
+++ b/deps/uv/deps/pthread-win32/COPYING
@ -1,150 +0,0 @@
 	pthreads-win32 - a POSIX threads library for Microsoft Windows
 This file is Copyrighted
 ------------------------
    This file is covered under the following Copyright:
 	Copyright (C) 2001,2006 Ross P. Johnson
 	All rights reserved.
 	Everyone is permitted to copy and distribute verbatim copies
 	of this license document, but changing it is not allowed.
 Pthreads-win32 is covered by the GNU Lesser General Public License
 ------------------------------------------------------------------
    Pthreads-win32 is open software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public License
    as published by the Free Software Foundation version 2.1 of the
    License.
    Pthreads-win32 is several binary link libraries, several modules,
    associated interface definition files and scripts used to control
    its compilation and installation.
    Pthreads-win32 is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
    A copy of the GNU Lesser General Public License is distributed with
    pthreads-win32 under the filename:
 	    COPYING.LIB
    You should have received a copy of the version 2.1 GNU Lesser General
    Public License with pthreads-win32; if not, write to:
 	    Free Software Foundation, Inc.
 	    59 Temple Place
 	    Suite 330
 	    Boston, MA	02111-1307
 	    USA
    The contact addresses for pthreads-win32 is as follows:
        Web:	http://sources.redhat.com/pthreads-win32
        Email:  Ross Johnson
                Please use: Firstname.Lastname@homemail.com.au
 Pthreads-win32 copyrights and exception files
 ---------------------------------------------
    With the exception of the files listed below, Pthreads-win32
    is covered under the following GNU Lesser General Public License
    Copyrights:
 	Pthreads-win32 - POSIX Threads Library for Win32
 	Copyright(C) 1998 John E. Bossom
 	Copyright(C) 1999,2006 Pthreads-win32 contributors
 	The current list of contributors is contained
        in the file CONTRIBUTORS included with the source
 	code distribution. The current list of CONTRIBUTORS
 	can also be seen at the following WWW location:
        http://sources.redhat.com/pthreads-win32/contributors.html
    Contact Email: Ross Johnson
                   Please use: Firstname.Lastname@homemail.com.au
    These files are not covered under one of the Copyrights listed above:
            COPYING
 	    COPYING.LIB
            tests/rwlock7.c
    This file, COPYING, is distributed under the Copyright found at the
    top of this file.  It is important to note that you may distribute
    verbatim copies of this file but you may not modify this file.
    The file COPYING.LIB, which contains a copy of the version 2.1
    GNU Lesser General Public License, is itself copyrighted by the
    Free Software Foundation, Inc.  Please note that the Free Software
    Foundation, Inc. does NOT have a copyright over Pthreads-win32,
    only the COPYING.LIB that is supplied with pthreads-win32.
    The file tests/rwlock7.c is derived from code written by
    Dave Butenhof for his book 'Programming With POSIX(R) Threads'.
    The original code was obtained by free download from his website
    http://home.earthlink.net/~anneart/family/Threads/source.html
    and did not contain a copyright or author notice. It is assumed to
    be freely distributable.
    In all cases one may use and distribute these exception files freely.
    And because one may freely distribute the LGPL covered files, the
    entire pthreads-win32 source may be freely used and distributed.
 General Copyleft and License info
 ---------------------------------
    For general information on Copylefts, see:
 	http://www.gnu.org/copyleft/
    For information on GNU Lesser General Public Licenses, see:
 	http://www.gnu.org/copyleft/lesser.html
 	http://www.gnu.org/copyleft/lesser.txt
 Why pthreads-win32 did not use the GNU General Public License
 -------------------------------------------------------------
    The goal of the pthreads-win32 project has been to
    provide a quality and complete implementation of the POSIX
    threads API for Microsoft Windows within the limits imposed
    by virtue of it being a stand-alone library and not
    linked directly to other POSIX compliant libraries. For
    example, some functions and features, such as those based
    on POSIX signals, are missing.
    Pthreads-win32 is a library, available in several different
    versions depending on supported compilers, and may be used
    as a dynamically linked module or a statically linked set of
    binary modules. It is not an application on it's own.
    It was fully intended that pthreads-win32 be usable with
    commercial software not covered by either the GPL or the LGPL
    licenses. Pthreads-win32 has many contributors to it's
    code base, many of whom have done so because they have
    used the library in commercial or proprietry software
    projects.
    Releasing pthreads-win32 under the LGPL ensures that the
    library can be used widely, while at the same time ensures
    that bug fixes and improvements to the pthreads-win32 code
    itself is returned to benefit all current and future users
    of the library.
    Although pthreads-win32 makes it possible for applications
    that use POSIX threads to be ported to Win32 platforms, the
    broader goal of the project is to encourage the use of open
    standards, and in particular, to make it just a little easier
    for developers writing Win32 applications to consider
    widening the potential market for their products.
--- a/deps/uv/deps/pthread-win32/COPYING.LIB
+++ b/deps/uv/deps/pthread-win32/COPYING.LIB
@ -1,504 +0,0 @@
 		  GNU LESSER GENERAL PUBLIC LICENSE
 		       Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 Licenses are intended to guarantee your freedom to share and change
 free software--to make sure the software is free for all its users.
  This license, the Lesser General Public License, applies to some
 specially designated software packages--typically libraries--of the
 Free Software Foundation and other authors who decide to use it.  You
 can use it too, but we suggest you first think carefully about whether
 this license or the ordinary General Public License is the better
 strategy to use in any particular case, based on the explanations below.
  When we speak of free software, we are referring to freedom of use,
 not price.  Our General Public Licenses are designed to make sure that
 you have the freedom to distribute copies of free software (and charge
 for this service if you wish); that you receive source code or can get
 it if you want it; that you can change the software and use pieces of
 it in new free programs; and that you are informed that you can do
 these things.
  To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights.  These restrictions translate to certain responsibilities for
 you if you distribute copies of the library or if you modify it.
  For example, if you distribute copies of the library, whether gratis
 or for a fee, you must give the recipients all the rights that we gave
 you.  You must make sure that they, too, receive or can get the source
 code.  If you link other code with the library, you must provide
 complete object files to the recipients, so that they can relink them
 with the library after making changes to the library and recompiling
 it.  And you must show them these terms so they know their rights.
  We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
  To protect each distributor, we want to make it very clear that
 there is no warranty for the free library.  Also, if the library is
 modified by someone else and passed on, the recipients should know
 that what they have is not the original version, so that the original
 author's reputation will not be affected by problems that might be
 introduced by others.
  Finally, software patents pose a constant threat to the existence of
 any free program.  We wish to make sure that a company cannot
 effectively restrict the users of a free program by obtaining a
 restrictive license from a patent holder.  Therefore, we insist that
 any patent license obtained for a version of the library must be
 consistent with the full freedom of use specified in this license.
  Most GNU software, including some libraries, is covered by the
 ordinary GNU General Public License.  This license, the GNU Lesser
 General Public License, applies to certain designated libraries, and
 is quite different from the ordinary General Public License.  We use
 this license for certain libraries in order to permit linking those
 libraries into non-free programs.
  When a program is linked with a library, whether statically or using
 a shared library, the combination of the two is legally speaking a
 combined work, a derivative of the original library.  The ordinary
 General Public License therefore permits such linking only if the
 entire combination fits its criteria of freedom.  The Lesser General
 Public License permits more lax criteria for linking other code with
 the library.
  We call this license the "Lesser" General Public License because it
 does Less to protect the user's freedom than the ordinary General
 Public License.  It also provides other free software developers Less
 of an advantage over competing non-free programs.  These disadvantages
 are the reason we use the ordinary General Public License for many
 libraries.  However, the Lesser license provides advantages in certain
 special circumstances.
  For example, on rare occasions, there may be a special need to
 encourage the widest possible use of a certain library, so that it becomes
 a de-facto standard.  To achieve this, non-free programs must be
 allowed to use the library.  A more frequent case is that a free
 library does the same job as widely used non-free libraries.  In this
 case, there is little to gain by limiting the free library to free
 software only, so we use the Lesser General Public License.
  In other cases, permission to use a particular library in non-free
 programs enables a greater number of people to use a large body of
 free software.  For example, permission to use the GNU C Library in
 non-free programs enables many more people to use the whole GNU
 operating system, as well as its variant, the GNU/Linux operating
 system.
  Although the Lesser General Public License is Less protective of the
 users' freedom, it does ensure that the user of a program that is
 linked with the Library has the freedom and the wherewithal to run
 that program using a modified version of the Library.
  The precise terms and conditions for copying, distribution and
 modification follow.  Pay close attention to the difference between a
 "work based on the library" and a "work that uses the library".  The
 former contains code derived from the library, whereas the latter must
 be combined with the library in order to run.
 		  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License Agreement applies to any software library or other
 program which contains a notice placed by the copyright holder or
 other authorized party saying it may be distributed under the terms of
 this Lesser General Public License (also called "this License").
 Each licensee is addressed as "you".
  A "library" means a collection of software functions and/or data
 prepared so as to be conveniently linked with application programs
 (which use some of those functions and data) to form executables.
  The "Library", below, refers to any such software library or work
 which has been distributed under these terms.  A "work based on the
 Library" means either the Library or any derivative work under
 copyright law: that is to say, a work containing the Library or a
 portion of it, either verbatim or with modifications and/or translated
 straightforwardly into another language.  (Hereinafter, translation is
 included without limitation in the term "modification".)
  "Source code" for a work means the preferred form of the work for
 making modifications to it.  For a library, complete source code means
 all the source code for all modules it contains, plus any associated
 interface definition files, plus the scripts used to control compilation
 and installation of the library.
  Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running a program using the Library is not restricted, and output from
 such a program is covered only if its contents constitute a work based
 on the Library (independent of the use of the Library in a tool for
 writing it).  Whether that is true depends on what the Library does
 and what the program that uses the Library does.
  1. You may copy and distribute verbatim copies of the Library's
 complete source code as you receive it, in any medium, provided that
 you conspicuously and appropriately publish on each copy an
 appropriate copyright notice and disclaimer of warranty; keep intact
 all the notices that refer to this License and to the absence of any
 warranty; and distribute a copy of this License along with the
 Library.
  You may charge a fee for the physical act of transferring a copy,
 and you may at your option offer warranty protection in exchange for a
 fee.
  2. You may modify your copy or copies of the Library or any portion
 of it, thus forming a work based on the Library, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) The modified work must itself be a software library.
    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.
    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.
    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.
    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Library,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Library, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote
 it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Library.
 In addition, mere aggregation of another work not based on the Library
 with the Library (or with a work based on the Library) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may opt to apply the terms of the ordinary GNU General Public
 License instead of this License to a given copy of the Library.  To do
 this, you must alter all the notices that refer to this License, so
 that they refer to the ordinary GNU General Public License, version 2,
 instead of to this License.  (If a newer version than version 2 of the
 ordinary GNU General Public License has appeared, then you can specify
 that version instead if you wish.)  Do not make any other change in
 these notices.
  Once this change is made in a given copy, it is irreversible for
 that copy, so the ordinary GNU General Public License applies to all
 subsequent copies and derivative works made from that copy.
  This option is useful when you wish to copy part of the code of
 the Library into a program that is not a library.
  4. You may copy and distribute the Library (or a portion or
 derivative of it, under Section 2) in object code or executable form
 under the terms of Sections 1 and 2 above provided that you accompany
 it with the complete corresponding machine-readable source code, which
 must be distributed under the terms of Sections 1 and 2 above on a
 medium customarily used for software interchange.
  If distribution of object code is made by offering access to copy
 from a designated place, then offering equivalent access to copy the
 source code from the same place satisfies the requirement to
 distribute the source code, even though third parties are not
 compelled to copy the source along with the object code.
  5. A program that contains no derivative of any portion of the
 Library, but is designed to work with the Library by being compiled or
 linked with it, is called a "work that uses the Library".  Such a
 work, in isolation, is not a derivative work of the Library, and
 therefore falls outside the scope of this License.
  However, linking a "work that uses the Library" with the Library
 creates an executable that is a derivative of the Library (because it
 contains portions of the Library), rather than a "work that uses the
 library".  The executable is therefore covered by this License.
 Section 6 states terms for distribution of such executables.
  When a "work that uses the Library" uses material from a header file
 that is part of the Library, the object code for the work may be a
 derivative work of the Library even though the source code is not.
 Whether this is true is especially significant if the work can be
 linked without the Library, or if the work is itself a library.  The
 threshold for this to be true is not precisely defined by law.
  If such an object file uses only numerical parameters, data
 structure layouts and accessors, and small macros and small inline
 functions (ten lines or less in length), then the use of the object
 file is unrestricted, regardless of whether it is legally a derivative
 work.  (Executables containing this object code plus portions of the
 Library will still fall under Section 6.)
  Otherwise, if the work is a derivative of the Library, you may
 distribute the object code for the work under the terms of Section 6.
 Any executables containing that work also fall under Section 6,
 whether or not they are linked directly with the Library itself.
  6. As an exception to the Sections above, you may also combine or
 link a "work that uses the Library" with the Library to produce a
 work containing portions of the Library, and distribute that work
 under terms of your choice, provided that the terms permit
 modification of the work for the customer's own use and reverse
 engineering for debugging such modifications.
  You must give prominent notice with each copy of the work that the
 Library is used in it and that the Library and its use are covered by
 this License.  You must supply a copy of this License.  If the work
 during execution displays copyright notices, you must include the
 copyright notice for the Library among them, as well as a reference
 directing the user to the copy of this License.  Also, you must do one
 of these things:
    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)
    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.
    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.
    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.
    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.
  For an executable, the required form of the "work that uses the
 Library" must include any data and utility programs needed for
 reproducing the executable from it.  However, as a special exception,
 the materials to be distributed need not include anything that is
 normally distributed (in either source or binary form) with the major
 components (compiler, kernel, and so on) of the operating system on
 which the executable runs, unless that component itself accompanies
 the executable.
  It may happen that this requirement contradicts the license
 restrictions of other proprietary libraries that do not normally
 accompany the operating system.  Such a contradiction means you cannot
 use both them and the Library together in an executable that you
 distribute.
  7. You may place library facilities that are a work based on the
 Library side-by-side in a single library together with other library
 facilities not covered by this License, and distribute such a combined
 library, provided that the separate distribution of the work based on
 the Library and of the other library facilities is otherwise
 permitted, and provided that you do these two things:
    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.
    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.
  8. You may not copy, modify, sublicense, link with, or distribute
 the Library except as expressly provided under this License.  Any
 attempt otherwise to copy, modify, sublicense, link with, or
 distribute the Library is void, and will automatically terminate your
 rights under this License.  However, parties who have received copies,
 or rights, from you under this License will not have their licenses
 terminated so long as such parties remain in full compliance.
  9. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Library or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Library (or any work based on the
 Library), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Library or works based on it.
  10. Each time you redistribute the Library (or any work based on the
 Library), the recipient automatically receives a license from the
 original licensor to copy, distribute, link with or modify the Library
 subject to these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties with
 this License.
  11. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Library at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Library by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Library.
 If any portion of this section is held invalid or unenforceable under any
 particular circumstance, the balance of the section is intended to apply,
 and the section as a whole is intended to apply in other circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  12. If the distribution and/or use of the Library is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Library under this License may add
 an explicit geographical distribution limitation excluding those countries,
 so that distribution is permitted only in or among countries not thus
 excluded.  In such case, this License incorporates the limitation as if
 written in the body of this License.
  13. The Free Software Foundation may publish revised and/or new
 versions of the Lesser General Public License from time to time.
 Such new versions will be similar in spirit to the present version,
 but may differ in detail to address new problems or concerns.
 Each version is given a distinguishing version number.  If the Library
 specifies a version number of this License which applies to it and
 "any later version", you have the option of following the terms and
 conditions either of that version or of any later version published by
 the Free Software Foundation.  If the Library does not specify a
 license version number, you may choose any version ever published by
 the Free Software Foundation.
  14. If you wish to incorporate parts of the Library into other free
 programs whose distribution conditions are incompatible with these,
 write to the author to ask for permission.  For software which is
 copyrighted by the Free Software Foundation, write to the Free
 Software Foundation; we sometimes make exceptions for this.  Our
 decision will be guided by the two goals of preserving the free status
 of all derivatives of our free software and of promoting the sharing
 and reuse of software generally.
 			    NO WARRANTY
  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
 WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
 EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
 OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
 KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
 LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
 THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
 WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
 AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
 FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
 CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
 LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
 FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGES.
 		     END OF TERMS AND CONDITIONS
           How to Apply These Terms to Your New Libraries
  If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change.  You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
  To apply these terms, attach the following notices to the library.  It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
    <one line to give the library's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Also add information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
  <signature of Ty Coon>, 1 April 1990
  Ty Coon, President of Vice
 That's all there is to it!
--- a/deps/uv/deps/pthread-win32/ChangeLog
+++ b/deps/uv/deps/pthread-win32/ChangeLog
--- a/deps/uv/deps/pthread-win32/FAQ
+++ b/deps/uv/deps/pthread-win32/FAQ
@ -1,451 +0,0 @@
 		  =========================================
 		  PTHREADS-WIN32 Frequently Asked Questions
 		  =========================================
 INDEX
 -----
 Q 1	What is it?
 Q 2	Which of the several dll versions do I use?
 	or,
 	What are all these pthread*.dll and pthread*.lib files?
 Q 3	What is the library naming convention?
 Q 4	Cleanup code default style or: it used to work when I built
 	the library myself, but now it doesn't - why?
 Q 5	Why is the default library version now less exception-friendly?
 Q 6	Should I use Cygwin or Mingw32 as a development environment?
 Q 7	Now that pthreads-win32 builds under Mingw32, why do I get
 	memory access violations (segfaults)?
 Q 8	How do I use pthread.dll for Win32 (Visual C++ 5.0)
 Q 9	Cancelation doesn't work for me, why?
 Q 10	How do I generate pthreadGCE.dll and libpthreadw32.a for use
 	with Mingw32?
 Q 11    Why isn't pthread_t defined as a scalar (e.g. pointer or int)
        like it is for other POSIX threads implementations?
 =============================================================================
 Q 1	What is it?
 ---
 Pthreads-win32 is an Open Source Software implementation of the
 Threads component of the POSIX 1003.1c 1995 Standard for Microsoft's
 Win32 environment. Some functions from POSIX 1003.1b are also
 supported including semaphores. Other related functions include
 the set of read-write lock functions. The library also supports
 some of the functionality of the Open Group's Single Unix
 specification, version 2, namely mutex types.
 See the file "ANNOUNCE" for more information including standards
 conformance details and list of supported routines.
 ------------------------------------------------------------------------------
 Q 2	Which of the several dll versions do I use?
 ---	or,
 	What are all these pthread*.dll and pthread*.lib files?
 Simply, you only use one of them, but you need to choose carefully.
 The most important choice you need to make is whether to use a
 version that uses exceptions internally, or not (there are versions
 of the library that use exceptions as part of the thread
 cancelation and cleanup implementation, and one that uses
 setjmp/longjmp instead).
 There is some contension amongst POSIX threads experts as
 to how POSIX threads cancelation and exit should work
 with languages that include exceptions and handlers, e.g.
 C++ and even C (Microsoft's Structured Exceptions).
 The issue is: should cancelation of a thread in, say,
 a C++ application cause object destructors and C++ exception
 handlers to be invoked as the stack unwinds during thread
 exit, or not?
 There seems to be more opinion in favour of using the
 standard C version of the library (no EH) with C++ applications
 since this appears to be the assumption commercial pthreads
 implementations make. Therefore, if you use an EH version
 of pthreads-win32 then you may be under the illusion that
 your application will be portable, when in fact it is likely to
 behave very differently linked with other pthreads libraries.
 Now you may be asking: why have you kept the EH versions of
 the library?
 There are a couple of reasons:
 - there is division amongst the experts and so the code may
  be needed in the future. (Yes, it's in the repository and we
  can get it out anytime in the future, but ...)
 - pthreads-win32 is one of the few implementations, and possibly
  the only freely available one, that has EH versions. It may be
  useful to people who want to play with or study application
  behaviour under these conditions.
 ------------------------------------------------------------------------------
 Q 3	What is the library naming convention?
 ---
 Because the library is being built using various exception
 handling schemes and compilers - and because the library
 may not work reliably if these are mixed in an application,
 each different version of the library has it's own name.
 Note 1: the incompatibility is really between EH implementations
 of the different compilers. It should be possible to use the
 standard C version from either compiler with C++ applications
 built with a different compiler. If you use an EH version of
 the library, then you must use the same compiler for the
 application. This is another complication and dependency that
 can be avoided by using only the standard C library version.
 Note 2: if you use a standard C pthread*.dll with a C++
 application, then any functions that you define that are
 intended to be called via pthread_cleanup_push() must be
 __cdecl.
 Note 3: the intention is to also name either the VC or GC
 version (it should be arbitrary) as pthread.dll, including
 pthread.lib and libpthread.a as appropriate.
 In general:
 	pthread[VG]{SE,CE,C}.dll
 	pthread[VG]{SE,CE,C}.lib
 where:
 	[VG] indicates the compiler
 	V	- MS VC
 	G	- GNU C
 	{SE,CE,C} indicates the exception handling scheme
 	SE	- Structured EH
 	CE	- C++ EH
 	C	- no exceptions - uses setjmp/longjmp
 For example:
 	pthreadVSE.dll	(MSVC/SEH)
 	pthreadGCE.dll	(GNUC/C++ EH)
 	pthreadGC.dll	(GNUC/not dependent on exceptions)
 The GNU library archive file names have changed to:
 	libpthreadGCE.a
 	libpthreadGC.a
 ------------------------------------------------------------------------------
 Q 4	Cleanup code default style or: it used to work when I built
 ---	the library myself, but now it doesn't - why?
 Up to and including snapshot 2001-07-12, if not defined, the cleanup
 style was determined automatically from the compiler used, and one
 of the following was defined accordingly:
 	__CLEANUP_SEH	MSVC only
 	__CLEANUP_CXX	C++, including MSVC++, GNU G++
 	__CLEANUP_C		C, including GNU GCC, not MSVC
 These defines determine the style of cleanup (see pthread.h) and,
 most importantly, the way that cancelation and thread exit (via
 pthread_exit) is performed (see the routine ptw32_throw() in private.c).
 In short, the exceptions versions of the library throw an exception
 when a thread is canceled or exits (via pthread_exit()), which is
 caught by a handler in the thread startup routine, so that the
 the correct stack unwinding occurs regardless of where the thread
 is when it's canceled or exits via pthread_exit().
 After snapshot 2001-07-12, unless your build explicitly defines (e.g.
 via a compiler option) __CLEANUP_SEH, __CLEANUP_CXX, or __CLEANUP_C, then
 the build now ALWAYS defaults to __CLEANUP_C style cleanup. This style
 uses setjmp/longjmp in the cancelation and pthread_exit implementations,
 and therefore won't do stack unwinding even when linked to applications
 that have it (e.g. C++ apps). This is for consistency with most/all
 commercial Unix POSIX threads implementations.
 Although it was not clearly documented before, it is still necessary to
 build your application using the same __CLEANUP_* define as was
 used for the version of the library that you link with, so that the
 correct parts of pthread.h are included. That is, the possible
 defines require the following library versions:
 	__CLEANUP_SEH	pthreadVSE.dll
 	__CLEANUP_CXX	pthreadVCE.dll or pthreadGCE.dll
 	__CLEANUP_C		pthreadVC.dll or pthreadGC.dll
 THE POINT OF ALL THIS IS: if you have not been defining one of these
 explicitly, then the defaults have been set according to the compiler
 and language you are using, as described at the top of this
 section.
 THIS NOW CHANGES, as has been explained above. For example:
 If you were building your application with MSVC++ i.e. using C++
 exceptions (rather than SEH) and not explicitly defining one of
 __CLEANUP_*, then __CLEANUP_C++ was defined for you in pthread.h.
 You should have been linking with pthreadVCE.dll, which does
 stack unwinding.
 If you now build your application as you had before, pthread.h will now
 set __CLEANUP_C as the default style, and you will need to link
 with pthreadVC.dll. Stack unwinding will now NOT occur when a
 thread is canceled, nor when the thread calls pthread_exit().
 Your application will now most likely behave differently to previous
 versions, and in non-obvious ways. Most likely is that local
 objects may not be destroyed or cleaned up after a thread
 is canceled.
 If you want the same behaviour as before, then you must now define
 __CLEANUP_C++ explicitly using a compiler option and link with
 pthreadVCE.dll as you did before.
 ------------------------------------------------------------------------------
 Q 5	Why is the default library version now less exception-friendly?
 ---
 Because most commercial Unix POSIX threads implementations don't allow you to
 choose to have stack unwinding. (Compaq's TRU64 Unix is possibly an exception.)
 Therefore, providing it in pthread-win32 as a default could be dangerous
 and non-portable. We still provide the choice but you must now consciously
 make it.
 WHY NOT REMOVE THE EXCEPTIONS VERSIONS OF THE LIBRARY ALTOGETHER?
 There are a few reasons:
 - because there are well respected POSIX threads people who believe
  that POSIX threads implementations should be exceptions-aware and
  do the expected thing in that context. (There are equally respected
  people who believe it should not be easily accessible, if it's there
  at all.)
 - because pthreads-win32 is one of the few implementations that has
  the choice, perhaps the only freely available one, and so offers
  a laboratory to people who may want to explore the effects;
 - although the code will always be around somewhere for anyone who
  wants it, once it's removed from the current version it will not be
  nearly as visible to people who may have a use for it.
 ------------------------------------------------------------------------------
 Q 6	Should I use Cygwin or Mingw32 as a development environment?
 ---
 Important: see Q7 also.
 Use Mingw32 with the MSVCRT library to build applications that use
 the pthreads DLL.
 Cygwin's own internal support for POSIX threads is growing.
 Consult that project's documentation for more information.
 ------------------------------------------------------------------------------
 Q 7	Now that pthreads-win32 builds under Mingw32, why do I get
 ---	memory access violations (segfaults)?
 The latest Mingw32 package has thread-safe exception handling (see Q10).
 Also, see Q6 above.
 ------------------------------------------------------------------------------
 Q 8	How do I use pthread.dll for Win32 (Visual C++ 5.0)
 ---	
 >
 > I'm a "rookie" when it comes to your pthread implementation.	I'm currently
 > desperately trying to install the prebuilt .dll file into my MSVC compiler.
 > Could you please provide me with explicit instructions on how to do this (or
 > direct me to a resource(s) where I can acquire such information)?
 >
 > Thank you,
 >
 You should have a .dll, .lib, .def, and three .h files. It is recommended
 that you use pthreadVC.dll, rather than pthreadVCE.dll or pthreadVSE.dll
 (see Q2 above).
 The .dll can go in any directory listed in your PATH environment
 variable, so putting it into C:\WINDOWS should work.
 The .lib file can go in any directory listed in your LIB environment
 variable.
 The .h files can go in any directory listed in your INCLUDE
 environment variable.
 Or you might prefer to put the .lib and .h files into a new directory
 and add its path to LIB and INCLUDE. You can probably do this easiest
 by editing the file:-
 C:\Program Files\DevStudio\vc\bin\vcvars32.bat
 The .def file isn't used by anything in the pre-compiled version but 
 is included for information.
 Cheers.
 Ross
 ------------------------------------------------------------------------------
 Q 9	Cancelation doesn't work for me, why?
 ---
 > I'm investigating a problem regarding thread cancelation. The thread I want
 > to cancel has PTHREAD_CANCEL_ASYNCHRONOUS, however, this piece of code
 > blocks on the join():
 >
 >		if ((retv = Pthread_cancel( recvThread )) == 0)
 >		{
 >			retv = Pthread_join( recvThread, 0 );
 >		}
 >
 > Pthread_* are just macro's; they call pthread_*.
 >
 > The thread recvThread seems to block on a select() call. It doesn't get
 > cancelled.
 >
 > Two questions:
 >
 > 1) is this normal behaviour?
 >
 > 2) if not, how does the cancel mechanism work? I'm not very familliar to
 > win32 programming, so I don't really understand how the *Event() family of
 > calls work.
 The answer to your first question is, normal POSIX behaviour would  
 be to asynchronously cancel the thread. However, even that doesn't
 guarantee cancelation as the standard only says it should be
 cancelled as soon as possible.
 Snapshot 99-11-02 or earlier only partially supports asynchronous cancellation.
 Snapshots since then simulate async cancelation by poking the address of
 a cancelation routine into the PC of the threads context. This requires
 the thread to be resumed in some way for the cancelation to actually
 proceed. This is not true async cancelation, but it is as close as we've
 been able to get to it.
 If the thread you're trying to cancel is blocked (for instance, it could be
 waiting for data from the network), it will only get cancelled when it unblocks
 (when the data arrives). For true pre-emptive cancelation in these cases,
 pthreads-win32 from snapshot 2004-05-16 can automatically recognise and use the
 QueueUserAPCEx package by Panagiotis E. Hadjidoukas. This package is available
 from the pthreads-win32 ftp site and is included in the pthreads-win32
 self-unpacking zip from 2004-05-16 onwards.
 Using deferred cancelation would normally be the way to go, however,
 even though the POSIX threads standard lists a number of C library
 functions that are defined as deferred cancelation points, there is
 no hookup between those which are provided by Windows and the
 pthreads-win32 library.
 Incidently, it's worth noting for code portability that the older POSIX
 threads standards cancelation point lists didn't include "select" because
 (as I read in Butenhof) it wasn't part of POSIX. However, it does appear in
 the SUSV3.
 Effectively, the only mandatory cancelation points that pthreads-win32
 recognises are those the library implements itself, ie.
 	pthread_testcancel
 	pthread_cond_wait
 	pthread_cond_timedwait
 	pthread_join
 	sem_wait
 	sem_timedwait
 	pthread_delay_np
 The following routines from the non-mandatory list in SUSV3 are
 cancelation points in pthreads-win32:
 	pthread_rwlock_wrlock
 	pthread_rwlock_timedwrlock
 The following routines from the non-mandatory list in SUSV3 are not
 cancelation points in pthreads-win32:
 	pthread_rwlock_rdlock
 	pthread_rwlock_timedrdlock
 Pthreads-win32 also provides two functions that allow you to create
 cancelation points within your application, but only for cases where
 a thread is going to block on a Win32 handle. These are:
 	pthreadCancelableWait(HANDLE waitHandle) /* Infinite wait */
 	pthreadCancelableTimedWait(HANDLE waitHandle, DWORD timeout)
 ------------------------------------------------------------------------------
 Q 10	How do I create thread-safe applications using
 ----	pthreadGCE.dll, libpthreadw32.a and Mingw32?
 This should not be a problem with recent versions of MinGW32.
 For early versions, see Thomas Pfaff's email at:
 http://sources.redhat.com/ml/pthreads-win32/2002/msg00000.html
 ------------------------------------------------------------------------------
 Q 11    Why isn't pthread_t defined as a scalar (e.g. pointer or int)
        like it is for other POSIX threads implementations?
 ----
 Originally pthread_t was defined as a pointer (to the opaque pthread_t_
 struct) and later it was changed to a struct containing the original
 pointer plus a sequence counter. This is allowed under both the original
 POSIX Threads Standard and the current Single Unix Specification.
 When pthread_t is a simple pointer to a struct some very difficult to
 debug problems arise from the process of freeing and later allocing
 thread structs because new pthread_t handles can acquire the identity of
 previously detached threads. The change to a struct was made, along with
 some changes to their internal managment, in order to guarantee (for
 practical applications) that the pthread_t handle will be unique over the
 life of the running process.
 Where application code attempts to compare one pthread_t against another
 directly, a compiler error will be emitted because structs can't be
 compared at that level. This should signal a potentially serious problem
 in the code design, which would go undetected if pthread_t was a scalar.
 The POSIX Threading API provides a function named pthread_equal() to
 compare pthread_t thread handles.
 Other pthreads implementations, such as Sun's, use an int as the handle
 but do guarantee uniqueness within the process scope. Win32 scalar typed
 thread handles also guarantee uniqueness in system scope. It wasn't clear
 how well the internal management of these handles would scale as the
 number of threads and the fragmentation of the sequence numbering
 increased for applications where thousands or millions of threads are
 created and detached over time. The current management of threads within
 pthreads-win32 using structs for pthread_t, and reusing without ever
 freeing them, reduces the management time overheads to a constant, which
 could be important given that pthreads-win32 threads are built on top of
 Win32 threads and will therefore include that management overhead on top
 of their own. The cost is that the memory resources used for thread
 handles will remain at the peak level until the process exits.
 While it may be inconvenient for developers to be forced away from making
 assumptions about the internals of pthread_t, the advantage for the
 future development of pthread-win32, as well as those applications that
 use it and other pthread implementations, is that the library is free to
 change pthread_t internals and management as better methods arise.
--- a/deps/uv/deps/pthread-win32/GNUmakefile
+++ b/deps/uv/deps/pthread-win32/GNUmakefile
@ -1,593 +0,0 @@
 #
 # --------------------------------------------------------------------------
 #
 #      Pthreads-win32 - POSIX Threads Library for Win32
 #      Copyright(C) 1998 John E. Bossom
 #      Copyright(C) 1999,2005 Pthreads-win32 contributors
 # 
 #      Contact Email: rpj@callisto.canberra.edu.au
 # 
 #      The current list of contributors is contained
 #      in the file CONTRIBUTORS included with the source
 #      code distribution. The list can also be seen at the
 #      following World Wide Web location:
 #      http://sources.redhat.com/pthreads-win32/contributors.html
 # 
 #      This library is free software; you can redistribute it and/or
 #      modify it under the terms of the GNU Lesser General Public
 #      License as published by the Free Software Foundation; either
 #      version 2 of the License, or (at your option) any later version.
 # 
 #      This library is distributed in the hope that it will be useful,
 #      but WITHOUT ANY WARRANTY; without even the implied warranty of
 #      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 #      Lesser General Public License for more details.
 # 
 #      You should have received a copy of the GNU Lesser General Public
 #      License along with this library in the file COPYING.LIB;
 #      if not, write to the Free Software Foundation, Inc.,
 #      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 #
 DLL_VER	= 2
 DLL_VERD= $(DLL_VER)d
 DEVROOT	= C:\PTHREADS
 DLLDEST	= $(DEVROOT)\DLL
 LIBDEST	= $(DEVROOT)\DLL
 # If Running MsysDTK
 RM	= rm -f
 MV	= mv -f
 CP	= cp -f
 # If not.
 #RM	= erase
 #MV	= rename
 #CP	= copy
 # For cross compiling use e.g.
 # make CROSS=x86_64-w64-mingw32- clean GC-inlined
 CROSS	= 
 AR	= $(CROSS)ar
 DLLTOOL = $(CROSS)dlltool
 CC      = $(CROSS)gcc
 CXX     = $(CROSS)g++
 RANLIB  = $(CROSS)ranlib
 RC	= $(CROSS)windres
 OPT	= $(CLEANUP) -O3 # -finline-functions -findirect-inlining
 XOPT	=
 RCFLAGS		= --include-dir=.
 # Uncomment this if config.h defines RETAIN_WSALASTERROR
 #LFLAGS		= -lws2_32
 # ----------------------------------------------------------------------
 # The library can be built with some alternative behaviour to
 # facilitate development of applications on Win32 that will be ported
 # to other POSIX systems. Nothing definable here will make the library
 # non-compliant, but applications that make assumptions that POSIX
 # does not garrantee may fail or misbehave under some settings.
 #
 # PTW32_THREAD_ID_REUSE_INCREMENT
 # Purpose:
 # POSIX says that applications should assume that thread IDs can be
 # recycled. However, Solaris and some other systems use a [very large]
 # sequence number as the thread ID, which provides virtual uniqueness.
 # Pthreads-win32 provides pseudo-unique IDs when the default increment
 # (1) is used, but pthread_t is not a scalar type like Solaris's.
 #
 # Usage:
 # Set to any value in the range: 0 <= value <= 2^wordsize
 #
 # Examples:
 # Set to 0 to emulate non recycle-unique behaviour like Linux or *BSD.
 # Set to 1 for recycle-unique thread IDs (this is the default).
 # Set to some other +ve value to emulate smaller word size types
 # (i.e. will wrap sooner).
 #
 #PTW32_FLAGS	= "-DPTW32_THREAD_ID_REUSE_INCREMENT=0"
 #
 # ----------------------------------------------------------------------
 GC_CFLAGS	= $(PTW32_FLAGS) 
 GCE_CFLAGS	= $(PTW32_FLAGS) -mthreads
 ## Mingw32
 MAKE		?= make
 CFLAGS	= $(OPT) $(XOPT) -I. -DHAVE_PTW32_CONFIG_H -Wall
 DLL_INLINED_OBJS	= \
 		pthread.o \
 		version.o
 # Agregate modules for inlinability
 DLL_OBJS	= \
 		attr.o \
 		barrier.o \
 		cancel.o \
 		cleanup.o \
 		condvar.o \
 		create.o \
 		dll.o \
 		errno.o \
 		exit.o \
 		fork.o \
 		global.o \
 		misc.o \
 		mutex.o \
 		nonportable.o \
 		private.o \
 		rwlock.o \
 		sched.o \
 		semaphore.o \
 		signal.o \
 		spin.o \
 		sync.o \
 		tsd.o \
 		version.o
 # Separate modules for minimum size statically linked images
 SMALL_STATIC_OBJS	= \
 		pthread_attr_init.o \
 		pthread_attr_destroy.o \
 		pthread_attr_getdetachstate.o \
 		pthread_attr_setdetachstate.o \
 		pthread_attr_getstackaddr.o \
 		pthread_attr_setstackaddr.o \
 		pthread_attr_getstacksize.o \
 		pthread_attr_setstacksize.o \
 		pthread_attr_getscope.o \
 		pthread_attr_setscope.o \
 		pthread_attr_setschedpolicy.o \
 		pthread_attr_getschedpolicy.o \
 		pthread_attr_setschedparam.o \
 		pthread_attr_getschedparam.o \
 		pthread_attr_setinheritsched.o \
 		pthread_attr_getinheritsched.o \
 		pthread_barrier_init.o \
 		pthread_barrier_destroy.o \
 		pthread_barrier_wait.o \
 		pthread_barrierattr_init.o \
 		pthread_barrierattr_destroy.o \
 		pthread_barrierattr_setpshared.o \
 		pthread_barrierattr_getpshared.o \
 		pthread_setcancelstate.o \
 		pthread_setcanceltype.o \
 		pthread_testcancel.o \
 		pthread_cancel.o \
 		cleanup.o \
 		pthread_condattr_destroy.o \
 		pthread_condattr_getpshared.o \
 		pthread_condattr_init.o \
 		pthread_condattr_setpshared.o \
 		pthread_cond_destroy.o \
 		pthread_cond_init.o \
 		pthread_cond_signal.o \
 		pthread_cond_wait.o \
 		create.o \
 		dll.o \
 		autostatic.o \
 		errno.o \
 		pthread_exit.o \
 		fork.o \
 		global.o \
 		pthread_mutex_init.o \
 		pthread_mutex_destroy.o \
 		pthread_mutexattr_init.o \
 		pthread_mutexattr_destroy.o \
 		pthread_mutexattr_getpshared.o \
 		pthread_mutexattr_setpshared.o \
 		pthread_mutexattr_settype.o \
 		pthread_mutexattr_gettype.o \
 		pthread_mutexattr_setrobust.o \
 		pthread_mutexattr_getrobust.o \
 		pthread_mutex_lock.o \
 		pthread_mutex_timedlock.o \
 		pthread_mutex_unlock.o \
 		pthread_mutex_trylock.o \
 		pthread_mutex_consistent.o \
 		pthread_mutexattr_setkind_np.o \
 		pthread_mutexattr_getkind_np.o \
 		pthread_getw32threadhandle_np.o \
 		pthread_getunique_np.o \
 		pthread_delay_np.o \
 		pthread_num_processors_np.o \
 		pthread_win32_attach_detach_np.o \
 		pthread_equal.o \
 		pthread_getconcurrency.o \
 		pthread_once.o \
 		pthread_self.o \
 		pthread_setconcurrency.o \
 		pthread_rwlock_init.o \
 		pthread_rwlock_destroy.o \
 		pthread_rwlockattr_init.o \
 		pthread_rwlockattr_destroy.o \
 		pthread_rwlockattr_getpshared.o \
 		pthread_rwlockattr_setpshared.o \
 		pthread_rwlock_rdlock.o \
 		pthread_rwlock_wrlock.o \
 		pthread_rwlock_unlock.o \
 		pthread_rwlock_tryrdlock.o \
 		pthread_rwlock_trywrlock.o \
 		pthread_setschedparam.o \
 		pthread_getschedparam.o \
 		pthread_timechange_handler_np.o \
 		ptw32_is_attr.o \
 		ptw32_cond_check_need_init.o \
 		ptw32_MCS_lock.o \
 		ptw32_mutex_check_need_init.o \
 		ptw32_processInitialize.o \
 		ptw32_processTerminate.o \
 		ptw32_threadStart.o \
 		ptw32_threadDestroy.o \
 		ptw32_tkAssocCreate.o \
 		ptw32_tkAssocDestroy.o \
 		ptw32_callUserDestroyRoutines.o \
 		ptw32_timespec.o \
 		ptw32_throw.o \
 		ptw32_getprocessors.o \
 		ptw32_calloc.o \
 		ptw32_new.o \
 		ptw32_reuse.o \
 		ptw32_semwait.o \
 		ptw32_relmillisecs.o \
 		ptw32_rwlock_check_need_init.o \
 		sched_get_priority_max.o \
 		sched_get_priority_min.o \
 		sched_setscheduler.o \
 		sched_getscheduler.o \
 		sched_yield.o \
 		sem_init.o \
 		sem_destroy.o \
 		sem_trywait.o \
 		sem_timedwait.o \
 		sem_wait.o \
 		sem_post.o \
 		sem_post_multiple.o \
 		sem_getvalue.o \
 		sem_open.o \
 		sem_close.o \
 		sem_unlink.o \
 		signal.o \
 		pthread_kill.o \
 		ptw32_spinlock_check_need_init.o \
 		pthread_spin_init.o \
 		pthread_spin_destroy.o \
 		pthread_spin_lock.o \
 		pthread_spin_unlock.o \
 		pthread_spin_trylock.o \
 		pthread_detach.o \
 		pthread_join.o \
 		pthread_key_create.o \
 		pthread_key_delete.o \
 		pthread_setspecific.o \
 		pthread_getspecific.o \
 		w32_CancelableWait.o \
 		version.o
 INCL	= \
 		config.h \
 		implement.h \
 		semaphore.h \
 		pthread.h \
 		need_errno.h
 ATTR_SRCS	= \
 		pthread_attr_init.c \
 		pthread_attr_destroy.c \
 		pthread_attr_getdetachstate.c \
 		pthread_attr_setdetachstate.c \
 		pthread_attr_getstackaddr.c \
 		pthread_attr_setstackaddr.c \
 		pthread_attr_getstacksize.c \
 		pthread_attr_setstacksize.c \
 		pthread_attr_getscope.c \
 		pthread_attr_setscope.c
 BARRIER_SRCS = \
 		pthread_barrier_init.c \
 		pthread_barrier_destroy.c \
 		pthread_barrier_wait.c \
 		pthread_barrierattr_init.c \
 		pthread_barrierattr_destroy.c \
 		pthread_barrierattr_setpshared.c \
 		pthread_barrierattr_getpshared.c
 CANCEL_SRCS	= \
 		pthread_setcancelstate.c \
 		pthread_setcanceltype.c \
 		pthread_testcancel.c \
 		pthread_cancel.c 
 CONDVAR_SRCS	= \
 		ptw32_cond_check_need_init.c \
 		pthread_condattr_destroy.c \
 		pthread_condattr_getpshared.c \
 		pthread_condattr_init.c \
 		pthread_condattr_setpshared.c \
 		pthread_cond_destroy.c \
 		pthread_cond_init.c \
 		pthread_cond_signal.c \
 		pthread_cond_wait.c
 EXIT_SRCS	= \
 		pthread_exit.c
 MISC_SRCS	= \
 		pthread_equal.c \
 		pthread_getconcurrency.c \
 		pthread_kill.c \
 		pthread_once.c \
 		pthread_self.c \
 		pthread_setconcurrency.c \
 		ptw32_calloc.c \
 		ptw32_MCS_lock.c \
 		ptw32_new.c \
 		ptw32_reuse.c \
 		w32_CancelableWait.c
 MUTEX_SRCS	= \
 		ptw32_mutex_check_need_init.c \
 		pthread_mutex_init.c \
 		pthread_mutex_destroy.c \
 		pthread_mutexattr_init.c \
 		pthread_mutexattr_destroy.c \
 		pthread_mutexattr_getpshared.c \
 		pthread_mutexattr_setpshared.c \
 		pthread_mutexattr_settype.c \
 		pthread_mutexattr_gettype.c \
 		pthread_mutexattr_setrobust.c \
 		pthread_mutexattr_getrobust.c \
 		pthread_mutex_lock.c \
 		pthread_mutex_timedlock.c \
 		pthread_mutex_unlock.c \
 		pthread_mutex_trylock.c \
 		pthread_mutex_consistent.c
 NONPORTABLE_SRCS = \
 		pthread_mutexattr_setkind_np.c \
 		pthread_mutexattr_getkind_np.c \
 		pthread_getw32threadhandle_np.c \
                pthread_getunique_np.c \
 		pthread_delay_np.c \
 		pthread_num_processors_np.c \
 		pthread_win32_attach_detach_np.c \
 		pthread_timechange_handler_np.c 
 PRIVATE_SRCS	= \
 		ptw32_is_attr.c \
 		ptw32_processInitialize.c \
 		ptw32_processTerminate.c \
 		ptw32_threadStart.c \
 		ptw32_threadDestroy.c \
 		ptw32_tkAssocCreate.c \
 		ptw32_tkAssocDestroy.c \
 		ptw32_callUserDestroyRoutines.c \
 		ptw32_semwait.c \
 		ptw32_relmillisecs.c \
 		ptw32_timespec.c \
 		ptw32_throw.c \
 		ptw32_getprocessors.c
 RWLOCK_SRCS	= \
 		ptw32_rwlock_check_need_init.c \
 		ptw32_rwlock_cancelwrwait.c \
 		pthread_rwlock_init.c \
 		pthread_rwlock_destroy.c \
 		pthread_rwlockattr_init.c \
 		pthread_rwlockattr_destroy.c \
 		pthread_rwlockattr_getpshared.c \
 		pthread_rwlockattr_setpshared.c \
 		pthread_rwlock_rdlock.c \
 		pthread_rwlock_timedrdlock.c \
 		pthread_rwlock_wrlock.c \
 		pthread_rwlock_timedwrlock.c \
 		pthread_rwlock_unlock.c \
 		pthread_rwlock_tryrdlock.c \
 		pthread_rwlock_trywrlock.c
 SCHED_SRCS	= \
 		pthread_attr_setschedpolicy.c \
 		pthread_attr_getschedpolicy.c \
 		pthread_attr_setschedparam.c \
 		pthread_attr_getschedparam.c \
 		pthread_attr_setinheritsched.c \
 		pthread_attr_getinheritsched.c \
 		pthread_setschedparam.c \
 		pthread_getschedparam.c \
 		sched_get_priority_max.c \
 		sched_get_priority_min.c \
 		sched_setscheduler.c \
 		sched_getscheduler.c \
 		sched_yield.c
 SEMAPHORE_SRCS = \
 		sem_init.c \
 		sem_destroy.c \
 		sem_trywait.c \
 		sem_timedwait.c \
 		sem_wait.c \
 		sem_post.c \
 		sem_post_multiple.c \
 		sem_getvalue.c \
 		sem_open.c \
 		sem_close.c \
 		sem_unlink.c
 SPIN_SRCS	= \
 		ptw32_spinlock_check_need_init.c \
 		pthread_spin_init.c \
 		pthread_spin_destroy.c \
 		pthread_spin_lock.c \
 		pthread_spin_unlock.c \
 		pthread_spin_trylock.c
 SYNC_SRCS	= \
 		pthread_detach.c \
 		pthread_join.c
 TSD_SRCS	= \
 		pthread_key_create.c \
 		pthread_key_delete.c \
 		pthread_setspecific.c \
 		pthread_getspecific.c
 GCE_DLL	= pthreadGCE$(DLL_VER).dll
 GCED_DLL= pthreadGCE$(DLL_VERD).dll
 GCE_LIB	= libpthreadGCE$(DLL_VER).a
 GCED_LIB= libpthreadGCE$(DLL_VERD).a
 GCE_INLINED_STAMP = pthreadGCE$(DLL_VER).stamp
 GCED_INLINED_STAMP = pthreadGCE$(DLL_VERD).stamp
 GCE_STATIC_STAMP = libpthreadGCE$(DLL_VER).stamp
 GCED_STATIC_STAMP = libpthreadGCE$(DLL_VERD).stamp
 GC_DLL 	= pthreadGC$(DLL_VER).dll
 GCD_DLL	= pthreadGC$(DLL_VERD).dll
 GC_LIB	= libpthreadGC$(DLL_VER).a
 GCD_LIB	= libpthreadGC$(DLL_VERD).a
 GC_INLINED_STAMP = pthreadGC$(DLL_VER).stamp
 GCD_INLINED_STAMP = pthreadGC$(DLL_VERD).stamp
 GC_STATIC_STAMP = libpthreadGC$(DLL_VER).stamp
 GCD_STATIC_STAMP = libpthreadGC$(DLL_VERD).stamp
 PTHREAD_DEF	= pthread.def
 help:
 	@ echo "Run one of the following command lines:"
 	@ echo "make clean GC            (to build the GNU C dll with C cleanup code)"
 	@ echo "make clean GCE           (to build the GNU C dll with C++ exception handling)"
 	@ echo "make clean GC-inlined    (to build the GNU C inlined dll with C cleanup code)"
 	@ echo "make clean GCE-inlined   (to build the GNU C inlined dll with C++ exception handling)"
 	@ echo "make clean GC-static     (to build the GNU C inlined static lib with C cleanup code)"
 	@ echo "make clean GC-debug      (to build the GNU C debug dll with C cleanup code)"
 	@ echo "make clean GCE-debug     (to build the GNU C debug dll with C++ exception handling)"
 	@ echo "make clean GC-inlined-debug    (to build the GNU C inlined debug dll with C cleanup code)"
 	@ echo "make clean GCE-inlined-debug   (to build the GNU C inlined debug dll with C++ exception handling)"
 	@ echo "make clean GC-static-debug     (to build the GNU C inlined static debug lib with C cleanup code)"
 all:
 	@ $(MAKE) clean GCE
 	@ $(MAKE) clean GC
 GC:
 		$(MAKE) CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_OBJS)" $(GC_DLL)
 GC-debug:
 		$(MAKE) CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_C -g -O0" $(GCD_DLL)
 GCE:
 		$(MAKE) CC=$(CXX) CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_OBJS)" $(GCE_DLL)
 GCE-debug:
 		$(MAKE) CC=$(CXX) CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_CXX -g -O0" $(GCED_DLL)
 GC-inlined:
 		$(MAKE) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" $(GC_INLINED_STAMP)
 GC-inlined-debug:
 		$(MAKE) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_C -g -O0" $(GCD_INLINED_STAMP)
 GCE-inlined:
 		$(MAKE) CC=$(CXX) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" $(GCE_INLINED_STAMP)
 GCE-inlined-debug:
 		$(MAKE) CC=$(CXX) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_CXX -g -O0" $(GCED_INLINED_STAMP)
 GC-static:
 		$(MAKE) XOPT="-DPTW32_BUILD_INLINED -DPTW32_STATIC_LIB" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" $(GC_STATIC_STAMP)
 GC-static-debug:
 		$(MAKE) XOPT="-DPTW32_BUILD_INLINED -DPTW32_STATIC_LIB" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_C -g -O0" $(GCD_STATIC_STAMP)
 tests:
 	@ cd tests
 	@ $(MAKE) auto
 %.pre: %.c
 	$(CC) -E -o $@ $(CFLAGS) $^
 %.s: %.c
 	$(CC) -c $(CFLAGS) -DPTW32_BUILD_INLINED -Wa,-ahl $^ > $@
 %.o: %.rc
 	$(RC) $(RCFLAGS) $(CLEANUP) -o $@ $<
 .SUFFIXES: .dll .rc .c .o
 .c.o:;		 $(CC) -c -o $@ $(CFLAGS) $(XC_FLAGS) $<
 $(GC_DLL) $(GCD_DLL): $(DLL_OBJS)
 	$(CC) $(OPT) -shared -o $(GC_DLL) $(DLL_OBJS) $(LFLAGS)
 	$(DLLTOOL) -z pthread.def $(DLL_OBJS)
 	$(DLLTOOL) -k --dllname $@ --output-lib $(GC_LIB) --def $(PTHREAD_DEF)
 $(GCE_DLL): $(DLL_OBJS)
 	$(CC) $(OPT) -mthreads -shared -o $(GCE_DLL) $(DLL_OBJS) $(LFLAGS)
 	$(DLLTOOL) -z pthread.def $(DLL_OBJS)
 	$(DLLTOOL) -k --dllname $@ --output-lib $(GCE_LIB) --def $(PTHREAD_DEF)
 $(GC_INLINED_STAMP) $(GCD_INLINED_STAMP): $(DLL_INLINED_OBJS)
 	$(CC) $(OPT) $(XOPT) -shared -o $(GC_DLL) $(DLL_INLINED_OBJS) $(LFLAGS)
 	$(DLLTOOL) -z pthread.def $(DLL_INLINED_OBJS)
 	$(DLLTOOL) -k --dllname $(GC_DLL) --output-lib $(GC_LIB) --def $(PTHREAD_DEF)
 	echo touched > $(GC_INLINED_STAMP)
 $(GCE_INLINED_STAMP) $(GCED_INLINED_STAMP): $(DLL_INLINED_OBJS)
 	$(CC) $(OPT) $(XOPT) -mthreads -shared -o $(GCE_DLL) $(DLL_INLINED_OBJS)  $(LFLAGS)
 	$(DLLTOOL) -z pthread.def $(DLL_INLINED_OBJS)
 	$(DLLTOOL) -k --dllname $(GCE_DLL) --output-lib $(GCE_LIB) --def $(PTHREAD_DEF)
 	echo touched > $(GCE_INLINED_STAMP)
 $(GC_STATIC_STAMP) $(GCD_STATIC_STAMP): $(DLL_INLINED_OBJS)
 	$(RM) $(GC_LIB)
 	$(AR) -rv $(GC_LIB) $(DLL_INLINED_OBJS)
 	$(RANLIB) $(GC_LIB)
 	echo touched > $(GC_STATIC_STAMP)
 clean:
 	-$(RM) *~
 	-$(RM) *.i
 	-$(RM) *.s
 	-$(RM) *.o
 	-$(RM) *.obj
 	-$(RM) *.exe
 	-$(RM) $(PTHREAD_DEF)
 realclean: clean
 	-$(RM) $(GC_LIB)
 	-$(RM) $(GCE_LIB)
 	-$(RM) $(GC_DLL)
 	-$(RM) $(GCE_DLL)
 	-$(RM) $(GC_INLINED_STAMP)
 	-$(RM) $(GCE_INLINED_STAMP)
 	-$(RM) $(GC_STATIC_STAMP)
 	-$(RM) $(GCD_LIB)
 	-$(RM) $(GCED_LIB)
 	-$(RM) $(GCD_DLL)
 	-$(RM) $(GCED_DLL)
 	-$(RM) $(GCD_INLINED_STAMP)
 	-$(RM) $(GCED_INLINED_STAMP)
 	-$(RM) $(GCD_STATIC_STAMP)
 attr.o:		attr.c $(ATTR_SRCS) $(INCL)
 barrier.o:	barrier.c $(BARRIER_SRCS) $(INCL)
 cancel.o:	cancel.c $(CANCEL_SRCS) $(INCL)
 condvar.o:	condvar.c $(CONDVAR_SRCS) $(INCL)
 exit.o:		exit.c $(EXIT_SRCS) $(INCL)
 misc.o:		misc.c $(MISC_SRCS) $(INCL)
 mutex.o:	mutex.c $(MUTEX_SRCS) $(INCL)
 nonportable.o:	nonportable.c $(NONPORTABLE_SRCS) $(INCL)
 private.o:	private.c $(PRIVATE_SRCS) $(INCL)
 rwlock.o:	rwlock.c $(RWLOCK_SRCS) $(INCL)
 sched.o:	sched.c $(SCHED_SRCS) $(INCL)
 semaphore.o:	semaphore.c $(SEMAPHORE_SRCS) $(INCL)
 spin.o:		spin.c $(SPIN_SRCS) $(INCL)
 sync.o:		sync.c $(SYNC_SRCS) $(INCL)
 tsd.o:		tsd.c $(TSD_SRCS) $(INCL)
 version.o:	version.rc $(INCL)
--- a/deps/uv/deps/pthread-win32/MAINTAINERS
+++ b/deps/uv/deps/pthread-win32/MAINTAINERS
@ -1,4 +0,0 @@
 CVS Repository maintainers
 Ross Johnson		rpj@ise.canberra.edu.au
 Ben Elliston		bje@cygnus.com
--- a/deps/uv/deps/pthread-win32/Makefile
+++ b/deps/uv/deps/pthread-win32/Makefile
@ -1,516 +0,0 @@
 # This makefile is compatible with MS nmake and can be used as a
 # replacement for buildlib.bat. I've changed the target from an ordinary dll
 # (/LD) to a debugging dll (/LDd).
 # 
 # The variables $DLLDEST and $LIBDEST hold the destination directories for the
 # dll and the lib, respectively. Probably all that needs to change is $DEVROOT.
 # DLL_VER:
 # See pthread.h and README - This number is computed as 'current - age'
 DLL_VER	= 2
 DLL_VERD= $(DLL_VER)d
 DEVROOT	= C:\pthreads
 DLLDEST	= $(DEVROOT)\dll
 LIBDEST	= $(DEVROOT)\lib
 HDRDEST	= $(DEVROOT)\include
 DLLS	= pthreadVCE$(DLL_VER).dll pthreadVSE$(DLL_VER).dll pthreadVC$(DLL_VER).dll \
 		  pthreadVCE$(DLL_VERD).dll pthreadVSE$(DLL_VERD).dll pthreadVC$(DLL_VERD).dll
 INLINED_STAMPS	= pthreadVCE$(DLL_VER).stamp pthreadVSE$(DLL_VER).stamp pthreadVC$(DLL_VER).stamp \
 				  pthreadVCE$(DLL_VERD).stamp pthreadVSE$(DLL_VERD).stamp pthreadVC$(DLL_VERD).stamp
 STATIC_STAMPS	= pthreadVCE$(DLL_VER).static pthreadVSE$(DLL_VER).static pthreadVC$(DLL_VER).static \
 				  pthreadVCE$(DLL_VERD).static pthreadVSE$(DLL_VERD).static pthreadVC$(DLL_VERD).static
 CC	= cl
 CPPFLAGS = /I. /DHAVE_PTW32_CONFIG_H
 STATICCRT  = /MT
 STATICCRTD = /MTd
 DLLCRT     = /MD
 DLLCRTD    = /MDd
 XCFLAGS = /W3 /nologo
 CFLAGS	= /O2 /Ob2 $(XCFLAGS)
 CFLAGSD	= /Z7 $(XCFLAGS)
 # Uncomment this if config.h defines RETAIN_WSALASTERROR
 #XLIBS = wsock32.lib
 # Default cleanup style
 CLEANUP	= __CLEANUP_C
 # C++ Exceptions
 VCEFLAGS	= /EHsc /TP $(CPPFLAGS) $(CFLAGS)
 VCEFLAGSD	= /EHsc /TP $(CPPFLAGS) $(CFLAGSD)
 #Structured Exceptions
 VSEFLAGS	= $(CPPFLAGS) $(CFLAGS)
 VSEFLAGSD	= $(CPPFLAGS) $(CFLAGSD)
 #C cleanup code
 VCFLAGS		= $(CPPFLAGS) $(CFLAGS)
 VCFLAGSD	= $(CPPFLAGS) $(CFLAGSD)
 DLL_INLINED_OBJS = \
 		pthread.obj \
 		version.res
 # Aggregate modules for inlinability
 DLL_OBJS	= \
 		attr.obj \
 		barrier.obj \
 		cancel.obj \
 		cleanup.obj \
 		condvar.obj \
 		create.obj \
 		dll.obj \
 		autostatic.obj \
 		errno.obj \
 		exit.obj \
 		fork.obj \
 		global.obj \
 		misc.obj \
 		mutex.obj \
 		nonportable.obj \
 		private.obj \
 		rwlock.obj \
 		sched.obj \
 		semaphore.obj \
 		signal.obj \
 		spin.obj \
 		sync.obj \
 		tsd.obj \
 		version.res
 # Separate modules for minimising the size of statically linked images
 SMALL_STATIC_OBJS	= \
 		pthread_attr_init.obj \
 		pthread_attr_destroy.obj \
 		pthread_attr_getdetachstate.obj \
 		pthread_attr_setdetachstate.obj \
 		pthread_attr_getstackaddr.obj \
 		pthread_attr_setstackaddr.obj \
 		pthread_attr_getstacksize.obj \
 		pthread_attr_setstacksize.obj \
 		pthread_attr_getscope.obj \
 		pthread_attr_setscope.obj \
 		pthread_attr_setschedpolicy.obj \
 		pthread_attr_getschedpolicy.obj \
 		pthread_attr_setschedparam.obj \
 		pthread_attr_getschedparam.obj \
 		pthread_attr_setinheritsched.obj \
 		pthread_attr_getinheritsched.obj \
 		pthread_barrier_init.obj \
 		pthread_barrier_destroy.obj \
 		pthread_barrier_wait.obj \
 		pthread_barrierattr_init.obj \
 		pthread_barrierattr_destroy.obj \
 		pthread_barrierattr_setpshared.obj \
 		pthread_barrierattr_getpshared.obj \
 		pthread_setcancelstate.obj \
 		pthread_setcanceltype.obj \
 		pthread_testcancel.obj \
 		pthread_cancel.obj \
 		cleanup.obj \
 		pthread_condattr_destroy.obj \
 		pthread_condattr_getpshared.obj \
 		pthread_condattr_init.obj \
 		pthread_condattr_setpshared.obj \
 		pthread_cond_destroy.obj \
 		pthread_cond_init.obj \
 		pthread_cond_signal.obj \
 		pthread_cond_wait.obj \
 		create.obj \
 		dll.obj \
 		autostatic.obj \
 		errno.obj \
 		pthread_exit.obj \
 		fork.obj \
 		global.obj \
 		pthread_mutex_init.obj \
 		pthread_mutex_destroy.obj \
 		pthread_mutexattr_init.obj \
 		pthread_mutexattr_destroy.obj \
 		pthread_mutexattr_getpshared.obj \
 		pthread_mutexattr_setpshared.obj \
 		pthread_mutexattr_settype.obj \
 		pthread_mutexattr_gettype.obj \
 		pthread_mutexattr_setrobust.obj \
 		pthread_mutexattr_getrobust.obj \
 		pthread_mutex_lock.obj \
 		pthread_mutex_timedlock.obj \
 		pthread_mutex_unlock.obj \
 		pthread_mutex_trylock.obj \
 		pthread_mutex_consistent.obj \
 		pthread_mutexattr_setkind_np.obj \
 		pthread_mutexattr_getkind_np.obj \
 		pthread_getw32threadhandle_np.obj \
 		pthread_getunique_np.obj \
 		pthread_delay_np.obj \
 		pthread_num_processors_np.obj \
 		pthread_win32_attach_detach_np.obj \
 		pthread_equal.obj \
 		pthread_getconcurrency.obj \
 		pthread_once.obj \
 		pthread_self.obj \
 		pthread_setconcurrency.obj \
 		pthread_rwlock_init.obj \
 		pthread_rwlock_destroy.obj \
 		pthread_rwlockattr_init.obj \
 		pthread_rwlockattr_destroy.obj \
 		pthread_rwlockattr_getpshared.obj \
 		pthread_rwlockattr_setpshared.obj \
 		pthread_rwlock_rdlock.obj \
 		pthread_rwlock_wrlock.obj \
 		pthread_rwlock_unlock.obj \
 		pthread_rwlock_tryrdlock.obj \
 		pthread_rwlock_trywrlock.obj \
 		pthread_setschedparam.obj \
 		pthread_getschedparam.obj \
 		pthread_timechange_handler_np.obj \
 		ptw32_is_attr.obj \
 		ptw32_processInitialize.obj \
 		ptw32_processTerminate.obj \
 		ptw32_threadStart.obj \
 		ptw32_threadDestroy.obj \
 		ptw32_tkAssocCreate.obj \
 		ptw32_tkAssocDestroy.obj \
 		ptw32_callUserDestroyRoutines.obj \
 		ptw32_timespec.obj \
 		ptw32_throw.obj \
 		ptw32_getprocessors.obj \
 		ptw32_calloc.obj \
 		ptw32_new.obj \
 		ptw32_reuse.obj \
 		ptw32_rwlock_check_need_init.obj \
 		ptw32_cond_check_need_init.obj \
 		ptw32_mutex_check_need_init.obj \
 		ptw32_semwait.obj \
 		ptw32_relmillisecs.obj \
 		ptw32_MCS_lock.obj \
 		sched_get_priority_max.obj \
 		sched_get_priority_min.obj \
 		sched_setscheduler.obj \
 		sched_getscheduler.obj \
 		sched_yield.obj \
 		sem_init.obj \
 		sem_destroy.obj \
 		sem_trywait.obj \
 		sem_timedwait.obj \
 		sem_wait.obj \
 		sem_post.obj \
 		sem_post_multiple.obj \
 		sem_getvalue.obj \
 		sem_open.obj \
 		sem_close.obj \
 		sem_unlink.obj \
 		signal.obj \
 		pthread_kill.obj \
 		ptw32_spinlock_check_need_init.obj \
 		pthread_spin_init.obj \
 		pthread_spin_destroy.obj \
 		pthread_spin_lock.obj \
 		pthread_spin_unlock.obj \
 		pthread_spin_trylock.obj \
 		pthread_detach.obj \
 		pthread_join.obj \
 		pthread_key_create.obj \
 		pthread_key_delete.obj \
 		pthread_setspecific.obj \
 		pthread_getspecific.obj \
 		w32_CancelableWait.obj \
 		version.res
 INCL	= config.h implement.h semaphore.h pthread.h need_errno.h
 ATTR_SRCS	= \
 		pthread_attr_init.c \
 		pthread_attr_destroy.c \
 		pthread_attr_getdetachstate.c \
 		pthread_attr_setdetachstate.c \
 		pthread_attr_getstackaddr.c \
 		pthread_attr_setstackaddr.c \
 		pthread_attr_getstacksize.c \
 		pthread_attr_setstacksize.c \
 		pthread_attr_getscope.c \
 		pthread_attr_setscope.c
 BARRIER_SRCS = \
 		pthread_barrier_init.c \
 		pthread_barrier_destroy.c \
 		pthread_barrier_wait.c \
 		pthread_barrierattr_init.c \
 		pthread_barrierattr_destroy.c \
 		pthread_barrierattr_setpshared.c \
 		pthread_barrierattr_getpshared.c
 CANCEL_SRCS	= \
 		pthread_setcancelstate.c \
 		pthread_setcanceltype.c \
 		pthread_testcancel.c \
 		pthread_cancel.c 
 CONDVAR_SRCS	= \
 		ptw32_cond_check_need_init.c \
 		pthread_condattr_destroy.c \
 		pthread_condattr_getpshared.c \
 		pthread_condattr_init.c \
 		pthread_condattr_setpshared.c \
 		pthread_cond_destroy.c \
 		pthread_cond_init.c \
 		pthread_cond_signal.c \
 		pthread_cond_wait.c
 EXIT_SRCS	= \
 		pthread_exit.c
 MISC_SRCS	= \
 		pthread_equal.c \
 		pthread_getconcurrency.c \
 		pthread_kill.c \
 		pthread_once.c \
 		pthread_self.c \
 		pthread_setconcurrency.c \
 		ptw32_calloc.c \
 		ptw32_MCS_lock.c \
 		ptw32_new.c \
 		ptw32_reuse.c \
 		ptw32_relmillisecs.c \
 		w32_CancelableWait.c
 MUTEX_SRCS	= \
 		ptw32_mutex_check_need_init.c \
 		pthread_mutex_init.c \
 		pthread_mutex_destroy.c \
 		pthread_mutexattr_init.c \
 		pthread_mutexattr_destroy.c \
 		pthread_mutexattr_getpshared.c \
 		pthread_mutexattr_setpshared.c \
 		pthread_mutexattr_settype.c \
 		pthread_mutexattr_gettype.c \
 		pthread_mutexattr_setrobust.c \
 		pthread_mutexattr_getrobust.c \
 		pthread_mutex_lock.c \
 		pthread_mutex_timedlock.c \
 		pthread_mutex_unlock.c \
 		pthread_mutex_trylock.c \
 		pthread_mutex_consistent.c
 NONPORTABLE_SRCS = \
 		pthread_mutexattr_setkind_np.c \
 		pthread_mutexattr_getkind_np.c \
 		pthread_getw32threadhandle_np.c \
 		pthread_getunique_np.c \
 		pthread_delay_np.c \
 		pthread_num_processors_np.c \
 		pthread_win32_attach_detach_np.c \
 		pthread_timechange_handler_np.c 
 PRIVATE_SRCS	= \
 		ptw32_is_attr.c \
 		ptw32_processInitialize.c \
 		ptw32_processTerminate.c \
 		ptw32_threadStart.c \
 		ptw32_threadDestroy.c \
 		ptw32_tkAssocCreate.c \
 		ptw32_tkAssocDestroy.c \
 		ptw32_callUserDestroyRoutines.c \
 		ptw32_semwait.c \
 		ptw32_timespec.c \
 		ptw32_throw.c \
 		ptw32_getprocessors.c
 RWLOCK_SRCS	= \
 		ptw32_rwlock_check_need_init.c \
 		ptw32_rwlock_cancelwrwait.c \
 		pthread_rwlock_init.c \
 		pthread_rwlock_destroy.c \
 		pthread_rwlockattr_init.c \
 		pthread_rwlockattr_destroy.c \
 		pthread_rwlockattr_getpshared.c \
 		pthread_rwlockattr_setpshared.c \
 		pthread_rwlock_rdlock.c \
 		pthread_rwlock_timedrdlock.c \
 		pthread_rwlock_wrlock.c \
 		pthread_rwlock_timedwrlock.c \
 		pthread_rwlock_unlock.c \
 		pthread_rwlock_tryrdlock.c \
 		pthread_rwlock_trywrlock.c
 SCHED_SRCS	= \
 		pthread_attr_setschedpolicy.c \
 		pthread_attr_getschedpolicy.c \
 		pthread_attr_setschedparam.c \
 		pthread_attr_getschedparam.c \
 		pthread_attr_setinheritsched.c \
 		pthread_attr_getinheritsched.c \
 		pthread_setschedparam.c \
 		pthread_getschedparam.c \
 		sched_get_priority_max.c \
 		sched_get_priority_min.c \
 		sched_setscheduler.c \
 		sched_getscheduler.c \
 		sched_yield.c
 SEMAPHORE_SRCS = \
 		sem_init.c \
 		sem_destroy.c \
 		sem_trywait.c \
 		sem_timedwait.c \
 		sem_wait.c \
 		sem_post.c \
 		sem_post_multiple.c \
 		sem_getvalue.c \
 		sem_open.c \
 		sem_close.c \
 		sem_unlink.c
 SPIN_SRCS	= \
 		ptw32_spinlock_check_need_init.c \
 		pthread_spin_init.c \
 		pthread_spin_destroy.c \
 		pthread_spin_lock.c \
 		pthread_spin_unlock.c \
 		pthread_spin_trylock.c
 SYNC_SRCS	= \
 		pthread_detach.c \
 		pthread_join.c
 TSD_SRCS	= \
 		pthread_key_create.c \
 		pthread_key_delete.c \
 		pthread_setspecific.c \
 		pthread_getspecific.c
 help:
 	@ echo Run one of the following command lines:
 	@ echo nmake clean VCE   (to build the MSVC dll with C++ exception handling)
 	@ echo nmake clean VSE   (to build the MSVC dll with structured exception handling)
 	@ echo nmake clean VC    (to build the MSVC dll with C cleanup code)
 	@ echo nmake clean VCE-inlined   (to build the MSVC inlined dll with C++ exception handling)
 	@ echo nmake clean VSE-inlined   (to build the MSVC inlined dll with structured exception handling)
 	@ echo nmake clean VC-inlined    (to build the MSVC inlined dll with C cleanup code)
 	@ echo nmake clean VC-static     (to build the MSVC static lib with C cleanup code)
 	@ echo nmake clean VCE-debug   (to build the debug MSVC dll with C++ exception handling)
 	@ echo nmake clean VSE-debug   (to build the debug MSVC dll with structured exception handling)
 	@ echo nmake clean VC-debug    (to build the debug MSVC dll with C cleanup code)
 	@ echo nmake clean VCE-inlined-debug   (to build the debug MSVC inlined dll with C++ exception handling)
 	@ echo nmake clean VSE-inlined-debug   (to build the debug MSVC inlined dll with structured exception handling)
 	@ echo nmake clean VC-inlined-debug    (to build the debug MSVC inlined dll with C cleanup code)
 	@ echo nmake clean VC-static-debug     (to build the debug MSVC static lib with C cleanup code)
 all:
 	@ $(MAKE) /E clean VCE-inlined
 	@ $(MAKE) /E clean VSE-inlined
 	@ $(MAKE) /E clean VC-inlined
 	@ $(MAKE) /E clean VCE-inlined-debug
 	@ $(MAKE) /E clean VSE-inlined-debug
 	@ $(MAKE) /E clean VC-inlined-debug
 VCE:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGS) $(DLLCRT)" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VER).dll
 VCE-debug:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGSD) $(DLLCRTD)" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VERD).dll
 VSE:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGS) $(DLLCRT)" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VER).dll
 VSE-debug:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGSD) $(DLLCRTD)" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VERD).dll
 VC:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGS) $(DLLCRT)" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VER).dll
 VC-debug:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGSD) $(DLLCRTD)" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VERD).dll
 #
 # The so-called inlined DLL is just a single translation unit with
 # inlining optimisation turned on.
 #
 VCE-inlined:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGS) $(DLLCRT) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VER).stamp
 VCE-inlined-debug:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGSD) $(DLLCRTD) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VERD).stamp
 VSE-inlined:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGS) $(DLLCRT) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VER).stamp
 VSE-inlined-debug:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGSD) $(DLLCRTD) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VERD).stamp
 VC-inlined:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGS) $(DLLCRT) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VER).stamp
 VC-inlined-debug:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGSD) $(DLLCRTD) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VERD).stamp
 VC-static:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGS) $(STATICCRT) /DPTW32_BUILD_INLINED /DPTW32_STATIC_LIB" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VER).static
 VC-static-debug:
 	@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGSD) $(STATICCRTD) /DPTW32_BUILD_INLINED /DPTW32_STATIC_LIB" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VERD).static
 realclean: clean
 	if exist pthread*.dll del pthread*.dll
 	if exist pthread*.lib del pthread*.lib
 	if exist *.manifest del *.manifest
 	if exist *.stamp del *.stamp
 clean:
 	if exist *.obj del *.obj
 	if exist *.def del *.def
 	if exist *.ilk del *.ilk
 	if exist *.pdb del *.pdb
 	if exist *.exp del *.exp
 	if exist *.map del *.map
 	if exist *.o del *.o
 	if exist *.i del *.i
 	if exist *.res del *.res
 install:
 	copy pthread*.dll $(DLLDEST)
 	copy pthread*.lib $(LIBDEST)
 	copy pthread.h $(HDRDEST)
 	copy sched.h $(HDRDEST)
 	copy semaphore.h $(HDRDEST)
 $(DLLS): $(DLL_OBJS)
 	$(CC) /LDd /Zi /nologo $(DLL_OBJS) /link /implib:$*.lib $(XLIBS) /out:$@
 $(INLINED_STAMPS): $(DLL_INLINED_OBJS)
 	$(CC) /LDd /Zi /nologo $(DLL_INLINED_OBJS) /link /implib:$*.lib $(XLIBS) /out:$*.dll
 $(STATIC_STAMPS): $(DLL_INLINED_OBJS)
 	if exist $*.lib del $*.lib
 	lib $(DLL_INLINED_OBJS) /out:$*.lib
 .c.obj:
 	$(CC) $(EHFLAGS) /D$(CLEANUP) -c $<
 .rc.res:
 	rc /dPTW32_RC_MSC /d$(CLEANUP) $<
 .c.i:
 	$(CC) /P /O2 /Ob1 $(VCFLAGS) $<
 attr.obj:	attr.c $(ATTR_SRCS) $(INCL)
 barrier.obj:	barrier.c $(BARRIER_SRCS) $(INCL)
 cancel.obj:	cancel.c $(CANCEL_SRCS) $(INCL)
 condvar.obj:	condvar.c $(CONDVAR_SRCS) $(INCL)
 exit.obj:	exit.c $(EXIT_SRCS) $(INCL)
 misc.obj:	misc.c $(MISC_SRCS) $(INCL)
 mutex.obj:	mutex.c $(MUTEX_SRCS) $(INCL)
 nonportable.obj:	nonportable.c $(NONPORTABLE_SRCS) $(INCL)
 private.obj:	private.c $(PRIVATE_SRCS) $(INCL)
 rwlock.obj:	rwlock.c $(RWLOCK_SRCS) $(INCL)
 sched.obj:	sched.c $(SCHED_SRCS) $(INCL)
 semaphore.obj:	semaphore.c $(SEMAPHORE_SRCS) $(INCL)
 spin.obj:	spin.c $(SPIN_SRCS) $(INCL)
 sync.obj:	sync.c $(SYNC_SRCS) $(INCL)
 tsd.obj:	tsd.c $(TSD_SRCS) $(INCL)
 version.res:	version.rc $(INCL)
--- a/deps/uv/deps/pthread-win32/NEWS
+++ b/deps/uv/deps/pthread-win32/NEWS
--- a/deps/uv/deps/pthread-win32/Nmakefile
+++ b/deps/uv/deps/pthread-win32/Nmakefile
@ -1,24 +0,0 @@
 /*
 * nmake file for uwin pthread library
 */
 VERSION 		= -
 CCFLAGS 		= -V -g $(CC.DLL)
 HAVE_PTW32_CONFIG_H	== 1
 _MT			== 1
 _timeb		== timeb
 _ftime		== ftime
 _errno		== _ast_errno
 $(INCLUDEDIR)	:INSTALLDIR:	pthread.h sched.h
 pthread $(VERSION) :LIBRARY: attr.c barrier.c cancel.c cleanup.c condvar.c \
 	create.c dll.c exit.c fork.c global.c misc.c mutex.c private.c \
 	rwlock.c sched.c semaphore.c spin.c sync.c tsd.c nonportable.c
 :: ANNOUNCE CONTRIBUTORS COPYING.LIB ChangeLog FAQ GNUmakefile MAINTAINERS \
 	Makefile Makefile.in Makefile.vc NEWS PROGRESS README README.WinCE \
 	TODO WinCE-PORT install-sh errno.c tests tests.mk acconfig.h \
 	config.guess config.h.in config.sub configure configure.in signal.c \
 	README.CV README.NONPORTABLE pthread.dsp pthread.dsw
--- a/deps/uv/deps/pthread-win32/Nmakefile.tests
+++ b/deps/uv/deps/pthread-win32/Nmakefile.tests
@ -1,260 +0,0 @@
 /* for running tests */
 CCFLAGS 	= -g 
 _MT		== 1
 _timeb	== timeb
 _ftime	== ftime 
 .SOURCE:	tests
 /*
 :PACKAGE:	pthread
 */
 set keepgoing
 ":test:" : .MAKE .OPERATOR
 	local I
 	$(<:D:B:S=.pass) : .IMPLICIT $(>:D:B:S=.pass)
 	for I $(<) $(>)
 		$(I:D:B:S=.pass) : .VIRTUAL .FORCE $(I)
 			$(>)
 	end
 sizes::		sizes.c
 loadfree::	loadfree.c
 mutex1::	mutex1.c
 mutex1e::	mutex1e.c
 mutex1n::	mutex1n.c
 mutex1r::	mutex1r.c
 mutex2::	mutex2.c
 mutex2r::	mutex2r.c
 mutex2e::	mutex2e.c
 exit1::	exit1.c
 condvar1::	condvar1.c
 condvar1_1::	condvar1_1.c
 condvar1_2::	condvar1_2.c
 self1::		self1.c
 condvar2::	condvar2.c
 condvar2_1::	condvar2_1.c
 condvar3_1::	condvar3_1.c
 condvar3_2::	condvar3_2.c
 condvar3_3::	condvar3_3.c
 create1.::	create1.c
 create2.::	create2.c
 cancel1::	cancel1.c
 cancel2::	cancel2.c
 mutex3::	mutex3.c
 mutex3r::	mutex3r.c
 mutex3e::	mutex3e.c
 mutex4::	mutex4.c
 mutex5::	mutex5.c
 mutex6::	mutex6.c
 mutex6e::	mutex6e.c
 mutex6n::	mutex6n.c
 mutex6r::	mutex6r.c
 mutex7::	mutex7.c
 mutex6s::	mutex6s.c
 mutex6rs::	mutex6rs.c
 mutex6es::	mutex6es.c
 mutex7e::	mutex7e.c
 mutex7n::	mutex7n.c
 mutex7r::	mutex7r.c
 mutex8::	mutex8.c
 mutex8e::	mutex8e.c
 mutex8n::	mutex8n.c
 mutex8r::	mutex8r.c
 equal1::	equal1.c
 exit2::		exit2.c
 exit3::		exit3.c
 exit4::		exit4.c
 exit5::		exit5.c
 join0::		join0.c
 join1::		join1.c
 join2::		join2.c
 join3::		join3.c
 kill1::		kill1.c
 count1::	count1.c
 once1::		once1.c
 tsd1::		tsd1.c
 self2::		self2.c
 eyal1::		eyal1.c
 condvar3::	condvar3.c
 condvar4::	condvar4.c
 condvar5::	condvar5.c
 condvar6::	condvar6.c
 condvar7::	condvar7.c
 condvar8::	condvar8.c
 condvar9::	condvar9.c
 errno1::	errno1.c
 reuse1.::	reuse1.c
 reuse2.::	reuse2.c
 rwlock1::	rwlock1.c
 rwlock2::	rwlock2.c
 rwlock3::	rwlock3.c
 rwlock4::	rwlock4.c
 rwlock5::	rwlock5.c
 rwlock6::	rwlock6.c
 rwlock7::	rwlock7.c
 rwlock8::	rwlock8.c
 rwlock2_t::	rwlock2_t.c
 rwlock3_t::	rwlock3_t.c
 rwlock4_t::	rwlock4_t.c
 rwlock5_t::	rwlock5_t.c
 rwlock6_t::	rwlock6_t.c
 rwlock6_t2::	rwlock6_t2.c
 semaphore1::	semaphore1.c
 semaphore2::	semaphore2.c
 semaphore3::	semaphore3.c
 context1::	context1.c
 cancel3::	cancel3.c
 cancel4::	cancel4.c
 cancel5::	cancel5.c
 cancel6a::	cancel6a.c
 cancel6d::	cancel6d.c
 cancel7::	cancel7.c
 cleanup0::	cleanup0.c
 cleanup1::	cleanup1.c
 cleanup2::	cleanup2.c
 cleanup3::	cleanup3.c
 priority1::     priority1.c
 priority2::     priority2.c
 inherit1::      inherit1.c
 spin1::         spin1.c
 spin2::         spin2.c
 spin3::         spin3.c
 spin4::         spin4.c
 barrier1::      barrier1.c
 barrier2::      barrier2.c
 barrier3::      barrier3.c
 barrier4::      barrier4.c
 barrier5::      barrier5.c
 exception1::	exception1.c
 exception2::	exception2.c
 exception3::	exception3.c
 benchtest1::    benchtest1.c
 benchtest2::    benchtest2.c
 benchtest3::    benchtest3.c
 benchtest4::    benchtest4.c
 benchtest5::    benchtest5.c
 valid1::	valid1.c
 valid2::	valid2.c
 cancel9::	cancel9.c
 sizes:		:test:	sizes
 loadfree:	:test:
 mutex5		:test:	loadfree
 mutex1		:test:	loadfree
 mutex1n		:test:	loadfree
 mutex1r		:test:	loadfree
 mutex1e		:test:	loadfree
 semaphore1	:test:	loadfree
 semaphore2	:test:	loadfree
 semaphore3	:test:	loadfree
 mutex2		:test:	loadfree
 mutex2r		:test:	loadfree
 mutex2e		:test:	loadfree
 exit1		:test:	loadfree
 condvar1	:test:	loadfree
 kill1		:test:	loadfree
 condvar1_1	:test:	condvar1
 condvar1_2	:test:	join2
 self1		:test:	loadfree
 condvar2	:test:	condvar1
 condvar2_1	:test:	condvar2
 create1 	:test:	mutex2
 create2 	:test:	create1
 reuse1 		:test:	create2
 reuse2 		:test:	reuse1
 cancel1		:test:	create1
 cancel2		:test:	cancel1
 mutex3		:test:	create1
 mutex3r		:test:	create1
 mutex3e		:test:	create1
 mutex4		:test:	mutex3
 mutex6		:test:	mutex4
 mutex6n		:test:	mutex4
 mutex6e		:test:	mutex4
 mutex6r		:test:	mutex4
 mutex6s		:test:	mutex6
 mutex6rs	:test:	mutex6r
 mutex6es	:test:	mutex6e
 mutex7		:test:	mutex6
 mutex7n		:test:	mutex6n
 mutex7e		:test:	mutex6e
 mutex7r		:test:	mutex6r
 mutex8		:test:	mutex7
 mutex8n		:test:	mutex7n
 mutex8e		:test:	mutex7e
 mutex8r		:test:	mutex7r
 equal1		:test:	create1
 exit2		:test:	create1
 exit3		:test:	create1
 exit4		:test:	kill1
 exit5		:test:	exit4
 join0		:test:	create1
 join1		:test:	create1
 join2		:test:	create1
 join3		:test:	join2
 count1		:test:	join1
 once1		:test:	create1
 tsd1		:test:	join1
 self2		:test:	create1
 eyal1		:test:	tsd1
 condvar3	:test:	create1
 condvar3_1	:test:	condvar3
 condvar3_2	:test:	condvar3_1
 condvar3_3	:test:	condvar3_2
 condvar4	:test:	create1
 condvar5	:test:	condvar4
 condvar6	:test:	condvar5
 condvar7	:test:	condvar6	cleanup1
 condvar8	:test:	condvar7
 condvar9	:test:	condvar8
 errno1		:test:	mutex3
 rwlock1		:test:	condvar6
 rwlock2		:test:	rwlock1
 rwlock3		:test:	rwlock2
 rwlock4		:test:	rwlock3
 rwlock5		:test:	rwlock4
 rwlock6		:test:	rwlock5
 rwlock7		:test:	rwlock6
 rwlock8		:test:	rwlock7
 rwlock2_t	:test:	rwlock2
 rwlock3_t	:test:	rwlock2_t
 rwlock4_t	:test:	rwlock3_t
 rwlock5_t	:test:	rwlock4_t
 rwlock6_t	:test:	rwlock5_t
 rwlock6_t2	:test:	rwlock6_t
 context1	:test:	cancel2
 cancel3		:test:	context1
 cancel4		:test:	cancel3
 cancel5		:test:	cancel3
 cancel6a	:test:	cancel3
 cancel6d	:test:	cancel3
 cancel7		:test:	kill1
 cleanup0	:test:	cancel5
 cleanup1	:test:	cleanup0
 cleanup2	:test:	cleanup1
 cleanup3	:test:	cleanup2
 priority1       :test:  join1
 priority2       :test:  priority1
 inherit1        :test:  join1
 spin1           :test:
 spin2           :test:  spin1.c
 spin3           :test:  spin2.c
 spin4           :test:  spin3.c
 barrier1        :test:
 barrier2        :test:  barrier1.c
 barrier3        :test:  barrier2.c
 barrier4        :test:  barrier3.c
 barrier5        :test:  barrier4.c
 benchtest1      :test:  mutex3
 benchtest2      :test:  benchtest1
 benchtest3      :test:  benchtest2
 benchtest4      :test:  benchtest3
 benchtest5      :test:  benchtest4
 exception1	:test:	cancel4
 exception2	:test:	exception1
 exception3	:test:	exception2
 exit4		:test:	exit3
 valid1		:test:	join1
 valid2		:test:	valid1
 cancel9		:test:	cancel8
--- a/deps/uv/deps/pthread-win32/PROGRESS
+++ b/deps/uv/deps/pthread-win32/PROGRESS
@ -1,4 +0,0 @@
 Please see the ANNOUNCE file "Level of Standards Conformance"
 or the web page:
 http://sources.redhat.com/pthreads-win32/conformance.html
--- a/deps/uv/deps/pthread-win32/README
+++ b/deps/uv/deps/pthread-win32/README
@ -1,601 +0,0 @@
 PTHREADS-WIN32
 ==============
 Pthreads-win32 is free software, distributed under the GNU Lesser
 General Public License (LGPL). See the file 'COPYING.LIB' for terms
 and conditions. Also see the file 'COPYING' for information
 specific to pthreads-win32, copyrights and the LGPL.
 What is it?
 -----------
 Pthreads-win32 is an Open Source Software implementation of the
 Threads component of the POSIX 1003.1c 1995 Standard (or later)
 for Microsoft's Win32 environment. Some functions from POSIX
 1003.1b are also supported including semaphores. Other related
 functions include the set of read-write lock functions. The
 library also supports some of the functionality of the Open
 Group's Single Unix specification, version 2, namely mutex types,
 plus some common and pthreads-win32 specific non-portable
 routines (see README.NONPORTABLE).
 See the file "ANNOUNCE" for more information including standards
 conformance details and the list of supported and unsupported
 routines.
 Prerequisites
 -------------
 MSVC or GNU C (MinGW32 MSys development kit)
 	To build from source.
 QueueUserAPCEx by Panagiotis E. Hadjidoukas
 	To support any thread cancelation in C++ library builds or
 	to support cancelation of blocked threads in any build.
 	This library is not required otherwise.
 	For true async cancelation of threads (including blocked threads).
 	This is a DLL and Windows driver that provides pre-emptive APC
 	by forcing threads into an alertable state when the APC is queued.
 	Both the DLL and driver are provided with the pthreads-win32.exe
 	self-unpacking ZIP, and on the pthreads-win32 FTP site  (in source
 	and pre-built forms). Currently this is a separate LGPL package to
 	pthreads-win32. See the README in the QueueUserAPCEx folder for
 	installation instructions.
 	Pthreads-win32 will automatically detect if the QueueUserAPCEx DLL
 	QuserEx.DLL is available and whether the driver AlertDrv.sys is
 	loaded. If it is not available, pthreads-win32 will simulate async
 	cancelation, which means that it can async cancel only threads that
 	are runnable. The simulated async cancellation cannot cancel blocked
 	threads.
        [FOR SECURITY] To be found Quserex.dll MUST be installed in the
 	Windows System Folder. This is not an unreasonable constraint given a
 	driver must also be installed and loaded at system startup.
 Library naming
 --------------
 Because the library is being built using various exception
 handling schemes and compilers - and because the library
 may not work reliably if these are mixed in an application,
 each different version of the library has it's own name.
 Note 1: the incompatibility is really between EH implementations
 of the different compilers. It should be possible to use the
 standard C version from either compiler with C++ applications
 built with a different compiler. If you use an EH version of
 the library, then you must use the same compiler for the
 application. This is another complication and dependency that
 can be avoided by using only the standard C library version.
 Note 2: if you use a standard C pthread*.dll with a C++
 application, then any functions that you define that are
 intended to be called via pthread_cleanup_push() must be
 __cdecl.
 Note 3: the intention was to also name either the VC or GC
 version (it should be arbitrary) as pthread.dll, including
 pthread.lib and libpthread.a as appropriate. This is no longer
 likely to happen.
 Note 4: the compatibility number was added so that applications
 can differentiate between binary incompatible versions of the
 libs and dlls.
 In general:
 	pthread[VG]{SE,CE,C}[c].dll
 	pthread[VG]{SE,CE,C}[c].lib
 where:
 	[VG] indicates the compiler
 	V	- MS VC, or
 	G	- GNU C
 	{SE,CE,C} indicates the exception handling scheme
 	SE	- Structured EH, or
 	CE	- C++ EH, or
 	C	- no exceptions - uses setjmp/longjmp
 	c	- DLL compatibility number indicating ABI and API
 		  compatibility with applications built against
 		  a snapshot with the same compatibility number.
 		  See 'Version numbering' below.
 The name may also be suffixed by a 'd' to indicate a debugging version
 of the library. E.g. pthreadVC2d.lib. Debugging versions contain
 additional information for debugging (symbols etc) and are often not
 optimised in any way (compiled with optimisation turned off).
 Examples:
 	pthreadVSE.dll	(MSVC/SEH)
 	pthreadGCE.dll	(GNUC/C++ EH)
 	pthreadGC.dll	(GNUC/not dependent on exceptions)
 	pthreadVC1.dll	(MSVC/not dependent on exceptions - not binary
 			compatible with pthreadVC.dll)
 	pthreadVC2.dll	(MSVC/not dependent on exceptions - not binary
 			compatible with pthreadVC1.dll or pthreadVC.dll)
 The GNU library archive file names have correspondingly changed to:
 	libpthreadGCEc.a
 	libpthreadGCc.a
 Versioning numbering
 --------------------
 Version numbering is separate from the snapshot dating system, and
 is the canonical version identification system embedded within the
 DLL using the Microsoft version resource system. The versioning
 system chosen follows the GNU Libtool system. See
 http://www.gnu.org/software/libtool/manual.html section 6.2.
 See the resource file 'version.rc'.
 Microsoft version numbers use 4 integers:
 	0.0.0.0
 Pthreads-win32 uses the first 3 following the Libtool convention.
 The fourth is commonly used for the build number, but will be reserved
 for future use.
 	current.revision.age.0
 The numbers are changed as follows:
 1. If the library source code has changed at all since the last update,
   then increment revision (`c:r:a' becomes `c:r+1:a').
 2. If any interfaces have been added, removed, or changed since the last
   update, increment current, and set revision to 0.
 3. If any interfaces have been added since the last public release, then
   increment age.
 4. If any interfaces have been removed or changed since the last public
   release, then set age to 0.
 DLL compatibility numbering is an attempt to ensure that applications
 always load a compatible pthreads-win32 DLL by using a DLL naming system
 that is consistent with the version numbering system. It also allows
 older and newer DLLs to coexist in the same filesystem so that older
 applications can continue to be used. For pre .NET Windows systems,
 this inevitably requires incompatible versions of the same DLLs to have
 different names.
 Pthreads-win32 has adopted the Cygwin convention of appending a single
 integer number to the DLL name. The number used is based on the library
 version number and is computed as 'current' - 'age'.
 (See http://home.att.net/~perlspinr/libversioning.html for a nicely
 detailed explanation.)
 Using this method, DLL name/s will only change when the DLL's
 backwards compatibility changes. Note that the addition of new
 'interfaces' will not of itself change the DLL's compatibility for older
 applications.
 Which of the several dll versions to use?
 -----------------------------------------
 or,
 ---
 What are all these pthread*.dll and pthread*.lib files?
 -------------------------------------------------------
 Simple, use either pthreadGCv.* if you use GCC, or pthreadVCv.* if you
 use MSVC - where 'v' is the DLL versioning (compatibility) number.
 Otherwise, you need to choose carefully and know WHY.
 The most important choice you need to make is whether to use a
 version that uses exceptions internally, or not. There are versions
 of the library that use exceptions as part of the thread
 cancelation and exit implementation. The default version uses
 setjmp/longjmp.
 There is some contension amongst POSIX threads experts as
 to how POSIX threads cancelation and exit should work
 with languages that use exceptions, e.g. C++ and even C
 (Microsoft's Structured Exceptions).
 The issue is: should cancelation of a thread in, say,
 a C++ application cause object destructors and C++ exception
 handlers to be invoked as the stack unwinds during thread
 exit, or not?
 There seems to be more opinion in favour of using the
 standard C version of the library (no EH) with C++ applications
 for the reason that this appears to be the assumption commercial
 pthreads implementations make. Therefore, if you use an EH version
 of pthreads-win32 then you may be under the illusion that
 your application will be portable, when in fact it is likely to
 behave differently when linked with other pthreads libraries.
 Now you may be asking: then why have you kept the EH versions of
 the library?
 There are a couple of reasons:
 - there is division amongst the experts and so the code may
  be needed in the future. Yes, it's in the repository and we
  can get it out anytime in the future, but it would be difficult
  to find.
 - pthreads-win32 is one of the few implementations, and possibly
  the only freely available one, that has EH versions. It may be
  useful to people who want to play with or study application
  behaviour under these conditions.
 Notes:
 [If you use either pthreadVCE or pthreadGCE]
 1. [See also the discussion in the FAQ file - Q2, Q4, and Q5]
 If your application contains catch(...) blocks in your POSIX
 threads then you will need to replace the "catch(...)" with the macro
 "PtW32Catch", eg.
 	#ifdef PtW32Catch
 		PtW32Catch {
 			...
 		}
 	#else
 		catch(...) {
 			...
 		}
 	#endif
 Otherwise neither pthreads cancelation nor pthread_exit() will work
 reliably when using versions of the library that use C++ exceptions
 for cancelation and thread exit.
 This is due to what is believed to be a C++ compliance error in VC++
 whereby you may not have multiple handlers for the same exception in
 the same try/catch block. GNU G++ doesn't have this restriction.
 Other name changes
 ------------------
 All snapshots prior to and including snapshot 2000-08-13
 used "_pthread_" as the prefix to library internal
 functions, and "_PTHREAD_" to many library internal
 macros. These have now been changed to "ptw32_" and "PTW32_"
 respectively so as to not conflict with the ANSI standard's
 reservation of identifiers beginning with "_" and "__" for
 use by compiler implementations only.
 If you have written any applications and you are linking
 statically with the pthreads-win32 library then you may have
 included a call to _pthread_processInitialize. You will
 now have to change that to ptw32_processInitialize.
 Cleanup code default style
 --------------------------
 Previously, if not defined, the cleanup style was determined automatically
 from the compiler used, and one of the following was defined accordingly:
 	__CLEANUP_SEH	MSVC only
 	__CLEANUP_CXX	C++, including MSVC++, GNU G++
 	__CLEANUP_C	C, including GNU GCC, not MSVC
 These defines determine the style of cleanup (see pthread.h) and,
 most importantly, the way that cancelation and thread exit (via
 pthread_exit) is performed (see the routine ptw32_throw()).
 In short, the exceptions versions of the library throw an exception
 when a thread is canceled, or exits via pthread_exit(). This exception is
 caught by a handler in the thread startup routine, so that the
 the correct stack unwinding occurs regardless of where the thread
 is when it's canceled or exits via pthread_exit().
 In this snapshot, unless the build explicitly defines (e.g. via a
 compiler option) __CLEANUP_SEH, __CLEANUP_CXX, or __CLEANUP_C, then
 the build NOW always defaults to __CLEANUP_C style cleanup. This style
 uses setjmp/longjmp in the cancelation and pthread_exit implementations,
 and therefore won't do stack unwinding even when linked to applications
 that have it (e.g. C++ apps). This is for consistency with most/all
 commercial Unix POSIX threads implementations.
 Although it was not clearly documented before, it is still necessary to
 build your application using the same __CLEANUP_* define as was
 used for the version of the library that you link with, so that the
 correct parts of pthread.h are included. That is, the possible
 defines require the following library versions:
 	__CLEANUP_SEH	pthreadVSE.dll
 	__CLEANUP_CXX	pthreadVCE.dll or pthreadGCE.dll
 	__CLEANUP_C	pthreadVC.dll or pthreadGC.dll
 It is recommended that you let pthread.h use it's default __CLEANUP_C
 for both library and application builds. That is, don't define any of
 the above, and then link with pthreadVC.lib (MSVC or MSVC++) and
 libpthreadGC.a (MinGW GCC or G++). The reason is explained below, but
 another reason is that the prebuilt pthreadVCE.dll is currently broken.
 Versions built with MSVC++ later than version 6 may not be broken, but I
 can't verify this yet.
 WHY ARE WE MAKING THE DEFAULT STYLE LESS EXCEPTION-FRIENDLY?
 Because no commercial Unix POSIX threads implementation allows you to
 choose to have stack unwinding. Therefore, providing it in pthread-win32
 as a default is dangerous. We still provide the choice but unless
 you consciously choose to do otherwise, your pthreads applications will
 now run or crash in similar ways irrespective of the pthreads platform
 you use. Or at least this is the hope.
 Building under VC++ using C++ EH, Structured EH, or just C
 ----------------------------------------------------------
 From the source directory run nmake without any arguments to list
 help information. E.g.
 $ nmake
 Microsoft (R) Program Maintenance Utility   Version 6.00.8168.0
 Copyright (C) Microsoft Corp 1988-1998. All rights reserved.
 Run one of the following command lines:
 nmake clean VCE (to build the MSVC dll with C++ exception handling)
 nmake clean VSE (to build the MSVC dll with structured exception handling)
 nmake clean VC (to build the MSVC dll with C cleanup code)
 nmake clean VCE-inlined (to build the MSVC inlined dll with C++ exception handling)
 nmake clean VSE-inlined (to build the MSVC inlined dll with structured exception handling)
 nmake clean VC-inlined (to build the MSVC inlined dll with C cleanup code)
 nmake clean VC-static (to build the MSVC static lib with C cleanup code)
 nmake clean VCE-debug (to build the debug MSVC dll with C++ exception handling)
 nmake clean VSE-debug (to build the debug MSVC dll with structured exception handling)
 nmake clean VC-debug (to build the debug MSVC dll with C cleanup code)
 nmake clean VCE-inlined-debug (to build the debug MSVC inlined dll with C++ exception handling)
 nmake clean VSE-inlined-debug (to build the debug MSVC inlined dll with structured exception handling)
 nmake clean VC-inlined-debug (to build the debug MSVC inlined dll with C cleanup code)
 nmake clean VC-static-debug (to build the debug MSVC static lib with C cleanup code)
 The pre-built dlls are normally built using the *-inlined targets.
 You can run the testsuite by changing to the "tests" directory and
 running nmake. E.g.:
 $ cd tests
 $ nmake
 Microsoft (R) Program Maintenance Utility   Version 6.00.8168.0
 Copyright (C) Microsoft Corp 1988-1998. All rights reserved.
 Run one of the following command lines:
 nmake clean VC (to test using VC dll with VC (no EH) applications)
 nmake clean VCX (to test using VC dll with VC++ (EH) applications)
 nmake clean VCE (to test using the VCE dll with VC++ EH applications)
 nmake clean VSE (to test using VSE dll with VC (SEH) applications)
 nmake clean VC-bench (to benchtest using VC dll with C bench app)
 nmake clean VCX-bench (to benchtest using VC dll with C++ bench app)
 nmake clean VCE-bench (to benchtest using VCE dll with C++ bench app)
 nmake clean VSE-bench (to benchtest using VSE dll with SEH bench app)
 nmake clean VC-static (to test using VC static lib with VC (no EH) applications)
 Building under Mingw32
 ----------------------
 The dll can be built easily with recent versions of Mingw32.
 (The distributed versions are built using Mingw32 and MsysDTK
 from www.mingw32.org.)
 From the source directory, run make for help information. E.g.:
 $ make
 Run one of the following command lines:
 make clean GC            (to build the GNU C dll with C cleanup code)
 make clean GCE           (to build the GNU C dll with C++ exception handling)
 make clean GC-inlined    (to build the GNU C inlined dll with C cleanup code)
 make clean GCE-inlined   (to build the GNU C inlined dll with C++ exception handling)
 make clean GC-static     (to build the GNU C inlined static lib with C cleanup code)
 make clean GC-debug      (to build the GNU C debug dll with C cleanup code)
 make clean GCE-debug     (to build the GNU C debug dll with C++ exception handling)
 make clean GC-inlined-debug    (to build the GNU C inlined debug dll with C cleanup code)
 make clean GCE-inlined-debug   (to build the GNU C inlined debug dll with C++ exception handling)
 make clean GC-static-debug     (to build the GNU C inlined static debug lib with C cleanup code)
 The pre-built dlls are normally built using the *-inlined targets.
 You can run the testsuite by changing to the "tests" directory and
 running make for help information. E.g.:
 $ cd tests
 $ make
 Run one of the following command lines:
 make clean GC    (to test using GC dll with C (no EH) applications)
 make clean GCX   (to test using GC dll with C++ (EH) applications)
 make clean GCE   (to test using GCE dll with C++ (EH) applications)
 make clean GC-bench       (to benchtest using GNU C dll with C cleanup code)
 make clean GCE-bench   (to benchtest using GNU C dll with C++ exception handling)
 make clean GC-static   (to test using GC static lib with C (no EH) applications)
 Building under Linux using the Mingw32 cross development tools
 --------------------------------------------------------------
 You can build the library without leaving Linux by using the Mingw32 cross
 development toolchain. See http://www.libsdl.org/extras/win32/cross/ for
 tools and info. The GNUmakefile contains some support for this, for example:
 make CROSS=i386-mingw32msvc- clean GC-inlined
 will build pthreadGCn.dll and libpthreadGCn.a (n=version#), provided your
 cross-tools/bin directory is in your PATH (or use the cross-make.sh script
 at the URL above).
 Building the library as a statically linkable library
 -----------------------------------------------------
 General: PTW32_STATIC_LIB must be defined for both the library build and the
 application build. The makefiles supplied and used by the following 'make'
 command lines will define this for you.
 MSVC (creates pthreadVCn.lib as a static link lib):
 nmake clean VC-static
 MinGW32 (creates libpthreadGCn.a as a static link lib):
 make clean GC-static
 Define PTW32_STATIC_LIB when building your application. Also, your
 application must call a two non-portable routines to initialise the
 some state on startup and cleanup before exit. One other routine needs
 to be called to cleanup after any Win32 threads have called POSIX API
 routines. See README.NONPORTABLE or the html reference manual pages for
 details on these routines:
 BOOL pthread_win32_process_attach_np (void);
 BOOL pthread_win32_process_detach_np (void);
 BOOL pthread_win32_thread_attach_np (void); // Currently a no-op
 BOOL pthread_win32_thread_detach_np (void);
 The tests makefiles have the same targets but only check that the
 static library is statically linkable. They don't run the full
 testsuite. To run the full testsuite, build the dlls and run the
 dll test targets.
 Building the library under Cygwin
 ---------------------------------
 Cygwin is implementing it's own POSIX threads routines and these
 will be the ones to use if you develop using Cygwin.
 Ready to run binaries
 ---------------------
 For convenience, the following ready-to-run files can be downloaded
 from the FTP site (see under "Availability" below):
 	pthread.h
 	semaphore.h
 	sched.h
 	pthreadVC.dll	- built with MSVC compiler using C setjmp/longjmp
 	pthreadVC.lib
 	pthreadVCE.dll	- built with MSVC++ compiler using C++ EH
 	pthreadVCE.lib
 	pthreadVSE.dll	- built with MSVC compiler using SEH
 	pthreadVSE.lib
 	pthreadGC.dll	- built with Mingw32 GCC
 	libpthreadGC.a	- derived from pthreadGC.dll
 	pthreadGCE.dll	- built with Mingw32 G++
 	libpthreadGCE.a	- derived from pthreadGCE.dll
 As of August 2003 pthreads-win32 pthreadG* versions are built and tested
 using the MinGW + MsysDTK environment current as of that date or later.
 The following file MAY be needed for older MinGW environments.
 	gcc.dll 	- needed to build and run applications that use
 			  pthreadGCE.dll.
 Building applications with GNU compilers
 ----------------------------------------
 If you're using pthreadGC.dll:
 With the three header files, pthreadGC.dll and libpthreadGC.a in the
 same directory as your application myapp.c, you could compile, link
 and run myapp.c under Mingw32 as follows:
 	gcc -o myapp.exe myapp.c -I. -L. -lpthreadGC
 	myapp
 Or put pthreadGC.dll in an appropriate directory in your PATH,
 put libpthreadGC.a in your system lib directory, and
 put the three header files in your system include directory,
 then use:
 	gcc -o myapp.exe myapp.c -lpthreadGC
 	myapp
 If you're using pthreadGCE.dll:
 With the three header files, pthreadGCE.dll, gcc.dll and libpthreadGCE.a
 in the same directory as your application myapp.c, you could compile,
 link and run myapp.c under Mingw32 as follows:
 	gcc -x c++ -o myapp.exe myapp.c -I. -L. -lpthreadGCE
 	myapp
 Or put pthreadGCE.dll and gcc.dll in an appropriate directory in
 your PATH, put libpthreadGCE.a in your system lib directory, and
 put the three header files in your system include directory,
 then use:
 	gcc -x c++ -o myapp.exe myapp.c -lpthreadGCE
 	myapp
 Availability
 ------------
 The complete source code in either unbundled, self-extracting
 Zip file, or tar/gzipped format can be found at:
 	ftp://sources.redhat.com/pub/pthreads-win32
 The pre-built DLL, export libraries and matching pthread.h can
 be found at:
 	ftp://sources.redhat.com/pub/pthreads-win32/dll-latest
 Home page:
 	http://sources.redhat.com/pthreads-win32/
 Mailing list
 ------------
 There is a mailing list for discussing pthreads on Win32.
 To join, send email to:
 	pthreads-win32-subscribe@sources.redhat.com
 Unsubscribe by sending mail to:
 	pthreads-win32-unsubscribe@sources.redhat.com
 Acknowledgements
 ----------------
 See the ANNOUNCE file for acknowledgements.
 See the 'CONTRIBUTORS' file for the list of contributors.
 As much as possible, the ChangeLog file attributes
 contributions and patches that have been incorporated
 in the library to the individuals responsible.
 Finally, thanks to all those who work on and contribute to the
 POSIX and Single Unix Specification standards. The maturity of an
 industry can be measured by it's open standards.
 ----
 Ross Johnson
 <rpj@callisto.canberra.edu.au>
--- a/deps/uv/deps/pthread-win32/README.Borland
+++ b/deps/uv/deps/pthread-win32/README.Borland
@ -1,57 +0,0 @@
 In ptw32_InterlockedCompareExchange.c, I've added a section for
 Borland's compiler; it's identical to that for the MS compiler except
 that it uses /* ... */ comments instead of ; comments.
 [RPJ: need to define HAVE_TASM32 in config.h to use the above.]
 The other file is a makefile suitable for use with Borland's compiler
 (run "make -fBmakefile" in the directory).  It builds a single version
 of the library, pthreadBC.dll and the corresponding pthreadBC.lib
 import library, which is comparable to the pthreadVC version; I can't
 personally see any demand for the versions that include structured or
 C++ exception cancellation handling so I haven't attempted to build
 those versions of the library.  (I imagine a static version might be
 of use to some, but we can't legally use that on my commercial
 projects so I can't try that out, unfortunately.)
 [RPJ: Added tests\Bmakefile as well.]
 Borland C++ doesn't define the ENOSYS constant used by pthreads-win32;
 rather than make more extensive patches to the pthreads-win32 source I
 have a mostly-arbitrary constant for it in the makefile.  However this
 doesn't make it visible to the application using the library, so if
 anyone actually wants to use this constant in their apps (why?)
 someone might like to make a seperate NEED_BCC_something define to add
 this stuff.
 The makefile also #defines EDEADLK as EDEADLOCK, _timeb as timeb, and
 _ftime as ftime, to deal with the minor differences between the two
 RTLs' naming conventions, and sets the compiler flags as required to
 get a normal compile of the library.
 [RPJ: Moved errno values and _timeb etc to pthread.h, so apps will also
 use them.]
 (While I'm on the subject, the reason Borland users should recompile
 the library, rather than using the impdef/implib technique suggested
 previously on the mailing list, is that a) the errno constants are
 different, so the results returned by the pthread_* functions can be
 meaningless, and b) the errno variable/pseudo-variable itself is
 different in the MS & BCC runtimes, so you can't access the
 pthreadVC's errno from a Borland C++-compiled host application
 correctly - I imagine there are other potential problems from the RTL
 mismatch too.)
 [RPJ: Make sure you use the same RTL in both dll and application builds.
 The dll and tests Bmakefiles use cw32mti.lib. Having some trouble with
 memory read exceptions running the test suite using BCC55.]
 Best regards,
 Will
 -- 
 Will Bryant
 Systems Architect, eCOSM Limited
 Cell +64 21 655 443, office +64 3 365 4176
 http://www.ecosm.com/
--- a/deps/uv/deps/pthread-win32/README.CV
+++ b/deps/uv/deps/pthread-win32/README.CV
--- a/deps/uv/deps/pthread-win32/README.NONPORTABLE
+++ b/deps/uv/deps/pthread-win32/README.NONPORTABLE
@ -1,783 +0,0 @@
 This file documents non-portable functions and other issues.
 Non-portable functions included in pthreads-win32
 -------------------------------------------------
 BOOL
 pthread_win32_test_features_np(int mask)
 	This routine allows an application to check which
 	run-time auto-detected features are available within
 	the library.
 	The possible features are:
 		PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE
 			Return TRUE if the native version of
 			InterlockedCompareExchange() is being used.
 			This feature is not meaningful in recent
 			library versions as MSVC builds only support
 			system implemented ICE. Note that all Mingw
 			builds use inlined asm versions of all the
 			Interlocked routines.
 		PTW32_ALERTABLE_ASYNC_CANCEL
 			Return TRUE is the QueueUserAPCEx package
 			QUSEREX.DLL is available and the AlertDrv.sys
 			driver is loaded into Windows, providing
 			alertable (pre-emptive) asyncronous threads
 			cancelation. If this feature returns FALSE
 			then the default async cancel scheme is in
 			use, which cannot cancel blocked threads.
 	Features may be Or'ed into the mask parameter, in which case
 	the routine returns TRUE if any of the Or'ed features would
 	return TRUE. At this stage it doesn't make sense to Or features
 	but it may some day.
 void *
 pthread_timechange_handler_np(void *)
        To improve tolerance against operator or time service
        initiated system clock changes.
        This routine can be called by an application when it
        receives a WM_TIMECHANGE message from the system. At
        present it broadcasts all condition variables so that
        waiting threads can wake up and re-evaluate their
        conditions and restart their timed waits if required.
        It has the same return type and argument type as a
        thread routine so that it may be called directly
        through pthread_create(), i.e. as a separate thread.
        Parameters
        Although a parameter must be supplied, it is ignored.
        The value NULL can be used.
        Return values
        It can return an error EAGAIN to indicate that not
        all condition variables were broadcast for some reason.
        Otherwise, 0 is returned.
        If run as a thread, the return value is returned
        through pthread_join().
        The return value should be cast to an integer.
 HANDLE
 pthread_getw32threadhandle_np(pthread_t thread);
 	Returns the win32 thread handle that the POSIX
 	thread "thread" is running as.
 	Applications can use the win32 handle to set
 	win32 specific attributes of the thread.
 DWORD
 pthread_getw32threadid_np (pthread_t thread)
 	Returns the Windows native thread ID that the POSIX
 	thread "thread" is running as.
        Only valid when the library is built where
        ! (defined(__MINGW64__) || defined(__MINGW32__)) || defined (__MSVCRT__) || defined (__DMC__)
        and otherwise returns 0.
 int
 pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr, int kind)
 int
 pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr, int *kind)
        These two routines are included for Linux compatibility
        and are direct equivalents to the standard routines
                pthread_mutexattr_settype
                pthread_mutexattr_gettype
        pthread_mutexattr_setkind_np accepts the following
        mutex kinds:
                PTHREAD_MUTEX_FAST_NP
                PTHREAD_MUTEX_ERRORCHECK_NP
                PTHREAD_MUTEX_RECURSIVE_NP
        These are really just equivalent to (respectively):
                PTHREAD_MUTEX_NORMAL
                PTHREAD_MUTEX_ERRORCHECK
                PTHREAD_MUTEX_RECURSIVE
 int
 pthread_delay_np (const struct timespec *interval);
        This routine causes a thread to delay execution for a specific period of time.
        This period ends at the current time plus the specified interval. The routine
        will not return before the end of the period is reached, but may return an
        arbitrary amount of time after the period has gone by. This can be due to
        system load, thread priorities, and system timer granularity.
        Specifying an interval of zero (0) seconds and zero (0) nanoseconds is
        allowed and can be used to force the thread to give up the processor or to
        deliver a pending cancelation request.
        This routine is a cancelation point.
        The timespec structure contains the following two fields:
                tv_sec is an integer number of seconds.
                tv_nsec is an integer number of nanoseconds. 
        Return Values
        If an error condition occurs, this routine returns an integer value
        indicating the type of error. Possible return values are as follows:
        0          Successful completion. 
        [EINVAL]   The value specified by interval is invalid. 
 int
 pthread_num_processors_np (void)
        This routine (found on HPUX systems) returns the number of processors
        in the system. This implementation actually returns the number of
        processors available to the process, which can be a lower number
        than the system's number, depending on the process's affinity mask.
 BOOL
 pthread_win32_process_attach_np (void);
 BOOL
 pthread_win32_process_detach_np (void);
 BOOL
 pthread_win32_thread_attach_np (void);
 BOOL
 pthread_win32_thread_detach_np (void);
 	These functions contain the code normally run via dllMain
 	when the library is used as a dll but which need to be
 	called explicitly by an application when the library
 	is statically linked. As of version 2.9.0 of the library, static
 	builds using either MSC or GCC will call pthread_win32_process_*
 	automatically at application startup and exit respectively.
 	Otherwise, you will need to call pthread_win32_process_attach_np()
 	before you can call any pthread routines when statically linking.
 	You should call pthread_win32_process_detach_np() before
 	exiting your application to clean up.
 	pthread_win32_thread_attach_np() is currently a no-op, but
 	pthread_win32_thread_detach_np() is needed to clean up
 	the implicit pthread handle that is allocated to a Win32 thread if
 	it calls any pthreads routines. Call this routine when the
 	Win32 thread exits.
 	Threads created through pthread_create() do not	need to call
 	pthread_win32_thread_detach_np().
 	These functions invariably return TRUE except for
 	pthread_win32_process_attach_np() which will return FALSE
 	if pthreads-win32 initialisation fails.
 int
 pthreadCancelableWait (HANDLE waitHandle);
 int
 pthreadCancelableTimedWait (HANDLE waitHandle, DWORD timeout);
 	These two functions provide hooks into the pthread_cancel
 	mechanism that will allow you to wait on a Windows handle
 	and make it a cancellation point. Both functions block
 	until either the given w32 handle is signaled, or
 	pthread_cancel has been called. It is implemented using
 	WaitForMultipleObjects on 'waitHandle' and a manually
 	reset w32 event used to implement pthread_cancel.
 Non-portable issues
 -------------------
 Thread priority
 	POSIX defines a single contiguous range of numbers that determine a
 	thread's priority. Win32 defines priority classes and priority
 	levels relative to these classes. Classes are simply priority base
 	levels that the defined priority levels are relative to such that,
 	changing a process's priority class will change the priority of all
 	of it's threads, while the threads retain the same relativity to each
 	other.
 	A Win32 system defines a single contiguous monotonic range of values
 	that define system priority levels, just like POSIX. However, Win32
 	restricts individual threads to a subset of this range on a
 	per-process basis.
 	The following table shows the base priority levels for combinations
 	of priority class and priority value in Win32.
 	 Process Priority Class               Thread Priority Level
 	 -----------------------------------------------------------------
 	 1 IDLE_PRIORITY_CLASS                THREAD_PRIORITY_IDLE
 	 1 BELOW_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_IDLE
 	 1 NORMAL_PRIORITY_CLASS              THREAD_PRIORITY_IDLE
 	 1 ABOVE_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_IDLE
 	 1 HIGH_PRIORITY_CLASS                THREAD_PRIORITY_IDLE
 	 2 IDLE_PRIORITY_CLASS                THREAD_PRIORITY_LOWEST
 	 3 IDLE_PRIORITY_CLASS                THREAD_PRIORITY_BELOW_NORMAL
 	 4 IDLE_PRIORITY_CLASS                THREAD_PRIORITY_NORMAL
 	 4 BELOW_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_LOWEST
 	 5 IDLE_PRIORITY_CLASS                THREAD_PRIORITY_ABOVE_NORMAL
 	 5 BELOW_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_BELOW_NORMAL
 	 5 Background NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_LOWEST
 	 6 IDLE_PRIORITY_CLASS                THREAD_PRIORITY_HIGHEST
 	 6 BELOW_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_NORMAL
 	 6 Background NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_BELOW_NORMAL
 	 7 BELOW_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_ABOVE_NORMAL
 	 7 Background NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_NORMAL
 	 7 Foreground NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_LOWEST
 	 8 BELOW_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_HIGHEST
 	 8 NORMAL_PRIORITY_CLASS              THREAD_PRIORITY_ABOVE_NORMAL
 	 8 Foreground NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_BELOW_NORMAL
 	 8 ABOVE_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_LOWEST
 	 9 NORMAL_PRIORITY_CLASS              THREAD_PRIORITY_HIGHEST
 	 9 Foreground NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_NORMAL
 	 9 ABOVE_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_BELOW_NORMAL
 	10 Foreground NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_ABOVE_NORMAL
 	10 ABOVE_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_NORMAL
 	11 Foreground NORMAL_PRIORITY_CLASS   THREAD_PRIORITY_HIGHEST
 	11 ABOVE_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_ABOVE_NORMAL
 	11 HIGH_PRIORITY_CLASS                THREAD_PRIORITY_LOWEST
 	12 ABOVE_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_HIGHEST
 	12 HIGH_PRIORITY_CLASS                THREAD_PRIORITY_BELOW_NORMAL
 	13 HIGH_PRIORITY_CLASS                THREAD_PRIORITY_NORMAL
 	14 HIGH_PRIORITY_CLASS                THREAD_PRIORITY_ABOVE_NORMAL
 	15 HIGH_PRIORITY_CLASS                THREAD_PRIORITY_HIGHEST
 	15 HIGH_PRIORITY_CLASS                THREAD_PRIORITY_TIME_CRITICAL
 	15 IDLE_PRIORITY_CLASS                THREAD_PRIORITY_TIME_CRITICAL
 	15 BELOW_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_TIME_CRITICAL
 	15 NORMAL_PRIORITY_CLASS              THREAD_PRIORITY_TIME_CRITICAL
 	15 ABOVE_NORMAL_PRIORITY_CLASS        THREAD_PRIORITY_TIME_CRITICAL
 	16 REALTIME_PRIORITY_CLASS            THREAD_PRIORITY_IDLE
 	17 REALTIME_PRIORITY_CLASS            -7
 	18 REALTIME_PRIORITY_CLASS            -6
 	19 REALTIME_PRIORITY_CLASS            -5
 	20 REALTIME_PRIORITY_CLASS            -4
 	21 REALTIME_PRIORITY_CLASS            -3
 	22 REALTIME_PRIORITY_CLASS            THREAD_PRIORITY_LOWEST
 	23 REALTIME_PRIORITY_CLASS            THREAD_PRIORITY_BELOW_NORMAL
 	24 REALTIME_PRIORITY_CLASS            THREAD_PRIORITY_NORMAL
 	25 REALTIME_PRIORITY_CLASS            THREAD_PRIORITY_ABOVE_NORMAL
 	26 REALTIME_PRIORITY_CLASS            THREAD_PRIORITY_HIGHEST
 	27 REALTIME_PRIORITY_CLASS             3
 	28 REALTIME_PRIORITY_CLASS             4
 	29 REALTIME_PRIORITY_CLASS             5
 	30 REALTIME_PRIORITY_CLASS             6
 	31 REALTIME_PRIORITY_CLASS            THREAD_PRIORITY_TIME_CRITICAL
 	Windows NT:  Values -7, -6, -5, -4, -3, 3, 4, 5, and 6 are not supported.
 	As you can see, the real priority levels available to any individual
 	Win32 thread are non-contiguous.
 	An application using pthreads-win32 should not make assumptions about
 	the numbers used to represent thread priority levels, except that they
 	are monotonic between the values returned by sched_get_priority_min()
 	and sched_get_priority_max(). E.g. Windows 95, 98, NT, 2000, XP make
 	available a non-contiguous range of numbers between -15 and 15, while
 	at least one version of WinCE (3.0) defines the minimum priority
 	(THREAD_PRIORITY_LOWEST) as 5, and the maximum priority
 	(THREAD_PRIORITY_HIGHEST) as 1.
 	Internally, pthreads-win32 maps any priority levels between
 	THREAD_PRIORITY_IDLE and THREAD_PRIORITY_LOWEST to THREAD_PRIORITY_LOWEST,
 	or between THREAD_PRIORITY_TIME_CRITICAL and THREAD_PRIORITY_HIGHEST to
 	THREAD_PRIORITY_HIGHEST. Currently, this also applies to
 	REALTIME_PRIORITY_CLASSi even if levels -7, -6, -5, -4, -3, 3, 4, 5, and 6
 	are supported.
 	If it wishes, a Win32 application using pthreads-win32 can use the Win32
 	defined priority macros THREAD_PRIORITY_IDLE through
 	THREAD_PRIORITY_TIME_CRITICAL.
 The opacity of the pthread_t datatype
 -------------------------------------
 and possible solutions for portable null/compare/hash, etc
 ----------------------------------------------------------
 Because pthread_t is an opague datatype an implementation is permitted to define
 pthread_t in any way it wishes. That includes defining some bits, if it is
 scalar, or members, if it is an aggregate, to store information that may be
 extra to the unique identifying value of the ID. As a result, pthread_t values
 may not be directly comparable.
 If you want your code to be portable you must adhere to the following contraints:
 1) Don't assume it is a scalar data type, e.g. an integer or pointer value. There
 are several other implementations where pthread_t is also a struct. See our FAQ
 Question 11 for our reasons for defining pthread_t as a struct.
 2) You must not compare them using relational or equality operators. You must use
 the API function pthread_equal() to test for equality.
 3) Never attempt to reference individual members.
 The problem
 Certain applications would like to be able to access only the 'pure' pthread_t
 id values, primarily to use as keys into data structures to manage threads or
 thread-related data, but this is not possible in a maximally portable and
 standards compliant way for current POSIX threads implementations.
 For implementations that define pthread_t as a scalar, programmers often employ
 direct relational and equality operators on pthread_t. This code will break when
 ported to an implementation that defines pthread_t as an aggregate type.
 For implementations that define pthread_t as an aggregate, e.g. a struct,
 programmers can use memcmp etc., but then face the prospect that the struct may
 include alignment padding bytes or bits as well as extra implementation-specific
 members that are not part of the unique identifying value.
 [While this is not currently the case for pthreads-win32, opacity also
 means that an implementation is free to change the definition, which should
 generally only require that applications be recompiled and relinked, not
 rewritten.]
 Doesn't the compiler take care of padding?
 The C89 and later standards only effectively guarrantee element-by-element
 equivalence following an assignment or pass by value of a struct or union,
 therefore undefined areas of any two otherwise equivalent pthread_t instances
 can still compare differently, e.g. attempting to compare two such pthread_t
 variables byte-by-byte, e.g. memcmp(&t1, &t2, sizeof(pthread_t) may give an
 incorrect result. In practice I'm reasonably confident that compilers routinely
 also copy the padding bytes, mainly because assignment of unions would be far
 too complicated otherwise. But it just isn't guarranteed by the standard.
 Illustration:
 We have two thread IDs t1 and t2
 pthread_t t1, t2;
 In an application we create the threads and intend to store the thread IDs in an
 ordered data structure (linked list, tree, etc) so we need to be able to compare
 them in order to insert them initially and also to traverse.
 Suppose pthread_t contains undefined padding bits and our compiler copies our
 pthread_t [struct] element-by-element, then for the assignment:
 pthread_t temp = t1;
 temp and t1 will be equivalent and correct but a byte-for-byte comparison such as
 memcmp(&temp, &t1, sizeof(pthread_t)) == 0 may not return true as we expect because
 the undefined bits may not have the same values in the two variable instances.
 Similarly if passing by value under the same conditions.
 If, on the other hand, the undefined bits are at least constant through every
 assignment and pass-by-value then the byte-for-byte comparison
 memcmp(&temp, &t1, sizeof(pthread_t)) == 0 will always return the expected result.
 How can we force the behaviour we need?
 Solutions
 Adding new functions to the standard API or as non-portable extentions is
 the only reliable and portable way to provide the necessary operations.
 Remember also that POSIX is not tied to the C language. The most common
 functions that have been suggested are:
 pthread_null()
 pthread_compare()
 pthread_hash()
 A single more general purpose function could also be defined as a
 basis for at least the last two of the above functions.
 First we need to list the freedoms and constraints with restpect
 to pthread_t so that we can be sure our solution is compatible with the
 standard.
 What is known or may be deduced from the standard:
 1) pthread_t must be able to be passed by value, so it must be a single object.
 2) from (1) it must be copyable so cannot embed thread-state information, locks
 or other volatile objects required to manage the thread it associates with.
 3) pthread_t may carry additional information, e.g. for debugging or to manage
 itself.
 4) there is an implicit requirement that the size of pthread_t is determinable
 at compile-time and size-invariant, because it must be able to copy the object
 (i.e. through assignment and pass-by-value). Such copies must be genuine
 duplicates, not merely a copy of a pointer to a common instance such as
 would be the case if pthread_t were defined as an array.
 Suppose we define the following function:
 /* This function shall return it's argument */
 pthread_t* pthread_normalize(pthread_t* thread);
 For scalar or aggregate pthread_t types this function would simply zero any bits
 within the pthread_t that don't uniquely identify the thread, including padding,
 such that client code can return consistent results from operations done on the
 result. If the additional bits are a pointer to an associate structure then
 this function would ensure that the memory used to store that associate
 structure does not leak. After normalization the following compare would be
 valid and repeatable:
 memcmp(pthread_normalize(&t1),pthread_normalize(&t2),sizeof(pthread_t))
 Note 1: such comparisons are intended merely to order and sort pthread_t values
 and allow them to index various data structures. They are not intended to reveal
 anything about the relationships between threads, like startup order.
 Note 2: the normalized pthread_t is also a valid pthread_t that uniquely
 identifies the same thread.
 Advantages:
 1) In most existing implementations this function would reduce to a no-op that
 emits no additional instructions, i.e after in-lining or optimisation, or if
 defined as a macro:
 #define pthread_normalise(tptr) (tptr)
 2) This single function allows an application to portably derive
 application-level versions of any of the other required functions.
 3) It is a generic function that could enable unanticipated uses.
 Disadvantages:
 1) Less efficient than dedicated compare or hash functions for implementations
 that include significant extra non-id elements in pthread_t.
 2) Still need to be concerned about padding if copying normalized pthread_t.
 See the later section on defining pthread_t to neutralise padding issues.
 Generally a pthread_t may need to be normalized every time it is used,
 which could have a significant impact. However, this is a design decision
 for the implementor in a competitive environment. An implementation is free
 to define a pthread_t in a way that minimises or eliminates padding or
 renders this function a no-op.
 Hazards:
 1) Pass-by-reference directly modifies 'thread' so the application must
 synchronise access or ensure that the pointer refers to a copy. The alternative
 of pass-by-value/return-by-value was considered but then this requires two copy
 operations, disadvantaging implementations where this function is not a no-op
 in terms of speed of execution. This function is intended to be used in high
 frequency situations and needs to be efficient, or at least not unnecessarily
 inefficient. The alternative also sits awkwardly with functions like memcmp.
 2) [Non-compliant] code that uses relational and equality operators on
 arithmetic or pointer style pthread_t types would need to be rewritten, but it
 should be rewritten anyway.
 C implementation of null/compare/hash functions using pthread_normalize():
 /* In pthread.h */
 pthread_t* pthread_normalize(pthread_t* thread);
 /* In user code */
 /* User-level bitclear function - clear bits in loc corresponding to mask */
 void* bitclear (void* loc, void* mask, size_t count);
 typedef unsigned int hash_t;
 /* User-level hash function */
 hash_t hash(void* ptr, size_t count);
 /*
 * User-level pthr_null function - modifies the origin thread handle.
 * The concept of a null pthread_t is highly implementation dependent
 * and this design may be far from the mark. For example, in an
 * implementation "null" may mean setting a special value inside one
 * element of pthread_t to mean "INVALID". However, if that value was zero and
 * formed part of the id component then we may get away with this design.
 */
 pthread_t* pthr_null(pthread_t* tp)
 {
  /* 
   * This should have the same effect as memset(tp, 0, sizeof(pthread_t))
   * We're just showing that we can do it.
   */
  void* p = (void*) pthread_normalize(tp);
  return (pthread_t*) bitclear(p, p, sizeof(pthread_t));
 }
 /*
 * Safe user-level pthr_compare function - modifies temporary thread handle copies
 */
 int pthr_compare_safe(pthread_t thread1, pthread_t thread2)
 {
  return memcmp(pthread_normalize(&thread1), pthread_normalize(&thread2), sizeof(pthread_t));
 }
 /*
 * Fast user-level pthr_compare function - modifies origin thread handles
 */
 int pthr_compare_fast(pthread_t* thread1, pthread_t* thread2)
 {
  return memcmp(pthread_normalize(&thread1), pthread_normalize(&thread2), sizeof(pthread_t));
 }
 /*
 * Safe user-level pthr_hash function - modifies temporary thread handle copy
 */
 hash_t pthr_hash_safe(pthread_t thread)
 {
  return hash((void *) pthread_normalize(&thread), sizeof(pthread_t));
 }
 /*
 * Fast user-level pthr_hash function - modifies origin thread handle
 */
 hash_t pthr_hash_fast(pthread_t thread)
 {
  return hash((void *) pthread_normalize(&thread), sizeof(pthread_t));
 }
 /* User-level bitclear function - modifies the origin array */
 void* bitclear(void* loc, void* mask, size_t count)
 {
  int i;
  for (i=0; i < count; i++) {
    (unsigned char) *loc++ &= ~((unsigned char) *mask++);
  }
 }
 /* Donald Knuth hash */
 hash_t hash(void* str, size_t count)
 {
   hash_t hash = (hash_t) count;
   unsigned int i = 0;
   for(i = 0; i < len; str++, i++)
   {
      hash = ((hash << 5) ^ (hash >> 27)) ^ (*str);
   }
   return hash;
 }
 /* Example of advantage point (3) - split a thread handle into its id and non-id values */
 pthread_t id = thread, non-id = thread;
 bitclear((void*) &non-id, (void*) pthread_normalize(&id), sizeof(pthread_t));
 A pthread_t type change proposal to neutralise the effects of padding
 Even if pthread_nornalize() is available, padding is still a problem because
 the standard only garrantees element-by-element equivalence through
 copy operations (assignment and pass-by-value). So padding bit values can
 still change randomly after calls to pthread_normalize().
 [I suspect that most compilers take the easy path and always byte-copy anyway,
 partly because it becomes too complex to do (e.g. unions that contain sub-aggregates)
 but also because programmers can easily design their aggregates to minimise and
 often eliminate padding].
 How can we eliminate the problem of padding bytes in structs? Could
 defining pthread_t as a union rather than a struct provide a solution?
 In fact, the Linux pthread.h defines most of it's pthread_*_t objects (but not
 pthread_t itself) as unions, possibly for this and/or other reasons. We'll
 borrow some element naming from there but the ideas themselves are well known
 - the __align element used to force alignment of the union comes from K&R's
 storage allocator example.
 /* Essentially our current pthread_t renamed */
 typedef struct {
  struct thread_state_t * __p;
  long __x; /* sequence counter */
 } thread_id_t;
 Ensuring that the last element in the above struct is a long ensures that the
 overall struct size is a multiple of sizeof(long), so there should be no trailing
 padding in this struct or the union we define below.
 (Later we'll see that we can handle internal but not trailing padding.)
 /* New pthread_t */
 typedef union {
  char __size[sizeof(thread_id_t)]; /* array as the first element */
  thread_id_t __tid;
  long __align;  /* Ensure that the union starts on long boundary */
 } pthread_t;
 This guarrantees that, during an assignment or pass-by-value, the compiler copies
 every byte in our thread_id_t because the compiler guarrantees that the __size
 array, which we have ensured is the equal-largest element in the union, retains
 equivalence.
 This means that pthread_t values stored, assigned and passed by value will at least
 carry the value of any undefined padding bytes along and therefore ensure that
 those values remain consistent. Our comparisons will return consistent results and
 our hashes of [zero initialised] pthread_t values will also return consistent
 results.
 We have also removed the need for a pthread_null() function; we can initialise
 at declaration time or easily create our own const pthread_t to use in assignments
 later:
 const pthread_t null_tid = {0}; /* braces are required */
 pthread_t t;
 ...
 t = null_tid;
 Note that we don't have to explicitly make use of the __size array at all. It's
 there just to force the compiler behaviour we want.
 Partial solutions without a pthread_normalize function
 An application-level pthread_null and pthread_compare proposal
 (and pthread_hash proposal by extention)
 In order to deal with the problem of scalar/aggregate pthread_t type disparity in
 portable code I suggest using an old-fashioned union, e.g.:
 Contraints:
 - there is no padding, or padding values are preserved through assignment and
  pass-by-value (see above);
 - there are no extra non-id values in the pthread_t.
 Example 1: A null initialiser for pthread_t variables...
 typedef union {
    unsigned char b[sizeof(pthread_t)];
    pthread_t t;
 } init_t;
 const init_t initial = {0};
 pthread_t tid = initial.t; /* init tid to all zeroes */
 Example 2: A comparison function for pthread_t values
 typedef union {
   unsigned char b[sizeof(pthread_t)];
   pthread_t t;
 } pthcmp_t;
 int pthcmp(pthread_t left, pthread_t right)
 {
  /*
  * Compare two pthread handles in a way that imposes a repeatable but arbitrary
  * ordering on them.
  * I.e. given the same set of pthread_t handles the ordering should be the same
  * each time but the order has no particular meaning other than that. E.g.
  * the ordering does not imply the thread start sequence, or any other
  * relationship between threads.
  *
  * Return values are:
  * 1 : left is greater than right
  * 0 : left is equal to right
  * -1 : left is less than right
  */
  int i;
  pthcmp_t L, R;
  L.t = left;
  R.t = right;
  for (i = 0; i < sizeof(pthread_t); i++)
  {
    if (L.b[i] > R.b[i])
      return 1;
    else if (L.b[i] < R.b[i])
      return -1;
  }
  return 0;
 }
 It has been pointed out that the C99 standard allows for the possibility that
 integer types also may include padding bits, which could invalidate the above
 method. This addition to C99 was specifically included after it was pointed
 out that there was one, presumably not particularly well known, architecture
 that included a padding bit in it's 32 bit integer type. See section 6.2.6.2
 of both the standard and the rationale, specifically the paragraph starting at
 line 16 on page 43 of the rationale.
 An aside
 Certain compilers, e.g. gcc and one of the IBM compilers, include a feature
 extention: provided the union contains a member of the same type as the
 object then the object may be cast to the union itself.
 We could use this feature to speed up the pthrcmp() function from example 2
 above by casting rather than assigning the pthread_t arguments to the union, e.g.:
 int pthcmp(pthread_t left, pthread_t right)
 {
  /*
  * Compare two pthread handles in a way that imposes a repeatable but arbitrary
  * ordering on them.
  * I.e. given the same set of pthread_t handles the ordering should be the same
  * each time but the order has no particular meaning other than that. E.g.
  * the ordering does not imply the thread start sequence, or any other
  * relationship between threads.
  *
  * Return values are:
  * 1 : left is greater than right
  * 0 : left is equal to right
  * -1 : left is less than right
  */
  int i;
  for (i = 0; i < sizeof(pthread_t); i++)
  {
    if (((pthcmp_t)left).b[i] > ((pthcmp_t)right).b[i])
      return 1;
    else if (((pthcmp_t)left).b[i] < ((pthcmp_t)right).b[i])
      return -1;
  }
  return 0;
 }
 Result thus far
 We can't remove undefined bits if they are there in pthread_t already, but we have
 attempted to render them inert for comparison and hashing functions by making them
 consistent through assignment, copy and pass-by-value.
 Note: Hashing pthread_t values requires that all pthread_t variables be initialised
 to the same value (usually all zeros) before being assigned a proper thread ID, i.e.
 to ensure that any padding bits are zero, or at least the same value for all
 pthread_t. Since all pthread_t values are generated by the library in the first
 instance this need not be an application-level operation.
 Conclusion
 I've attempted to resolve the multiple issues of type opacity and the possible
 presence of undefined bits and bytes in pthread_t values, which prevent
 applications from comparing or hashing pthread handles.
 Two complimentary partial solutions have been proposed, one an application-level
 scheme to handle both scalar and aggregate pthread_t types equally, plus a
 definition of pthread_t itself that neutralises padding bits and bytes by
 coercing semantics out of the compiler to eliminate variations in the values of
 padding bits.
 I have not provided any solution to the problem of handling extra values embedded
 in pthread_t, e.g. debugging or trap information that an implementation is entitled
 to include. Therefore none of this replaces the portability and flexibility of API
 functions but what functions are needed? The threads standard is unlikely to
 include that can be implemented by a combination of existing features and more
 generic functions (several references in the threads rationale suggest this.
 Therefore I propose that the following function could replace the several functions
 that have been suggested in conversations:
 pthread_t * pthread_normalize(pthread_t * handle);
 For most existing pthreads implementations this function, or macro, would reduce to
 a no-op with zero call overhead.
--- a/deps/uv/deps/pthread-win32/README.Watcom
+++ b/deps/uv/deps/pthread-win32/README.Watcom
@ -1,62 +0,0 @@
 Watcom compiler notes
 =====================
 Status
 ------
 Not yet usable. Although the library builds under Watcom it
 substantially fails the test suite.
 There is a working Wmakefile for wmake for the library build.
 invoke as any of:
 wmake -f Wmakefile clean WC
 wmake -f Wmakefile clean WC-inlined
 wmake -f Wmakefile clean WCE
 wmake -f Wmakefile clean WCE-inlined
 These build pthreadWC.dll and pthreadWCE.dll.
 There is a working Wmakefile for wmake for the test suite.
 invoke as any of:
 wmake -f Wmakefile clean WC
 wmake -f Wmakefile clean WCX
 wmake -f Wmakefile clean WCE
 wmake -f Wmakefile clean WC-bench
 wmake -f Wmakefile clean WCX-bench
 wmake -f Wmakefile clean WCE-bench
 Current known problems
 ----------------------
 Library build:
 The Watcom compiler uses a different default call convention to MS C or GNU C and so
 applications are not compatible with pthreadVC.dll etc using pre 2003-10-14 versions
 of pthread.h, sched.h, or semaphore.h. The cdecl attribute can be used on exposed
 function prototypes to force compatibility with MS C built DLLs.
 However, there appear to be other incompatibilities. Errno.h, for example, defines
 different values for the standard C and POSIX errors to those defined by the MS C
 errno.h. It may be that references to Watcom's threads compatible 'errno' do set
 and return translated numbers consistently, but I have not verified this.
 Watcom defines errno as a dereferenced pointer returned by the function
 _get_errno_ptr(). This is similar to both the MS and GNU C environments for
 multithreaded use. However, the Watcom version appears to have a number of problems:
 - different threads return the same pointer value. Compare with the MS and GNU C
 versions which correctly return different values (since each thread must maintain
 a thread specific errno value).
 - an errno value set within the DLL appears as zero in the application even though
 both share the same thread.
 Therefore applications built using the Watcom compiler may need to use
 a Watcom built version of the library (pthreadWC.dll). If this is the case, then
 the cdecl function attribute should not be required.
 Application builds:
 The test suite fails with the Watcom compiler.
 Test semaphore1.c fails for pthreadWC.dll because errno returns 0 instead of EAGAIN.
--- a/deps/uv/deps/pthread-win32/README.WinCE
+++ b/deps/uv/deps/pthread-win32/README.WinCE
@ -1,6 +0,0 @@
 WinCE port
 ----------
 (See the file WinCE-PORT for a detailed explanation.)
 Make sure you define "WINCE" amongst your compiler flags (eg. -DWINCE).
 The config.h file will define all the necessary defines for you.
--- a/deps/uv/deps/pthread-win32/TODO
+++ b/deps/uv/deps/pthread-win32/TODO
@ -1,7 +0,0 @@
                   Things that aren't done yet
                   ---------------------------
 1. Implement PTHREAD_PROCESS_SHARED for semaphores, mutexes,
   condition variables, read/write locks, barriers.
--- a/deps/uv/deps/pthread-win32/WinCE-PORT
+++ b/deps/uv/deps/pthread-win32/WinCE-PORT
@ -1,222 +0,0 @@
 NOTE: The comments in this file relate to the original WinCE port
 done by Tristan Savatier. The semaphore routines have been 
 completely rewritten since (2005-04-25), having been progressively
 broken more and more by changes to the library. All of the semaphore
 routines implemented for W9x/WNT/2000 and up should now also work for
 WinCE. Also, pthread_mutex_timedlock should now work.
 Additional WinCE updates have been applied since this as well. Check the
 ChangeLog file and search for WINCE for example. (2007-01-07)
 [RPJ]
 ----
 Some interesting news:
 I have been able to port pthread-win32 to Windows-CE,
 which uses a subset of the WIN32 API.
 Since we intend to keep using pthread-win32 for our
 Commercial WinCE developments, I would be very interested
 if WinCE support could be added to the main source tree
 of pthread-win32.  Also, I would like to be credited
 for this port :-)
 Now, here is the story...
 The port was performed and tested on a Casio "Cassiopeia"
 PalmSize PC, which runs a MIP processor.  The OS in the
 Casio is WinCE version 2.11, but I used VC++ 6.0 with
 the WinCE SDK for version 2.01.
 I used pthread-win32 to port a heavily multithreaded
 commercial application (real-time MPEG video player)
 from Linux to WinCE.  I consider the changes that
 I have done to be quite well tested.
 Overall the modifications that we had to do are minor.
 The WinCE port were based on pthread-win32-snap-1999-05-30,
 but I am certain that they can be integrated very easiely
 to more recent versions of the source.
 I have attached the modified source code:
 pthread-win32-snap-1999-05-30-WinCE.
 All the changes do not affect the code compiled on non-WinCE
 environment, provided that the macros used for WinCE compilation
 are not used, of course!
 Overall description of the WinCE port:
 -------------------------------------
 Most of the changes had to be made in areas where
 pthread-win32 was relying on some standard-C librairies
 (e.g. _ftime, calloc, errno), which are not available
 on WinCE. We have changed the code to use native Win32
 API instead (or in some cases we made wrappers).
 The Win32 Semaphores are not available,
 so we had to re-implement Semaphores using mutexes
 and events.
 Limitations / known problems of the WinCE port:
 ----------------------------------------------
 Not all the semaphore routines have been ported
 (semaphores are defined by Posix but are not part
 pf pthread).  I have just done enough to make
 pthread routines (that rely internally on semaphores)
 work, like signal conditions.
 I noticed that the Win32 threads work slightly
 differently on WinCE.  This may have some impact
 on some tricky parts of pthread-win32, but I have
 not really investigated.  For example, on WinCE,
 the process is killed if the main thread falls off
 the bottom (or calls pthread_exit), regardless
 of the existence of any other detached thread.
 Microsoft manual indicates that this behavior is
 deffirent from that of Windows Threads for other
 Win32 platforms.
 Detailed descriptions of the changes and rationals:
 ------------------------------------
 - use a new macro NEED_ERRNO.
 If defined, the code in errno.c that defines a reentrant errno
 is compiled, regardless of _MT and _REENTRANT.
 Rational: On WinCE, there is no support for <stdio.h>, <errno.h> or
 any other standard C library, i.e. even if _MT or _REENTRANT
 is defined, errno is not provided by any library.  NEED_ERRNO
 must be set to compile for WinCE.
 ------------------------------------
 - In implement.h, change #include <semaphore.h> to #include "semaphore.h".
 Rational: semaphore.h is provided in pthread-win32 and should not
 be searched in the systems standard include.  would not compile.
 This change does not seem to create problems on "classic" win32
 (e.g. win95).
 ------------------------------------
 - use a new macro NEED_CALLOC.
 If defined, some code in misc.c will provide a replacement
 for calloc, which is not available on Win32.
 ------------------------------------
 - use a new macro NEED_CREATETHREAD.
 If defined, implement.h defines the macro _beginthreadex
 and _endthreadex.
 Rational: On WinCE, the wrappers _beginthreadex and _endthreadex
 do not exist. The native Win32 routines must be used.
 ------------------------------------
 - in misc.c:
 #ifdef NEED_DUPLICATEHANDLE
 	  /* DuplicateHandle does not exist on WinCE */
 	  self->threadH = GetCurrentThread();
 #else
 	  if( !DuplicateHandle(
 			       GetCurrentProcess(),
 			       GetCurrentThread(),
 			       GetCurrentProcess(),
 			       &self->threadH,
 			       0,
 			       FALSE,
 			       DUPLICATE_SAME_ACCESS ) )
 	    {
 	      free( self );
 	      return (NULL);
 	    }
 #endif
 Rational: On WinCE, DuplicateHandle does not exist.  I could not understand
 why DuplicateHandle must be used.  It seems to me that getting the current
 thread handle with GetCurrentThread() is sufficient, and it seems to work
 perfectly fine, so maybe DuplicateHandle was just plain useless to begin with ?
 ------------------------------------
 - In private.c, added some code at the beginning of ptw32_processInitialize
 to detect the case of multiple calls to ptw32_processInitialize.
 Rational: In order to debug pthread-win32, it is easier to compile
 it as a regular library (it is not possible to debug DLL's on winCE).
 In that case, the application must call ptw32_rocessInitialize()
 explicitely, to initialize pthread-win32.  It is safer in this circumstance
 to handle the case where ptw32_processInitialize() is called on
 an already initialized library:
 int
 ptw32_processInitialize (void)
 {
 	if (ptw32_processInitialized) {
 		/* 
 		 * ignore if already initialized. this is useful for 
 		 * programs that uses a non-dll pthread
 		 * library. such programs must call ptw32_processInitialize() explicitely,
 		 * since this initialization routine is automatically called only when
 		 * the dll is loaded.
 		 */
 		return TRUE;
 	}
    ptw32_processInitialized = TRUE;
  	[...]
 }
 ------------------------------------
 - in private.c, if macro NEED_FTIME is defined, add routines to
 convert timespec_to_filetime and filetime_to_timespec, and modified
 code that was using _ftime() to use Win32 API instead.
 Rational: _ftime is not available on WinCE.  It is necessary to use
 the native Win32 time API instead.
 Note: the routine timespec_to_filetime is provided as a convenience and a mean
 to test that filetime_to_timespec works, but it is not used by the library.
 ------------------------------------
 - in semaphore.c, if macro NEED_SEM is defined, add code for the routines
 _increase_semaphore and _decrease_semaphore, and modify significantly
 the implementation of the semaphores so that it does not use CreateSemaphore.
 Rational: CreateSemaphore is not available on WinCE.  I had to re-implement
 semaphores using mutexes and Events.
 Note: Only the semaphore routines that are used by pthread are implemented
 (i.e. signal conditions rely on a subset of the semaphores routines, and
 this subset works). Some other semaphore routines (e.g. sem_trywait) are
 not yet supported on my WinCE port (and since I don't need them, I am not
 planning to do anything about them).
 ------------------------------------
 - in tsd.c, changed the code that defines TLS_OUT_OF_INDEXES
 /* TLS_OUT_OF_INDEXES not defined on WinCE */
 #ifndef TLS_OUT_OF_INDEXES
 #define TLS_OUT_OF_INDEXES 0xffffffff
 #endif
 Rational: TLS_OUT_OF_INDEXES is not defined in any standard include file
 on WinCE.
 ------------------------------------
 - added file need_errno.h
 Rational: On WinCE, there is no errno.h file. need_errno.h is just a
 copy of windows version of errno.h, with minor modifications due to the fact
 that some of the error codes are defined by the WinCE socket library.
 In pthread.h, if NEED_ERRNO is defined, the file need_errno.h is
 included (instead of <errno.h>).
 -- eof
--- a/deps/uv/deps/pthread-win32/attr.c
+++ b/deps/uv/deps/pthread-win32/attr.c
@ -1,53 +0,0 @@
 /*
 * attr.c
 *
 * Description:
 * This translation unit agregates operations on thread attribute objects.
 * It is used for inline optimisation.
 *
 * The included modules are used separately when static executable sizes
 * must be minimised.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "pthread_attr_init.c"
 #include "pthread_attr_destroy.c"
 #include "pthread_attr_getdetachstate.c"
 #include "pthread_attr_setdetachstate.c"
 #include "pthread_attr_getstackaddr.c"
 #include "pthread_attr_setstackaddr.c"
 #include "pthread_attr_getstacksize.c"
 #include "pthread_attr_setstacksize.c"
 #include "pthread_attr_getscope.c"
 #include "pthread_attr_setscope.c"
--- a/deps/uv/deps/pthread-win32/autostatic.c
+++ b/deps/uv/deps/pthread-win32/autostatic.c
@ -1,69 +0,0 @@
 /*
 * autostatic.c
 *
 * Description:
 * This translation unit implements static auto-init and auto-exit logic.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 *
 *      Contact Email: rpj@callisto.canberra.edu.au
 *
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 *
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 *
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 *
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #if defined(PTW32_STATIC_LIB)
 #if defined(__MINGW64__) || defined(__MINGW32__) || defined(_MSC_VER)
 #include "pthread.h"
 #include "implement.h"
 static void on_process_init(void)
 {
    pthread_win32_process_attach_np ();
 }
 static void on_process_exit(void)
 {
    pthread_win32_thread_detach_np  ();
    pthread_win32_process_detach_np ();
 }
 #if defined(__MINGW64__) || defined(__MINGW32__)
 # define attribute_section(a) __attribute__((section(a)))
 #elif defined(_MSC_VER)
 # define attribute_section(a) __pragma(section(a,long,read)); __declspec(allocate(a))
 #endif
 attribute_section(".ctors") void *gcc_ctor = on_process_init;
 attribute_section(".dtors") void *gcc_dtor = on_process_exit;
 attribute_section(".CRT$XCU") void *msc_ctor = on_process_init;
 attribute_section(".CRT$XPU") void *msc_dtor = on_process_exit;
 #endif /* defined(__MINGW64__) || defined(__MINGW32__) || defined(_MSC_VER) */
 #endif /* PTW32_STATIC_LIB */
--- a/deps/uv/deps/pthread-win32/barrier.c
+++ b/deps/uv/deps/pthread-win32/barrier.c
@ -1,47 +0,0 @@
 /*
 * barrier.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "pthread_barrier_init.c"
 #include "pthread_barrier_destroy.c"
 #include "pthread_barrier_wait.c"
 #include "pthread_barrierattr_init.c"
 #include "pthread_barrierattr_destroy.c"
 #include "pthread_barrierattr_getpshared.c"
 #include "pthread_barrierattr_setpshared.c"
--- a/deps/uv/deps/pthread-win32/builddmc.bat
+++ b/deps/uv/deps/pthread-win32/builddmc.bat
@ -1,9 +0,0 @@
 ; Build the pthreads library with the Digital Mars Compiler
 ;
 set DMCDIR=c:\dm
 ;   RELEASE
 %DMCDIR%\bin\dmc -D_WIN32_WINNT -D_MT -DHAVE_PTW32_CONFIG_H -I.;c:\dm\include -o+all -WD pthread.c user32.lib+kernel32.lib+wsock32.lib -L/impl -L/NODEBUG -L/SU:WINDOWS
 ;   DEBUG
 %DMCDIR%\bin\dmc -g -D_WIN32_WINNT -D_MT -DHAVE_PTW32_CONFIG_H -I.;c:\dm\include -o+all -WD pthread.c user32.lib+kernel32.lib+wsock32.lib -L/impl -L/SU:WINDOWS
--- a/deps/uv/deps/pthread-win32/cancel.c
+++ b/deps/uv/deps/pthread-win32/cancel.c
@ -1,44 +0,0 @@
 /*
 * cancel.c
 *
 * Description:
 * POSIX thread functions related to thread cancellation.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "pthread_setcancelstate.c"
 #include "pthread_setcanceltype.c"
 #include "pthread_testcancel.c"
 #include "pthread_cancel.c"
--- a/deps/uv/deps/pthread-win32/cleanup.c
+++ b/deps/uv/deps/pthread-win32/cleanup.c
@ -1,148 +0,0 @@
 /*
 * cleanup.c
 *
 * Description:
 * This translation unit implements routines associated
 * with cleaning up threads.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 * The functions ptw32_pop_cleanup and ptw32_push_cleanup
 * are implemented here for applications written in C with no
 * SEH or C++ destructor support. 
 */
 ptw32_cleanup_t *
 ptw32_pop_cleanup (int execute)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function pops the most recently pushed cleanup
      *      handler. If execute is nonzero, then the cleanup handler
      *      is executed if non-null.
      *
      * PARAMETERS
      *      execute
      *              if nonzero, execute the cleanup handler
      *
      *
      * DESCRIPTION
      *      This function pops the most recently pushed cleanup
      *      handler. If execute is nonzero, then the cleanup handler
      *      is executed if non-null.
      *      NOTE: specify 'execute' as nonzero to avoid duplication
      *                of common cleanup code.
      *
      * RESULTS
      *              N/A
      *
      * ------------------------------------------------------
      */
 {
  ptw32_cleanup_t *cleanup;
  cleanup = (ptw32_cleanup_t *) pthread_getspecific (ptw32_cleanupKey);
  if (cleanup != NULL)
    {
      if (execute && (cleanup->routine != NULL))
 	{
 	  (*cleanup->routine) (cleanup->arg);
 	}
      pthread_setspecific (ptw32_cleanupKey, (void *) cleanup->prev);
    }
  return (cleanup);
 }				/* ptw32_pop_cleanup */
 void
 ptw32_push_cleanup (ptw32_cleanup_t * cleanup,
 		    ptw32_cleanup_callback_t routine, void *arg)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function pushes a new cleanup handler onto the thread's stack
      *      of cleanup handlers. Each cleanup handler pushed onto the stack is
      *      popped and invoked with the argument 'arg' when
      *              a) the thread exits by calling 'pthread_exit',
      *              b) when the thread acts on a cancellation request,
      *              c) or when the thread calls pthread_cleanup_pop with a nonzero
      *                 'execute' argument
      *
      * PARAMETERS
      *      cleanup
      *              a pointer to an instance of pthread_cleanup_t,
      *
      *      routine
      *              pointer to a cleanup handler,
      *
      *      arg
      *              parameter to be passed to the cleanup handler
      *
      *
      * DESCRIPTION
      *      This function pushes a new cleanup handler onto the thread's stack
      *      of cleanup handlers. Each cleanup handler pushed onto the stack is
      *      popped and invoked with the argument 'arg' when
      *              a) the thread exits by calling 'pthread_exit',
      *              b) when the thread acts on a cancellation request,
      *              c) or when the thrad calls pthread_cleanup_pop with a nonzero
      *                 'execute' argument
      *      NOTE: pthread_push_cleanup, ptw32_pop_cleanup must be paired
      *                in the same lexical scope.
      *
      * RESULTS
      *              pthread_cleanup_t *
      *                              pointer to the previous cleanup
      *
      * ------------------------------------------------------
      */
 {
  cleanup->routine = routine;
  cleanup->arg = arg;
  cleanup->prev = (ptw32_cleanup_t *) pthread_getspecific (ptw32_cleanupKey);
  pthread_setspecific (ptw32_cleanupKey, (void *) cleanup);
 }				/* ptw32_push_cleanup */
--- a/deps/uv/deps/pthread-win32/condvar.c
+++ b/deps/uv/deps/pthread-win32/condvar.c
@ -1,50 +0,0 @@
 /*
 * condvar.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 *
 */
 #include "pthread.h"
 #include "implement.h"
 #include "ptw32_cond_check_need_init.c"
 #include "pthread_condattr_init.c"
 #include "pthread_condattr_destroy.c"
 #include "pthread_condattr_getpshared.c"
 #include "pthread_condattr_setpshared.c"
 #include "pthread_cond_init.c"
 #include "pthread_cond_destroy.c"
 #include "pthread_cond_wait.c"
 #include "pthread_cond_signal.c"
--- a/deps/uv/deps/pthread-win32/config.h
+++ b/deps/uv/deps/pthread-win32/config.h
@ -1,153 +0,0 @@
 /* config.h  */
 #ifndef PTW32_CONFIG_H
 #define PTW32_CONFIG_H
 /*********************************************************************
 * Defaults: see target specific redefinitions below.
 *********************************************************************/
 /* We're building the pthreads-win32 library */
 #define PTW32_BUILD
 /* Do we know about the C type sigset_t? */
 #undef HAVE_SIGSET_T
 /* Define if you have the <signal.h> header file.  */
 #undef HAVE_SIGNAL_H
 /* Define if you have the Borland TASM32 or compatible assembler.  */
 #undef HAVE_TASM32
 /* Define if you don't have Win32 DuplicateHandle. (eg. WinCE) */
 #undef NEED_DUPLICATEHANDLE
 /* Define if you don't have Win32 _beginthreadex. (eg. WinCE) */
 #undef NEED_CREATETHREAD
 /* Define if you don't have Win32 errno. (eg. WinCE) */
 #undef NEED_ERRNO
 /* Define if you don't have Win32 calloc. (eg. WinCE)  */
 #undef NEED_CALLOC
 /* Define if you don't have Win32 ftime. (eg. WinCE)  */
 #undef NEED_FTIME
 /* Define if you don't have Win32 semaphores. (eg. WinCE 2.1 or earlier)  */
 #undef NEED_SEM
 /* Define if you need to convert string parameters to unicode. (eg. WinCE)  */
 #undef NEED_UNICODE_CONSTS
 /* Define if your C (not C++) compiler supports "inline" functions. */
 #undef HAVE_C_INLINE
 /* Do we know about type mode_t? */
 #undef HAVE_MODE_T
 /* 
 * Define if GCC has atomic builtins, i.e. __sync_* intrinsics
 * __sync_lock_* is implemented in mingw32 gcc 4.5.2 at least
 * so this define does not turn those on or off. If you get an
 * error from __sync_lock* then consider upgrading your gcc.
 */
 #undef HAVE_GCC_ATOMIC_BUILTINS
 /* Define if you have the timespec struct */
 #undef HAVE_STRUCT_TIMESPEC
 /* Define if you don't have the GetProcessAffinityMask() */
 #undef NEED_PROCESS_AFFINITY_MASK
 /* Define if your version of Windows TLSGetValue() clears WSALastError
 * and calling SetLastError() isn't enough restore it. You'll also need to
 * link against wsock32.lib (or libwsock32.a for MinGW).
 */
 #undef RETAIN_WSALASTERROR
 /*
 # ----------------------------------------------------------------------
 # The library can be built with some alternative behaviour to better
 # facilitate development of applications on Win32 that will be ported
 # to other POSIX systems.
 #
 # Nothing described here will make the library non-compliant and strictly
 # compliant applications will not be affected in any way, but
 # applications that make assumptions that POSIX does not guarantee are
 # not strictly compliant and may fail or misbehave with some settings.
 #
 # PTW32_THREAD_ID_REUSE_INCREMENT
 # Purpose:
 # POSIX says that applications should assume that thread IDs can be
 # recycled. However, Solaris (and some other systems) use a [very large]
 # sequence number as the thread ID, which provides virtual uniqueness.
 # This provides a very high but finite level of safety for applications
 # that are not meticulous in tracking thread lifecycles e.g. applications
 # that call functions which target detached threads without some form of
 # thread exit synchronisation.
 #
 # Usage:
 # Set to any value in the range: 0 <= value < 2^wordsize.
 # Set to 0 to emulate reusable thread ID behaviour like Linux or *BSD.
 # Set to 1 for unique thread IDs like Solaris (this is the default).
 # Set to some factor of 2^wordsize to emulate smaller word size types
 # (i.e. will wrap sooner). This might be useful to emulate some embedded
 # systems.
 #
 # define PTW32_THREAD_ID_REUSE_INCREMENT 0
 #
 # ----------------------------------------------------------------------
 */
 #undef PTW32_THREAD_ID_REUSE_INCREMENT
 /*********************************************************************
 * Target specific groups
 *
 * If you find that these are incorrect or incomplete please report it
 * to the pthreads-win32 maintainer. Thanks.
 *********************************************************************/
 #if defined(WINCE)
 #define NEED_DUPLICATEHANDLE
 #define NEED_CREATETHREAD
 #define NEED_ERRNO
 #define NEED_CALLOC
 #define NEED_FTIME
 /* #define NEED_SEM */
 #define NEED_UNICODE_CONSTS
 #define NEED_PROCESS_AFFINITY_MASK
 /* This may not be needed */
 #define RETAIN_WSALASTERROR
 #endif
 #if defined(_UWIN)
 #define HAVE_MODE_T
 #define HAVE_STRUCT_TIMESPEC
 #endif
 #if defined(__GNUC__)
 #define HAVE_C_INLINE
 #endif
 #if defined(__MINGW64__)
 #define HAVE_MODE_T
 #define HAVE_STRUCT_TIMESPEC
 #elif defined(__MINGW32__)
 #define HAVE_MODE_T
 #endif
 #if defined(__BORLANDC__)
 #endif
 #if defined(__WATCOMC__)
 #endif
 #if defined(__DMC__)
 #define HAVE_SIGNAL_H
 #define HAVE_C_INLINE
 #endif
 #endif
--- a/deps/uv/deps/pthread-win32/context.h
+++ b/deps/uv/deps/pthread-win32/context.h
@ -1,74 +0,0 @@
 /*
 * context.h
 *
 * Description:
 * POSIX thread macros related to thread cancellation.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #ifndef PTW32_CONTEXT_H
 #define PTW32_CONTEXT_H
 #undef PTW32_PROGCTR
 #if defined(_M_IX86) || (defined(_X86_) && !defined(__amd64__))
 #define PTW32_PROGCTR(Context)  ((Context).Eip)
 #endif
 #if defined (_M_IA64) || defined(_IA64)
 #define PTW32_PROGCTR(Context)  ((Context).StIIP)
 #endif
 #if defined(_MIPS_) || defined(MIPS)
 #define PTW32_PROGCTR(Context)  ((Context).Fir)
 #endif
 #if defined(_ALPHA_)
 #define PTW32_PROGCTR(Context)  ((Context).Fir)
 #endif
 #if defined(_PPC_)
 #define PTW32_PROGCTR(Context)  ((Context).Iar)
 #endif
 #if defined(_AMD64_) || defined(__amd64__)
 #define PTW32_PROGCTR(Context)  ((Context).Rip)
 #endif
 #if defined(_ARM_) || defined(ARM)
 #define PTW32_PROGCTR(Context)  ((Context).Pc)
 #endif
 #if !defined(PTW32_PROGCTR)
 #error Module contains CPU-specific code; modify and recompile.
 #endif
 #endif
--- a/deps/uv/deps/pthread-win32/create.c
+++ b/deps/uv/deps/pthread-win32/create.c
@ -1,308 +0,0 @@
 /*
 * create.c
 *
 * Description:
 * This translation unit implements routines associated with spawning a new
 * thread.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #if ! defined(_UWIN) && ! defined(WINCE)
 #include <process.h>
 #endif
 int
 pthread_create (pthread_t * tid,
 		const pthread_attr_t * attr,
 		void *(*start) (void *), void *arg)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function creates a thread running the start function,
      *      passing it the parameter value, 'arg'. The 'attr'
      *      argument specifies optional creation attributes.
      *      The identity of the new thread is returned
      *      via 'tid', which should not be NULL.
      *
      * PARAMETERS
      *      tid
      *              pointer to an instance of pthread_t
      *
      *      attr
      *              optional pointer to an instance of pthread_attr_t
      *
      *      start
      *              pointer to the starting routine for the new thread
      *
      *      arg
      *              optional parameter passed to 'start'
      *
      *
      * DESCRIPTION
      *      This function creates a thread running the start function,
      *      passing it the parameter value, 'arg'. The 'attr'
      *      argument specifies optional creation attributes.
      *      The identity of the new thread is returned
      *      via 'tid', which should not be the NULL pointer.
      *
      * RESULTS
      *              0               successfully created thread,
      *              EINVAL          attr invalid,
      *              EAGAIN          insufficient resources.
      *
      * ------------------------------------------------------
      */
 {
  pthread_t thread;
  ptw32_thread_t * tp;
  register pthread_attr_t a;
  HANDLE threadH = 0;
  int result = EAGAIN;
  int run = PTW32_TRUE;
  ThreadParms *parms = NULL;
  unsigned int stackSize;
  int priority;
  pthread_t self;
  /*
   * Before doing anything, check that tid can be stored through
   * without invoking a memory protection error (segfault).
   * Make sure that the assignment below can't be optimised out by the compiler.
   * This is assured by conditionally assigning *tid again at the end.
   */
  tid->x = 0;
  if (attr != NULL)
    {
      a = *attr;
    }
  else
    {
      a = NULL;
    }
  if ((thread = ptw32_new ()).p == NULL)
    {
      goto FAIL0;
    }
  tp = (ptw32_thread_t *) thread.p;
  priority = tp->sched_priority;
  if ((parms = (ThreadParms *) malloc (sizeof (*parms))) == NULL)
    {
      goto FAIL0;
    }
  parms->tid = thread;
  parms->start = start;
  parms->arg = arg;
 #if defined(HAVE_SIGSET_T)
  /*
   * Threads inherit their initial sigmask from their creator thread.
   */
  self = pthread_self();
  tp->sigmask = ((ptw32_thread_t *)self.p)->sigmask;
 #endif /* HAVE_SIGSET_T */
  if (a != NULL)
    {
      stackSize = (unsigned int)a->stacksize;
      tp->detachState = a->detachstate;
      priority = a->param.sched_priority;
 #if (THREAD_PRIORITY_LOWEST > THREAD_PRIORITY_NORMAL)
      /* WinCE */
 #else
      /* Everything else */
      /*
       * Thread priority must be set to a valid system level
       * without altering the value set by pthread_attr_setschedparam().
       */
      /*
       * PTHREAD_EXPLICIT_SCHED is the default because Win32 threads
       * don't inherit their creator's priority. They are started with
       * THREAD_PRIORITY_NORMAL (win32 value). The result of not supplying
       * an 'attr' arg to pthread_create() is equivalent to defaulting to
       * PTHREAD_EXPLICIT_SCHED and priority THREAD_PRIORITY_NORMAL.
       */
      if (PTHREAD_INHERIT_SCHED == a->inheritsched)
 	{
 	  /*
 	   * If the thread that called pthread_create() is a Win32 thread
 	   * then the inherited priority could be the result of a temporary
 	   * system adjustment. This is not the case for POSIX threads.
 	   */
 #if ! defined(HAVE_SIGSET_T)
 	  self = pthread_self ();
 #endif
 	  priority = ((ptw32_thread_t *) self.p)->sched_priority;
 	}
 #endif
    }
  else
    {
      /*
       * Default stackSize
       */
      stackSize = PTHREAD_STACK_MIN;
    }
  tp->state = run ? PThreadStateInitial : PThreadStateSuspended;
  tp->keys = NULL;
  /*
   * Threads must be started in suspended mode and resumed if necessary
   * after _beginthreadex returns us the handle. Otherwise we set up a
   * race condition between the creating and the created threads.
   * Note that we also retain a local copy of the handle for use
   * by us in case thread.p->threadH gets NULLed later but before we've
   * finished with it here.
   */
 #if ! (defined (__MINGW64__) || defined(__MINGW32__)) || defined (__MSVCRT__) || defined (__DMC__) 
  tp->threadH =
    threadH =
    (HANDLE) _beginthreadex ((void *) NULL,	/* No security info             */
 			     stackSize,		/* default stack size   */
 			     ptw32_threadStart,
 			     parms,
 			     (unsigned)
 			     CREATE_SUSPENDED,
 			     (unsigned *) &(tp->thread));
  if (threadH != 0)
    {
      if (a != NULL)
 	{
 	  (void) ptw32_setthreadpriority (thread, SCHED_OTHER, priority);
 	}
      if (run)
 	{
 	  ResumeThread (threadH);
 	}
    }
 #else
  {
    ptw32_mcs_local_node_t stateLock;
    /*
     * This lock will force pthread_threadStart() to wait until we have
     * the thread handle and have set the priority.
     */
    ptw32_mcs_lock_acquire(&tp->stateLock, &stateLock);
    tp->threadH =
      threadH =
      (HANDLE) _beginthread (ptw32_threadStart, stackSize,	/* default stack size   */
 			     parms);
    /*
     * Make the return code match _beginthreadex's.
     */
    if (threadH == (HANDLE) - 1L)
      {
        tp->threadH = threadH = 0;
      }
    else
      {
        if (!run)
 	  {
 	    /* 
 	     * beginthread does not allow for create flags, so we do it now.
 	     * Note that beginthread itself creates the thread in SUSPENDED
 	     * mode, and then calls ResumeThread to start it.
 	     */
 	    SuspendThread (threadH);
 	  }
        if (a != NULL)
 	  {
 	    (void) ptw32_setthreadpriority (thread, SCHED_OTHER, priority);
 	  }
      }
    ptw32_mcs_lock_release (&stateLock);
  }
 #endif
  result = (threadH != 0) ? 0 : EAGAIN;
  /*
   * Fall Through Intentionally
   */
  /*
   * ------------
   * Failure Code
   * ------------
   */
 FAIL0:
  if (result != 0)
    {
      ptw32_threadDestroy (thread);
      tp = NULL;
      if (parms != NULL)
 	{
 	  free (parms);
 	}
    }
  else
    {
      *tid = thread;
    }
 #if defined(_UWIN)
  if (result == 0)
    pthread_count++;
 #endif
  return (result);
 }				/* pthread_create */
--- a/deps/uv/deps/pthread-win32/dll.c
+++ b/deps/uv/deps/pthread-win32/dll.c
@ -1,92 +0,0 @@
 /*
 * dll.c
 *
 * Description:
 * This translation unit implements DLL initialisation.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #if !defined(PTW32_STATIC_LIB)
 #include "pthread.h"
 #include "implement.h"
 #if defined(_MSC_VER)
 /* 
 * lpvReserved yields an unreferenced formal parameter;
 * ignore it
 */
 #pragma warning( disable : 4100 )
 #endif
 #if defined(__cplusplus)
 /*
 * Dear c++: Please don't mangle this name. -thanks
 */
 extern "C"
 #endif				/* __cplusplus */
  BOOL WINAPI
 DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
 {
  BOOL result = PTW32_TRUE;
  switch (fdwReason)
    {
    case DLL_PROCESS_ATTACH:
      result = pthread_win32_process_attach_np ();
      break;
    case DLL_THREAD_ATTACH:
      /*
       * A thread is being created
       */
      result = pthread_win32_thread_attach_np ();
      break;
    case DLL_THREAD_DETACH:
      /*
       * A thread is exiting cleanly
       */
      result = pthread_win32_thread_detach_np ();
      break;
    case DLL_PROCESS_DETACH:
      (void) pthread_win32_thread_detach_np ();
      result = pthread_win32_process_detach_np ();
      break;
    }
  return (result);
 }				/* DllMain */
 #endif /* PTW32_STATIC_LIB */
--- a/deps/uv/deps/pthread-win32/errno.c
+++ b/deps/uv/deps/pthread-win32/errno.c
@ -1,94 +0,0 @@
 /*
 * errno.c
 *
 * Description:
 * This translation unit implements routines associated with spawning a new
 * thread.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #if defined(NEED_ERRNO)
 #include "pthread.h"
 #include "implement.h"
 static int reallyBad = ENOMEM;
 /*
 * Re-entrant errno.
 *
 * Each thread has it's own errno variable in pthread_t.
 *
 * The benefit of using the pthread_t structure
 * instead of another TSD key is TSD keys are limited
 * on Win32 to 64 per process. Secondly, to implement
 * it properly without using pthread_t you'd need
 * to dynamically allocate an int on starting the thread
 * and store it manually into TLS and then ensure that you free
 * it on thread termination. We get all that for free
 * by simply storing the errno on the pthread_t structure.
 *
 * MSVC and Mingw32 already have their own thread-safe errno.
 *
 * #if defined( _REENTRANT ) || defined( _MT )
 * #define errno *_errno()
 *
 * int *_errno( void );
 * #else
 * extern int errno;
 * #endif
 *
 */
 int *
 _errno (void)
 {
  pthread_t self;
  int *result;
  if ((self = pthread_self ()).p == NULL)
    {
      /*
       * Yikes! unable to allocate a thread!
       * Throw an exception? return an error?
       */
      result = &reallyBad;
    }
  else
    {
      result = (int *)(&self.p->exitStatus);
    }
  return (result);
 }				/* _errno */
 #endif /* (NEED_ERRNO) */
--- a/deps/uv/deps/pthread-win32/exit.c
+++ b/deps/uv/deps/pthread-win32/exit.c
@ -1,44 +0,0 @@
 /*
 * exit.c
 *
 * Description:
 * This translation unit implements routines associated with exiting from
 * a thread.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #if ! defined(_UWIN) && ! defined(WINCE)
 #   include <process.h>
 #endif
 #include "pthread_exit.c"
--- a/deps/uv/deps/pthread-win32/fork.c
+++ b/deps/uv/deps/pthread-win32/fork.c
@ -1,39 +0,0 @@
 /*
 * fork.c
 *
 * Description:
 * Implementation of fork() for POSIX threads.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
--- a/deps/uv/deps/pthread-win32/global.c
+++ b/deps/uv/deps/pthread-win32/global.c
@ -1,107 +0,0 @@
 /*
 * global.c
 *
 * Description:
 * This translation unit instantiates data associated with the implementation
 * as a whole.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int ptw32_processInitialized = PTW32_FALSE;
 ptw32_thread_t * ptw32_threadReuseTop = PTW32_THREAD_REUSE_EMPTY;
 ptw32_thread_t * ptw32_threadReuseBottom = PTW32_THREAD_REUSE_EMPTY;
 pthread_key_t ptw32_selfThreadKey = NULL;
 pthread_key_t ptw32_cleanupKey = NULL;
 pthread_cond_t ptw32_cond_list_head = NULL;
 pthread_cond_t ptw32_cond_list_tail = NULL;
 int ptw32_concurrency = 0;
 /* What features have been auto-detected */
 int ptw32_features = 0;
 /*
 * Global [process wide] thread sequence Number
 */
 unsigned __int64 ptw32_threadSeqNumber = 0;
 /* 
 * Function pointer to QueueUserAPCEx if it exists, otherwise
 * it will be set at runtime to a substitute routine which cannot unblock
 * blocked threads.
 */
 DWORD (*ptw32_register_cancelation) (PAPCFUNC, HANDLE, DWORD) = NULL;
 /*
 * Global lock for managing pthread_t struct reuse.
 */
 ptw32_mcs_lock_t ptw32_thread_reuse_lock = 0;
 /*
 * Global lock for testing internal state of statically declared mutexes.
 */
 ptw32_mcs_lock_t ptw32_mutex_test_init_lock = 0;
 /*
 * Global lock for testing internal state of PTHREAD_COND_INITIALIZER
 * created condition variables.
 */
 ptw32_mcs_lock_t ptw32_cond_test_init_lock = 0;
 /*
 * Global lock for testing internal state of PTHREAD_RWLOCK_INITIALIZER
 * created read/write locks.
 */
 ptw32_mcs_lock_t ptw32_rwlock_test_init_lock = 0;
 /*
 * Global lock for testing internal state of PTHREAD_SPINLOCK_INITIALIZER
 * created spin locks.
 */
 ptw32_mcs_lock_t ptw32_spinlock_test_init_lock = 0;
 /*
 * Global lock for condition variable linked list. The list exists
 * to wake up CVs when a WM_TIMECHANGE message arrives. See
 * w32_TimeChangeHandler.c.
 */
 ptw32_mcs_lock_t ptw32_cond_list_lock = 0;
 #if defined(_UWIN)
 /*
 * Keep a count of the number of threads.
 */
 int pthread_count = 0;
 #endif
--- a/deps/uv/deps/pthread-win32/implement.h
+++ b/deps/uv/deps/pthread-win32/implement.h
@ -1,944 +0,0 @@
 /*
 * implement.h
 *
 * Definitions that don't need to be public.
 *
 * Keeps all the internals out of pthread.h
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: Ross.Johnson@homemail.com.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #if !defined(_IMPLEMENT_H)
 #define _IMPLEMENT_H
 #if !defined(_WIN32_WINNT)
 #define _WIN32_WINNT 0x0400
 #endif
 #include <windows.h>
 /*
 * In case windows.h doesn't define it (e.g. WinCE perhaps)
 */
 #if defined(WINCE)
 typedef VOID (APIENTRY *PAPCFUNC)(DWORD dwParam);
 #endif
 /*
 * note: ETIMEDOUT is correctly defined in winsock.h
 */
 #include <winsock.h>
 /*
 * In case ETIMEDOUT hasn't been defined above somehow.
 */
 #if !defined(ETIMEDOUT)
 #  define ETIMEDOUT 10060	/* This is the value in winsock.h. */
 #endif
 #if !defined(malloc)
 #include <malloc.h>
 #endif
 #if defined(__CLEANUP_C)
 # include <setjmp.h>
 #endif
 #if !defined(INT_MAX)
 #include <limits.h>
 #endif
 /* use local include files during development */
 #include "semaphore.h"
 #include "sched.h"
 #if defined(HAVE_C_INLINE) || defined(__cplusplus)
 #define INLINE inline
 #else
 #define INLINE
 #endif
 #if defined(_MSC_VER) && _MSC_VER < 1300
 /*
 * MSVC 6 does not use the "volatile" qualifier
 */
 #define PTW32_INTERLOCKED_VOLATILE
 #else
 #define PTW32_INTERLOCKED_VOLATILE volatile
 #endif
 #define PTW32_INTERLOCKED_LONG long
 #define PTW32_INTERLOCKED_SIZE size_t
 #define PTW32_INTERLOCKED_PVOID PVOID
 #define PTW32_INTERLOCKED_LONGPTR PTW32_INTERLOCKED_VOLATILE long*
 #define PTW32_INTERLOCKED_SIZEPTR PTW32_INTERLOCKED_VOLATILE size_t*
 #define PTW32_INTERLOCKED_PVOID_PTR PTW32_INTERLOCKED_VOLATILE PVOID*
 #if defined(__MINGW64__) || defined(__MINGW32__)
 #  include <stdint.h>
 #elif defined(__BORLANDC__)
 #  define int64_t ULONGLONG
 #else
 #  define int64_t _int64
 #  if defined(_MSC_VER) && _MSC_VER < 1300
     typedef long intptr_t;
 #  endif
 #endif
 typedef enum
 {
  /*
   * This enumeration represents the state of the thread;
   * The thread is still "alive" if the numeric value of the
   * state is greater or equal "PThreadStateRunning".
   */
  PThreadStateInitial = 0,	/* Thread not running                   */
  PThreadStateRunning,		/* Thread alive & kicking               */
  PThreadStateSuspended,	/* Thread alive but suspended           */
  PThreadStateCancelPending,	/* Thread alive but                     */
                                /* has cancelation pending.             */
  PThreadStateCanceling,	/* Thread alive but is                  */
                                /* in the process of terminating        */
                                /* due to a cancellation request        */
  PThreadStateExiting,		/* Thread alive but exiting             */
                                /* due to an exception                  */
  PThreadStateLast,             /* All handlers have been run and now   */
                                /* final cleanup can be done.           */
  PThreadStateReuse             /* In reuse pool.                       */
 }
 PThreadState;
 typedef struct ptw32_mcs_node_t_     ptw32_mcs_local_node_t;
 typedef struct ptw32_mcs_node_t_*    ptw32_mcs_lock_t;
 typedef struct ptw32_robust_node_t_  ptw32_robust_node_t;
 typedef struct ptw32_thread_t_       ptw32_thread_t;
 struct ptw32_thread_t_
 {
  unsigned __int64 seqNumber;	/* Process-unique thread sequence number */
  HANDLE threadH;		/* Win32 thread handle - POSIX thread is invalid if threadH == 0 */
  pthread_t ptHandle;		/* This thread's permanent pthread_t handle */
  ptw32_thread_t * prevReuse;	/* Links threads on reuse stack */
  volatile PThreadState state;
  ptw32_mcs_lock_t threadLock;	/* Used for serialised access to public thread state */
  ptw32_mcs_lock_t stateLock;	/* Used for async-cancel safety */
  HANDLE cancelEvent;
  void *exitStatus;
  void *parms;
  void *keys;
  void *nextAssoc;
 #if defined(__CLEANUP_C)
  jmp_buf start_mark;		/* Jump buffer follows void* so should be aligned */
 #endif				/* __CLEANUP_C */
 #if defined(HAVE_SIGSET_T)
  sigset_t sigmask;
 #endif				/* HAVE_SIGSET_T */
  ptw32_mcs_lock_t
              robustMxListLock; /* robustMxList lock */
  ptw32_robust_node_t*
                  robustMxList; /* List of currenty held robust mutexes */
  int ptErrno;
  int detachState;
  int sched_priority;		/* As set, not as currently is */
  int cancelState;
  int cancelType;
  int implicit:1;
  DWORD thread;			/* Win32 thread ID */
 #if defined(_UWIN)
  DWORD dummy[5];
 #endif
  size_t align;			/* Force alignment if this struct is packed */
 };
 /* 
 * Special value to mark attribute objects as valid.
 */
 #define PTW32_ATTR_VALID ((unsigned long) 0xC4C0FFEE)
 struct pthread_attr_t_
 {
  unsigned long valid;
  void *stackaddr;
  size_t stacksize;
  int detachstate;
  struct sched_param param;
  int inheritsched;
  int contentionscope;
 #if defined(HAVE_SIGSET_T)
  sigset_t sigmask;
 #endif				/* HAVE_SIGSET_T */
 };
 /*
 * ====================
 * ====================
 * Semaphores, Mutexes and Condition Variables
 * ====================
 * ====================
 */
 struct sem_t_
 {
  int value;
  pthread_mutex_t lock;
  HANDLE sem;
 #if defined(NEED_SEM)
  int leftToUnblock;
 #endif
 };
 #define PTW32_OBJECT_AUTO_INIT ((void *)(size_t) -1)
 #define PTW32_OBJECT_INVALID   NULL
 struct pthread_mutex_t_
 {
  LONG lock_idx;		/* Provides exclusive access to mutex state
 				   via the Interlocked* mechanism.
 				    0: unlocked/free.
 				    1: locked - no other waiters.
 				   -1: locked - with possible other waiters.
 				*/
  int recursive_count;		/* Number of unlocks a thread needs to perform
 				   before the lock is released (recursive
 				   mutexes only). */
  int kind;			/* Mutex type. */
  pthread_t ownerThread;
  HANDLE event;			/* Mutex release notification to waiting
 				   threads. */
  ptw32_robust_node_t*
                    robustNode; /* Extra state for robust mutexes  */
 };
 enum ptw32_robust_state_t_
 {
  PTW32_ROBUST_CONSISTENT,
  PTW32_ROBUST_INCONSISTENT,
  PTW32_ROBUST_NOTRECOVERABLE
 };
 typedef enum ptw32_robust_state_t_   ptw32_robust_state_t;
 /*
 * Node used to manage per-thread lists of currently-held robust mutexes.
 */
 struct ptw32_robust_node_t_
 {
  pthread_mutex_t mx;
  ptw32_robust_state_t stateInconsistent;
  ptw32_robust_node_t* prev;
  ptw32_robust_node_t* next;
 };
 struct pthread_mutexattr_t_
 {
  int pshared;
  int kind;
  int robustness;
 };
 /*
 * Possible values, other than PTW32_OBJECT_INVALID,
 * for the "interlock" element in a spinlock.
 *
 * In this implementation, when a spinlock is initialised,
 * the number of cpus available to the process is checked.
 * If there is only one cpu then "interlock" is set equal to
 * PTW32_SPIN_USE_MUTEX and u.mutex is an initialised mutex.
 * If the number of cpus is greater than 1 then "interlock"
 * is set equal to PTW32_SPIN_UNLOCKED and the number is
 * stored in u.cpus. This arrangement allows the spinlock
 * routines to attempt an InterlockedCompareExchange on "interlock"
 * immediately and, if that fails, to try the inferior mutex.
 *
 * "u.cpus" isn't used for anything yet, but could be used at
 * some point to optimise spinlock behaviour.
 */
 #define PTW32_SPIN_INVALID     (0)
 #define PTW32_SPIN_UNLOCKED    (1)
 #define PTW32_SPIN_LOCKED      (2)
 #define PTW32_SPIN_USE_MUTEX   (3)
 struct pthread_spinlock_t_
 {
  long interlock;		/* Locking element for multi-cpus. */
  union
  {
    int cpus;			/* No. of cpus if multi cpus, or   */
    pthread_mutex_t mutex;	/* mutex if single cpu.            */
  } u;
 };
 /*
 * MCS lock queue node - see ptw32_MCS_lock.c
 */
 struct ptw32_mcs_node_t_
 {
  struct ptw32_mcs_node_t_ **lock;        /* ptr to tail of queue */
  struct ptw32_mcs_node_t_  *next;        /* ptr to successor in queue */
  HANDLE                     readyFlag;   /* set after lock is released by
                                             predecessor */
  HANDLE                     nextFlag;    /* set after 'next' ptr is set by
                                             successor */
 };
 struct pthread_barrier_t_
 {
  unsigned int nCurrentBarrierHeight;
  unsigned int nInitialBarrierHeight;
  int pshared;
  sem_t semBarrierBreeched;
  ptw32_mcs_lock_t lock;
  ptw32_mcs_local_node_t proxynode;
 };
 struct pthread_barrierattr_t_
 {
  int pshared;
 };
 struct pthread_key_t_
 {
  DWORD key;
  void (*destructor) (void *);
  ptw32_mcs_lock_t keyLock;
  void *threads;
 };
 typedef struct ThreadParms ThreadParms;
 struct ThreadParms
 {
  pthread_t tid;
  void *(*start) (void *);
  void *arg;
 };
 struct pthread_cond_t_
 {
  long nWaitersBlocked;		/* Number of threads blocked            */
  long nWaitersGone;		/* Number of threads timed out          */
  long nWaitersToUnblock;	/* Number of threads to unblock         */
  sem_t semBlockQueue;		/* Queue up threads waiting for the     */
  /*   condition to become signalled      */
  sem_t semBlockLock;		/* Semaphore that guards access to      */
  /* | waiters blocked count/block queue  */
  /* +-> Mandatory Sync.LEVEL-1           */
  pthread_mutex_t mtxUnblockLock;	/* Mutex that guards access to          */
  /* | waiters (to)unblock(ed) counts     */
  /* +-> Optional* Sync.LEVEL-2           */
  pthread_cond_t next;		/* Doubly linked list                   */
  pthread_cond_t prev;
 };
 struct pthread_condattr_t_
 {
  int pshared;
 };
 #define PTW32_RWLOCK_MAGIC 0xfacade2
 struct pthread_rwlock_t_
 {
  pthread_mutex_t mtxExclusiveAccess;
  pthread_mutex_t mtxSharedAccessCompleted;
  pthread_cond_t cndSharedAccessCompleted;
  int nSharedAccessCount;
  int nExclusiveAccessCount;
  int nCompletedSharedAccessCount;
  int nMagic;
 };
 struct pthread_rwlockattr_t_
 {
  int pshared;
 };
 typedef struct ThreadKeyAssoc ThreadKeyAssoc;
 struct ThreadKeyAssoc
 {
  /*
   * Purpose:
   *      This structure creates an association between a thread and a key.
   *      It is used to implement the implicit invocation of a user defined
   *      destroy routine for thread specific data registered by a user upon
   *      exiting a thread.
   *
   *      Graphically, the arrangement is as follows, where:
   *
   *         K - Key with destructor
   *            (head of chain is key->threads)
   *         T - Thread that has called pthread_setspecific(Kn)
   *            (head of chain is thread->keys)
   *         A - Association. Each association is a node at the
   *             intersection of two doubly-linked lists.
   *
   *                 T1    T2    T3
   *                 |     |     |
   *                 |     |     |
   *         K1 -----+-----A-----A----->
   *                 |     |     |
   *                 |     |     |
   *         K2 -----A-----A-----+----->
   *                 |     |     |
   *                 |     |     |
   *         K3 -----A-----+-----A----->
   *                 |     |     |
   *                 |     |     |
   *                 V     V     V
   *
   *      Access to the association is guarded by two locks: the key's
   *      general lock (guarding the row) and the thread's general
   *      lock (guarding the column). This avoids the need for a
   *      dedicated lock for each association, which not only consumes
   *      more handles but requires that the lock resources persist
   *      until both the key is deleted and the thread has called the
   *      destructor. The two-lock arrangement allows those resources
   *      to be freed as soon as either thread or key is concluded.
   *
   *      To avoid deadlock, whenever both locks are required both the
   *      key and thread locks are acquired consistently in the order
   *      "key lock then thread lock". An exception to this exists
   *      when a thread calls the destructors, however, this is done
   *      carefully (but inelegantly) to avoid deadlock.
   *
   *      An association is created when a thread first calls
   *      pthread_setspecific() on a key that has a specified
   *      destructor.
   *
   *      An association is destroyed either immediately after the
   *      thread calls the key destructor function on thread exit, or
   *      when the key is deleted.
   *
   * Attributes:
   *      thread
   *              reference to the thread that owns the
   *              association. This is actually the pointer to the
   *              thread struct itself. Since the association is
   *              destroyed before the thread exits, this can never
   *              point to a different logical thread to the one that
   *              created the assoc, i.e. after thread struct reuse.
   *
   *      key
   *              reference to the key that owns the association.
   *
   *      nextKey
   *              The pthread_t->keys attribute is the head of a
   *              chain of associations that runs through the nextKey
   *              link. This chain provides the 1 to many relationship
   *              between a pthread_t and all pthread_key_t on which
   *              it called pthread_setspecific.
   *
   *      prevKey
   *              Similarly.
   *
   *      nextThread
   *              The pthread_key_t->threads attribute is the head of
   *              a chain of associations that runs through the
   *              nextThreads link. This chain provides the 1 to many
   *              relationship between a pthread_key_t and all the 
   *              PThreads that have called pthread_setspecific for
   *              this pthread_key_t.
   *
   *      prevThread
   *              Similarly.
   *
   * Notes:
   *      1)      As soon as either the key or the thread is no longer
   *              referencing the association, it can be destroyed. The
   *              association will be removed from both chains.
   *
   *      2)      Under WIN32, an association is only created by
   *              pthread_setspecific if the user provided a
   *              destroyRoutine when they created the key.
   *
   *
   */
  ptw32_thread_t * thread;
  pthread_key_t key;
  ThreadKeyAssoc *nextKey;
  ThreadKeyAssoc *nextThread;
  ThreadKeyAssoc *prevKey;
  ThreadKeyAssoc *prevThread;
 };
 #if defined(__CLEANUP_SEH)
 /*
 * --------------------------------------------------------------
 * MAKE_SOFTWARE_EXCEPTION
 *      This macro constructs a software exception code following
 *      the same format as the standard Win32 error codes as defined
 *      in WINERROR.H
 *  Values are 32 bit values laid out as follows:
 *
 *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 *  +---+-+-+-----------------------+-------------------------------+
 *  |Sev|C|R|     Facility          |               Code            |
 *  +---+-+-+-----------------------+-------------------------------+
 *
 * Severity Values:
 */
 #define SE_SUCCESS              0x00
 #define SE_INFORMATION          0x01
 #define SE_WARNING              0x02
 #define SE_ERROR                0x03
 #define MAKE_SOFTWARE_EXCEPTION( _severity, _facility, _exception ) \
 ( (DWORD) ( ( (_severity) << 30 ) |     /* Severity code        */ \
            ( 1 << 29 ) |               /* MS=0, User=1         */ \
            ( 0 << 28 ) |               /* Reserved             */ \
            ( (_facility) << 16 ) |     /* Facility Code        */ \
            ( (_exception) <<  0 )      /* Exception Code       */ \
            ) )
 /*
 * We choose one specific Facility/Error code combination to
 * identify our software exceptions vs. WIN32 exceptions.
 * We store our actual component and error code within
 * the optional information array.
 */
 #define EXCEPTION_PTW32_SERVICES        \
     MAKE_SOFTWARE_EXCEPTION( SE_ERROR, \
                              PTW32_SERVICES_FACILITY, \
                              PTW32_SERVICES_ERROR )
 #define PTW32_SERVICES_FACILITY         0xBAD
 #define PTW32_SERVICES_ERROR            0xDEED
 #endif /* __CLEANUP_SEH */
 /*
 * Services available through EXCEPTION_PTW32_SERVICES
 * and also used [as parameters to ptw32_throw()] as
 * generic exception selectors.
 */
 #define PTW32_EPS_EXIT                  (1)
 #define PTW32_EPS_CANCEL                (2)
 /* Useful macros */
 #define PTW32_MAX(a,b)  ((a)<(b)?(b):(a))
 #define PTW32_MIN(a,b)  ((a)>(b)?(b):(a))
 /* Declared in pthread_cancel.c */
 extern DWORD (*ptw32_register_cancelation) (PAPCFUNC, HANDLE, DWORD);
 /* Thread Reuse stack bottom marker. Must not be NULL or any valid pointer to memory. */
 #define PTW32_THREAD_REUSE_EMPTY ((ptw32_thread_t *)(size_t) 1)
 extern int ptw32_processInitialized;
 extern ptw32_thread_t * ptw32_threadReuseTop;
 extern ptw32_thread_t * ptw32_threadReuseBottom;
 extern pthread_key_t ptw32_selfThreadKey;
 extern pthread_key_t ptw32_cleanupKey;
 extern pthread_cond_t ptw32_cond_list_head;
 extern pthread_cond_t ptw32_cond_list_tail;
 extern int ptw32_mutex_default_kind;
 extern unsigned __int64 ptw32_threadSeqNumber;
 extern int ptw32_concurrency;
 extern int ptw32_features;
 extern ptw32_mcs_lock_t ptw32_thread_reuse_lock;
 extern ptw32_mcs_lock_t ptw32_mutex_test_init_lock;
 extern ptw32_mcs_lock_t ptw32_cond_list_lock;
 extern ptw32_mcs_lock_t ptw32_cond_test_init_lock;
 extern ptw32_mcs_lock_t ptw32_rwlock_test_init_lock;
 extern ptw32_mcs_lock_t ptw32_spinlock_test_init_lock;
 #if defined(_UWIN)
 extern int pthread_count;
 #endif
 #if defined(__cplusplus)
 extern "C"
 {
 #endif				/* __cplusplus */
 /*
 * =====================
 * =====================
 * Forward Declarations
 * =====================
 * =====================
 */
  int ptw32_is_attr (const pthread_attr_t * attr);
  int ptw32_cond_check_need_init (pthread_cond_t * cond);
  int ptw32_mutex_check_need_init (pthread_mutex_t * mutex);
  int ptw32_rwlock_check_need_init (pthread_rwlock_t * rwlock);
  int ptw32_spinlock_check_need_init (pthread_spinlock_t * lock);
  int ptw32_robust_mutex_inherit(pthread_mutex_t * mutex);
  void ptw32_robust_mutex_add(pthread_mutex_t* mutex, pthread_t self);
  void ptw32_robust_mutex_remove(pthread_mutex_t* mutex, ptw32_thread_t* otp);
  DWORD
    ptw32_RegisterCancelation (PAPCFUNC callback,
 			       HANDLE threadH, DWORD callback_arg);
  int ptw32_processInitialize (void);
  void ptw32_processTerminate (void);
  void ptw32_threadDestroy (pthread_t tid);
  void ptw32_pop_cleanup_all (int execute);
  pthread_t ptw32_new (void);
  pthread_t ptw32_threadReusePop (void);
  void ptw32_threadReusePush (pthread_t thread);
  int ptw32_getprocessors (int *count);
  int ptw32_setthreadpriority (pthread_t thread, int policy, int priority);
  void ptw32_rwlock_cancelwrwait (void *arg);
 #if ! (defined (__MINGW64__) || defined(__MINGW32__)) || (defined(__MSVCRT__) && ! defined(__DMC__))
  unsigned __stdcall
 #else
  void
 #endif
    ptw32_threadStart (void *vthreadParms);
  void ptw32_callUserDestroyRoutines (pthread_t thread);
  int ptw32_tkAssocCreate (ptw32_thread_t * thread, pthread_key_t key);
  void ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);
  int ptw32_semwait (sem_t * sem);
  DWORD ptw32_relmillisecs (const struct timespec * abstime);
  void ptw32_mcs_lock_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node);
  int ptw32_mcs_lock_try_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node);
  void ptw32_mcs_lock_release (ptw32_mcs_local_node_t * node);
  void ptw32_mcs_node_transfer (ptw32_mcs_local_node_t * new_node, ptw32_mcs_local_node_t * old_node);
 #if defined(NEED_FTIME)
  void ptw32_timespec_to_filetime (const struct timespec *ts, FILETIME * ft);
  void ptw32_filetime_to_timespec (const FILETIME * ft, struct timespec *ts);
 #endif
 /* Declared in misc.c */
 #if defined(NEED_CALLOC)
 #define calloc(n, s) ptw32_calloc(n, s)
  void *ptw32_calloc (size_t n, size_t s);
 #endif
 /* Declared in private.c */
 #if defined(_MSC_VER)
 /*
 * Ignore the warning:
 * "C++ exception specification ignored except to indicate that
 * the function is not __declspec(nothrow)."
 */
 #pragma warning(disable:4290)
 #endif
  void ptw32_throw (DWORD exception)
 #if defined(__CLEANUP_CXX)
    throw(ptw32_exception_cancel,ptw32_exception_exit)
 #endif
 ;
 #if defined(__cplusplus)
 }
 #endif				/* __cplusplus */
 #if defined(_UWIN_)
 #   if defined(_MT)
 #       if defined(__cplusplus)
 extern "C"
 {
 #       endif
  _CRTIMP unsigned long __cdecl _beginthread (void (__cdecl *) (void *),
 					      unsigned, void *);
  _CRTIMP void __cdecl _endthread (void);
  _CRTIMP unsigned long __cdecl _beginthreadex (void *, unsigned,
 						unsigned (__stdcall *) (void *),
 						void *, unsigned, unsigned *);
  _CRTIMP void __cdecl _endthreadex (unsigned);
 #       if defined(__cplusplus)
 }
 #       endif
 #   endif
 #else
 #       include <process.h>
 #   endif
 /*
 * Use intrinsic versions wherever possible. VC will do this
 * automatically where possible and GCC define these if available:
 * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
 * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
 * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
 * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
 * __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16
 *
 * The full set of Interlocked intrinsics in GCC are (check versions):
 * type __sync_fetch_and_add (type *ptr, type value, ...)
 * type __sync_fetch_and_sub (type *ptr, type value, ...)
 * type __sync_fetch_and_or (type *ptr, type value, ...)
 * type __sync_fetch_and_and (type *ptr, type value, ...)
 * type __sync_fetch_and_xor (type *ptr, type value, ...)
 * type __sync_fetch_and_nand (type *ptr, type value, ...)
 * type __sync_add_and_fetch (type *ptr, type value, ...)
 * type __sync_sub_and_fetch (type *ptr, type value, ...)
 * type __sync_or_and_fetch (type *ptr, type value, ...)
 * type __sync_and_and_fetch (type *ptr, type value, ...)
 * type __sync_xor_and_fetch (type *ptr, type value, ...)
 * type __sync_nand_and_fetch (type *ptr, type value, ...)
 * bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...)
 * type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...)
 * __sync_synchronize (...) // Full memory barrier
 * type __sync_lock_test_and_set (type *ptr, type value, ...) // Acquire barrier
 * void __sync_lock_release (type *ptr, ...) // Release barrier
 *
 * These are all overloaded and take 1,2,4,8 byte scalar or pointer types.
 *
 * The above aren't available in Mingw32 as of gcc 4.5.2 so define our own.
 */
 #if defined(__GNUC__)
 # if defined(_WIN64)
 # define PTW32_INTERLOCKED_COMPARE_EXCHANGE_64(location, value, comparand)    \
    ({                                                                     \
      __typeof (value) _result;                                            \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "cmpxchgq      %2,(%1)"                                            \
        :"=a" (_result)                                                    \
        :"r"  (location), "r" (value), "a" (comparand)                     \
        :"memory", "cc");                                                  \
      _result;                                                             \
    })
 # define PTW32_INTERLOCKED_EXCHANGE_64(location, value)                    \
    ({                                                                     \
      __typeof (value) _result;                                            \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "xchgq	 %0,(%1)"                                                  \
        :"=r" (_result)                                                    \
        :"r" (location), "0" (value)                                       \
        :"memory", "cc");                                                  \
      _result;                                                             \
    })
 # define PTW32_INTERLOCKED_EXCHANGE_ADD_64(location, value)                \
    ({                                                                     \
      __typeof (value) _result;                                            \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "xaddq	 %0,(%1)"                                                  \
        :"=r" (_result)                                                    \
        :"r" (location), "0" (value)                                       \
        :"memory", "cc");                                                  \
      _result;                                                             \
    })
 # define PTW32_INTERLOCKED_INCREMENT_64(location)                          \
    ({                                                                     \
      PTW32_INTERLOCKED_LONG _temp = 1;                                   \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "xaddq	 %0,(%1)"                                                  \
        :"+r" (_temp)                                                      \
        :"r" (location)                                                    \
        :"memory", "cc");                                                  \
      ++_temp;                                                             \
    })
 # define PTW32_INTERLOCKED_DECREMENT_64(location)                          \
    ({                                                                     \
      PTW32_INTERLOCKED_LONG _temp = -1;                                  \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "xaddq	 %2,(%1)"                                                  \
        :"+r" (_temp)                                                      \
        :"r" (location)                                                    \
        :"memory", "cc");                                                  \
      --_temp;                                                             \
    })
 #endif
 # define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand)    \
    ({                                                                     \
      __typeof (value) _result;                                            \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "cmpxchgl       %2,(%1)"                                           \
        :"=a" (_result)                                                    \
        :"r"  (location), "r" (value), "a" (comparand)                     \
        :"memory", "cc");                                                  \
      _result;                                                             \
    })
 # define PTW32_INTERLOCKED_EXCHANGE_LONG(location, value)                  \
    ({                                                                     \
      __typeof (value) _result;                                            \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "xchgl	 %0,(%1)"                                                  \
        :"=r" (_result)                                                    \
        :"r" (location), "0" (value)                                       \
        :"memory", "cc");                                                  \
      _result;                                                             \
    })
 # define PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(location, value)              \
    ({                                                                     \
      __typeof (value) _result;                                            \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "xaddl	 %0,(%1)"                                                  \
        :"=r" (_result)                                                    \
        :"r" (location), "0" (value)                                       \
        :"memory", "cc");                                                  \
      _result;                                                             \
    })
 # define PTW32_INTERLOCKED_INCREMENT_LONG(location)                        \
    ({                                                                     \
      PTW32_INTERLOCKED_LONG _temp = 1;                                   \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "xaddl	 %0,(%1)"                                                  \
        :"+r" (_temp)                                                      \
        :"r" (location)                                                    \
        :"memory", "cc");                                                  \
      ++_temp;                                                             \
    })
 # define PTW32_INTERLOCKED_DECREMENT_LONG(location)                        \
    ({                                                                     \
      PTW32_INTERLOCKED_LONG _temp = -1;                                  \
      __asm__ __volatile__                                                 \
      (                                                                    \
        "lock\n\t"                                                         \
        "xaddl	 %0,(%1)"                                                  \
        :"+r" (_temp)                                                      \
        :"r" (location)                                                    \
        :"memory", "cc");                                                  \
      --_temp;                                                             \
    })
 # define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR(location, value, comparand) \
    PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE((PTW32_INTERLOCKED_SIZEPTR)location, \
                                            (PTW32_INTERLOCKED_SIZE)value, \
                                            (PTW32_INTERLOCKED_SIZE)comparand)
 # define PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
    PTW32_INTERLOCKED_EXCHANGE_SIZE((PTW32_INTERLOCKED_SIZEPTR)location, \
                                    (PTW32_INTERLOCKED_SIZE)value)
 #else
 # if defined(_WIN64)
 #   define PTW32_INTERLOCKED_COMPARE_EXCHANGE_64 InterlockedCompareExchange64
 #   define PTW32_INTERLOCKED_EXCHANGE_64 InterlockedExchange64
 #   define PTW32_INTERLOCKED_EXCHANGE_ADD_64 InterlockedExchangeAdd64
 #   define PTW32_INTERLOCKED_INCREMENT_64 InterlockedIncrement64
 #   define PTW32_INTERLOCKED_DECREMENT_64 InterlockedDecrement64
 # endif
 # if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(_WIN64) /* MSVC 6 */
 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand) \
      ((LONG)InterlockedCompareExchange((PVOID *)(location), (PVOID)(value), (PVOID)(comparand)))
 # else
 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG InterlockedCompareExchange
 # endif
 # define PTW32_INTERLOCKED_EXCHANGE_LONG InterlockedExchange
 # define PTW32_INTERLOCKED_EXCHANGE_ADD_LONG InterlockedExchangeAdd
 # define PTW32_INTERLOCKED_INCREMENT_LONG InterlockedIncrement
 # define PTW32_INTERLOCKED_DECREMENT_LONG InterlockedDecrement
 # if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(_WIN64) /* MSVC 6 */
 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR InterlockedCompareExchange
 #  define PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
    ((PVOID)InterlockedExchange((LPLONG)(location), (LONG)(value)))
 # else
 #  define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR InterlockedCompareExchangePointer
 #  define PTW32_INTERLOCKED_EXCHANGE_PTR InterlockedExchangePointer
 # endif
 #endif
 #if defined(_WIN64)
 #   define PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE PTW32_INTERLOCKED_COMPARE_EXCHANGE_64
 #   define PTW32_INTERLOCKED_EXCHANGE_SIZE PTW32_INTERLOCKED_EXCHANGE_64
 #   define PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE PTW32_INTERLOCKED_EXCHANGE_ADD_64
 #   define PTW32_INTERLOCKED_INCREMENT_SIZE PTW32_INTERLOCKED_INCREMENT_64
 #   define PTW32_INTERLOCKED_DECREMENT_SIZE PTW32_INTERLOCKED_DECREMENT_64
 #else
 #   define PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG
 #   define PTW32_INTERLOCKED_EXCHANGE_SIZE PTW32_INTERLOCKED_EXCHANGE_LONG
 #   define PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE PTW32_INTERLOCKED_EXCHANGE_ADD_LONG
 #   define PTW32_INTERLOCKED_INCREMENT_SIZE PTW32_INTERLOCKED_INCREMENT_LONG
 #   define PTW32_INTERLOCKED_DECREMENT_SIZE PTW32_INTERLOCKED_DECREMENT_LONG
 #endif
 #if defined(NEED_CREATETHREAD)
 /* 
 * Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE
 * in order to avoid warnings because of return type
 */
 #define _beginthreadex(security, \
                       stack_size, \
                       start_proc, \
                       arg, \
                       flags, \
                       pid) \
        CreateThread(security, \
                     stack_size, \
                     (LPTHREAD_START_ROUTINE) start_proc, \
                     arg, \
                     flags, \
                     pid)
 #define _endthreadex ExitThread
 #endif				/* NEED_CREATETHREAD */
 #endif				/* _IMPLEMENT_H */
--- a/deps/uv/deps/pthread-win32/misc.c
+++ b/deps/uv/deps/pthread-win32/misc.c
@ -1,50 +0,0 @@
 /*
 * misc.c
 *
 * Description:
 * This translation unit implements miscellaneous thread functions.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "pthread_kill.c"
 #include "pthread_once.c"
 #include "pthread_self.c"
 #include "pthread_equal.c"
 #include "pthread_setconcurrency.c"
 #include "pthread_getconcurrency.c"
 #include "ptw32_new.c"
 #include "ptw32_calloc.c"
 #include "ptw32_reuse.c"
 #include "w32_CancelableWait.c"
--- a/deps/uv/deps/pthread-win32/mutex.c
+++ b/deps/uv/deps/pthread-win32/mutex.c
@ -1,62 +0,0 @@
 /*
 * mutex.c
 *
 * Description:
 * This translation unit implements mutual exclusion (mutex) primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #if ! defined(_UWIN) && ! defined(WINCE)
 #   include <process.h>
 #endif
 #if !defined(NEED_FTIME)
 #include <sys/timeb.h>
 #endif
 #include "pthread.h"
 #include "implement.h"
 #include "ptw32_mutex_check_need_init.c"
 #include "pthread_mutex_init.c"
 #include "pthread_mutex_destroy.c"
 #include "pthread_mutexattr_init.c"
 #include "pthread_mutexattr_destroy.c"
 #include "pthread_mutexattr_getpshared.c"
 #include "pthread_mutexattr_setpshared.c"
 #include "pthread_mutexattr_settype.c"
 #include "pthread_mutexattr_gettype.c"
 #include "pthread_mutexattr_setrobust.c"
 #include "pthread_mutexattr_getrobust.c"
 #include "pthread_mutex_lock.c"
 #include "pthread_mutex_timedlock.c"
 #include "pthread_mutex_unlock.c"
 #include "pthread_mutex_trylock.c"
 #include "pthread_mutex_consistent.c"
--- a/deps/uv/deps/pthread-win32/need_errno.h
+++ b/deps/uv/deps/pthread-win32/need_errno.h
@ -1,145 +0,0 @@
 /***
 * errno.h - system wide error numbers (set by system calls)
 *
 *       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
 *
 * Purpose:
 *       This file defines the system-wide error numbers (set by
 *       system calls).  Conforms to the XENIX standard.  Extended
 *       for compatibility with Uniforum standard.
 *       [System V]
 *
 *       [Public]
 *
 ****/
 #if     _MSC_VER > 1000
 #pragma once
 #endif
 #if !defined(_INC_ERRNO)
 #define _INC_ERRNO
 #if !defined(_WIN32)
 #error ERROR: Only Win32 targets supported!
 #endif
 #include <winsock.h>
 #if defined(__cplusplus)
 extern "C" {
 #endif
 /* Define _CRTIMP */
 #ifndef _CRTIMP
 #if defined(_DLL)
 #define _CRTIMP __declspec(dllimport)
 #else   /* ndef _DLL */
 #define _CRTIMP
 #endif  /* _DLL */
 #endif  /* _CRTIMP */
 /* Define __cdecl for non-Microsoft compilers */
 #if ( !defined(_MSC_VER) && !defined(__cdecl) )
 #define __cdecl
 #endif
 /* Define _CRTAPI1 (for compatibility with the NT SDK) */
 #if !defined(_CRTAPI1)
 #if	_MSC_VER >= 800 && _M_IX86 >= 300
 #define _CRTAPI1 __cdecl
 #else
 #define _CRTAPI1
 #endif
 #endif
 #if !defined(PTW32_STATIC_LIB)
 #  if defined(PTW32_BUILD)
 #    define PTW32_DLLPORT __declspec (dllexport)
 #  else
 #    define PTW32_DLLPORT __declspec (dllimport)
 #  endif
 #else
 #  define PTW32_DLLPORT
 #endif
 /* declare reference to errno */
 #if (defined(_MT) || defined(_MD) || defined(_DLL)) && !defined(_MAC)
 PTW32_DLLPORT int * __cdecl _errno(void);
 #define errno   (*_errno())
 #else   /* ndef _MT && ndef _MD && ndef _DLL */
 _CRTIMP extern int errno;
 #endif  /* _MT || _MD || _DLL */
 /* Error Codes */
 #define EPERM           1
 #define ENOENT          2
 #define ESRCH           3
 #define EINTR           4
 #define EIO             5
 #define ENXIO           6
 #define E2BIG           7
 #define ENOEXEC         8
 #define EBADF           9
 #define ECHILD          10
 #define EAGAIN          11
 #define ENOMEM          12
 #define EACCES          13
 #define EFAULT          14
 #define EBUSY           16
 #define EEXIST          17
 #define EXDEV           18
 #define ENODEV          19
 #define ENOTDIR         20
 #define EISDIR          21
 #define EINVAL          22
 #define ENFILE          23
 #define EMFILE          24
 #define ENOTTY          25
 #define EFBIG           27
 #define ENOSPC          28
 #define ESPIPE          29
 #define EROFS           30
 #define EMLINK          31
 #define EPIPE           32
 #define EDOM            33
 #define ERANGE          34
 #define EDEADLK         36
 /* defined differently in winsock.h on WinCE */
 #if !defined(ENAMETOOLONG)
 #define ENAMETOOLONG    38
 #endif
 #define ENOLCK          39
 #define ENOSYS          40
 /* defined differently in winsock.h on WinCE */
 #if !defined(ENOTEMPTY)
 #define ENOTEMPTY       41
 #endif
 #define EILSEQ          42
 /* POSIX 2008 - robust mutexes */
 #define EOWNERDEAD	43
 #define ENOTRECOVERABLE	44
 /*
 * Support EDEADLOCK for compatibiity with older MS-C versions.
 */
 #define EDEADLOCK       EDEADLK
 #if defined(__cplusplus)
 }
 #endif
 #endif  /* _INC_ERRNO */
--- a/deps/uv/deps/pthread-win32/nonportable.c
+++ b/deps/uv/deps/pthread-win32/nonportable.c
@ -1,47 +0,0 @@
 /*
 * nonportable.c
 *
 * Description:
 * This translation unit implements non-portable thread functions.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "pthread_mutexattr_setkind_np.c"
 #include "pthread_mutexattr_getkind_np.c"
 #include "pthread_getw32threadhandle_np.c"
 #include "pthread_getunique_np.c"
 #include "pthread_delay_np.c"
 #include "pthread_num_processors_np.c"
 #include "pthread_win32_attach_detach_np.c"
 #include "pthread_timechange_handler_np.c"
--- a/deps/uv/deps/pthread-win32/private.c
+++ b/deps/uv/deps/pthread-win32/private.c
@ -1,54 +0,0 @@
 /*
 * private.c
 *
 * Description:
 * This translation unit implements routines which are private to
 * the implementation and may be used throughout it.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "ptw32_MCS_lock.c"
 #include "ptw32_is_attr.c"
 #include "ptw32_processInitialize.c"
 #include "ptw32_processTerminate.c"
 #include "ptw32_threadStart.c"
 #include "ptw32_threadDestroy.c"
 #include "ptw32_tkAssocCreate.c"
 #include "ptw32_tkAssocDestroy.c"
 #include "ptw32_callUserDestroyRoutines.c"
 #include "ptw32_semwait.c"
 #include "ptw32_timespec.c"
 #include "ptw32_relmillisecs.c"
 #include "ptw32_throw.c"
 #include "ptw32_getprocessors.c"
--- a/deps/uv/deps/pthread-win32/pthread-win32.gyp
+++ b/deps/uv/deps/pthread-win32/pthread-win32.gyp
@ -1,165 +0,0 @@
 {
  'targets': [
    {
      'target_name': 'pthread-win32',
      'type': '<(library)',
      'include_dirs': [
        '.'
      ],
      'direct_dependent_settings': {
        'include_dirs': [
          '.'
        ],
      },
      'conditions': [
        ['OS=="win"', {
          'defines': [
            'HAVE_PTW32_CONFIG_H',
            '__CLEANUP_C'
          ],
          'sources': [
            'autostatic.c',
            'cleanup.c',
            'create.c',
            'dll.c',
            'errno.c',
            'fork.c',
            'global.c',
            'pthread_attr_destroy.c',
            'pthread_attr_getdetachstate.c',
            'pthread_attr_getinheritsched.c',
            'pthread_attr_getschedparam.c',
            'pthread_attr_getschedpolicy.c',
            'pthread_attr_getscope.c',
            'pthread_attr_getstackaddr.c',
            'pthread_attr_getstacksize.c',
            'pthread_attr_init.c',
            'pthread_attr_setdetachstate.c',
            'pthread_attr_setinheritsched.c',
            'pthread_attr_setschedparam.c',
            'pthread_attr_setschedpolicy.c',
            'pthread_attr_setscope.c',
            'pthread_attr_setstackaddr.c',
            'pthread_attr_setstacksize.c',
            'pthread_barrierattr_destroy.c',
            'pthread_barrierattr_getpshared.c',
            'pthread_barrierattr_init.c',
            'pthread_barrierattr_setpshared.c',
            'pthread_barrier_destroy.c',
            'pthread_barrier_init.c',
            'pthread_barrier_wait.c',
            'pthread_cancel.c',
            'pthread_condattr_destroy.c',
            'pthread_condattr_getpshared.c',
            'pthread_condattr_init.c',
            'pthread_condattr_setpshared.c',
            'pthread_cond_destroy.c',
            'pthread_cond_init.c',
            'pthread_cond_signal.c',
            'pthread_cond_wait.c',
            'pthread_delay_np.c',
            'pthread_detach.c',
            'pthread_equal.c',
            'pthread_exit.c',
            'pthread_getconcurrency.c',
            'pthread_getschedparam.c',
            'pthread_getspecific.c',
            'pthread_getunique_np.c',
            'pthread_getw32threadhandle_np.c',
            'pthread_join.c',
            'pthread_key_create.c',
            'pthread_key_delete.c',
            'pthread_kill.c',
            'pthread_mutexattr_destroy.c',
            'pthread_mutexattr_getkind_np.c',
            'pthread_mutexattr_getpshared.c',
            'pthread_mutexattr_getrobust.c',
            'pthread_mutexattr_gettype.c',
            'pthread_mutexattr_init.c',
            'pthread_mutexattr_setkind_np.c',
            'pthread_mutexattr_setpshared.c',
            'pthread_mutexattr_setrobust.c',
            'pthread_mutexattr_settype.c',
            'pthread_mutex_consistent.c',
            'pthread_mutex_destroy.c',
            'pthread_mutex_init.c',
            'pthread_mutex_lock.c',
            'pthread_mutex_timedlock.c',
            'pthread_mutex_trylock.c',
            'pthread_mutex_unlock.c',
            'pthread_num_processors_np.c',
            'pthread_once.c',
            'pthread_rwlockattr_destroy.c',
            'pthread_rwlockattr_getpshared.c',
            'pthread_rwlockattr_init.c',
            'pthread_rwlockattr_setpshared.c',
            'pthread_rwlock_destroy.c',
            'pthread_rwlock_init.c',
            'pthread_rwlock_rdlock.c',
            'pthread_rwlock_timedrdlock.c',
            'pthread_rwlock_timedwrlock.c',
            'pthread_rwlock_tryrdlock.c',
            'pthread_rwlock_trywrlock.c',
            'pthread_rwlock_unlock.c',
            'pthread_rwlock_wrlock.c',
            'pthread_self.c',
            'pthread_setcancelstate.c',
            'pthread_setcanceltype.c',
            'pthread_setconcurrency.c',
            'pthread_setschedparam.c',
            'pthread_setspecific.c',
            'pthread_spin_destroy.c',
            'pthread_spin_init.c',
            'pthread_spin_lock.c',
            'pthread_spin_trylock.c',
            'pthread_spin_unlock.c',
            'pthread_testcancel.c',
            'pthread_timechange_handler_np.c',
            'pthread_win32_attach_detach_np.c',
            'ptw32_calloc.c',
            'ptw32_callUserDestroyRoutines.c',
            'ptw32_cond_check_need_init.c',
            'ptw32_getprocessors.c',
            'ptw32_is_attr.c',
            'ptw32_MCS_lock.c',
            'ptw32_mutex_check_need_init.c',
            'ptw32_new.c',
            'ptw32_processInitialize.c',
            'ptw32_processTerminate.c',
            'ptw32_relmillisecs.c',
            'ptw32_reuse.c',
            'ptw32_rwlock_cancelwrwait.c',
            'ptw32_rwlock_check_need_init.c',
            'ptw32_semwait.c',
            'ptw32_spinlock_check_need_init.c',
            'ptw32_threadDestroy.c',
            'ptw32_threadStart.c',
            'ptw32_throw.c',
            'ptw32_timespec.c',
            'ptw32_tkAssocCreate.c',
            'ptw32_tkAssocDestroy.c',
            'sched_getscheduler.c',
            'sched_get_priority_max.c',
            'sched_get_priority_min.c',
            'sched_setscheduler.c',
            'sched_yield.c',
            'sem_close.c',
            'sem_destroy.c',
            'sem_getvalue.c',
            'sem_init.c',
            'sem_open.c',
            'sem_post.c',
            'sem_post_multiple.c',
            'sem_timedwait.c',
            'sem_trywait.c',
            'sem_unlink.c',
            'sem_wait.c',
            'signal.c',
            'w32_CancelableWait.c',
          ],
        }]
      ],
    },
  ]
 }
--- a/deps/uv/deps/pthread-win32/pthread.c
+++ b/deps/uv/deps/pthread-win32/pthread.c
@ -1,66 +0,0 @@
 /*
 * pthread.c
 *
 * Description:
 * This translation unit agregates pthreads-win32 translation units.
 * It is used for inline optimisation of the library,
 * maximising for speed at the expense of size.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /* The following are ordered for inlining */
 #include "private.c"
 #include "attr.c"
 #include "barrier.c"
 #include "cancel.c"
 #include "cleanup.c"
 #include "condvar.c"
 #include "create.c"
 #include "dll.c"
 #include "autostatic.c"
 #include "errno.c"
 #include "exit.c"
 #include "fork.c"
 #include "global.c"
 #include "misc.c"
 #include "mutex.c"
 #include "nonportable.c"
 #include "rwlock.c"
 #include "sched.c"
 #include "semaphore.c"
 #include "signal.c"
 #include "spin.c"
 #include "sync.c"
 #include "tsd.c"
--- a/deps/uv/deps/pthread-win32/pthread.dsp
+++ b/deps/uv/deps/pthread-win32/pthread.dsp
@ -1,142 +0,0 @@
 # Microsoft Developer Studio Project File - Name="pthread" - Package Owner=<4>
 # Microsoft Developer Studio Generated Build File, Format Version 6.00
 # ** DO NOT EDIT **
 # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
 CFG=pthread - Win32 Debug
 !MESSAGE This is not a valid makefile. To build this project using NMAKE,
 !MESSAGE use the Export Makefile command and run
 !MESSAGE 
 !MESSAGE NMAKE /f "pthread.mak".
 !MESSAGE 
 !MESSAGE You can specify a configuration when running NMAKE
 !MESSAGE by defining the macro CFG on the command line. For example:
 !MESSAGE 
 !MESSAGE NMAKE /f "pthread.mak" CFG="pthread - Win32 Debug"
 !MESSAGE 
 !MESSAGE Possible choices for configuration are:
 !MESSAGE 
 !MESSAGE "pthread - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE "pthread - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE 
 # Begin Project
 # PROP AllowPerConfigDependencies 0
 # PROP Scc_ProjName ""
 # PROP Scc_LocalPath ""
 CPP=cl.exe
 MTL=midl.exe
 RSC=rc.exe
 !IF  "$(CFG)" == "pthread - Win32 Release"
 # PROP BASE Use_MFC 0
 # PROP BASE Use_Debug_Libraries 0
 # PROP BASE Output_Dir "Release"
 # PROP BASE Intermediate_Dir "Release"
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 0
 # PROP Output_Dir "."
 # PROP Intermediate_Dir "."
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PTW32_BUILD" /YX /FD /c
 # ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "__CLEANUP_C" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PTW32_BUILD" /YX /FD /c
 # SUBTRACT CPP /u
 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x809 /d "NDEBUG"
 # ADD RSC /l 0x409 /i "." /d "NDEBUG" /d "PTW32_RC_MSC"
 BSC32=bscmake.exe
 # ADD BASE BSC32 /nologo
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
 # ADD LINK32 kernel32.lib user32.lib ws2_32.lib /nologo /dll /pdb:none /machine:I386 /out:".\pthreadVC2.dll"
 !ELSEIF  "$(CFG)" == "pthread - Win32 Debug"
 # PROP BASE Use_MFC 0
 # PROP BASE Use_Debug_Libraries 1
 # PROP BASE Output_Dir "Debug"
 # PROP BASE Intermediate_Dir "Debug"
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 1
 # PROP Output_Dir "."
 # PROP Intermediate_Dir "."
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PTW32_BUILD" /YX /FD /GZ /c
 # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "__CLEANUP_C" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PTW32_BUILD" /YX /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x809 /d "_DEBUG"
 # ADD RSC /l 0x409 /i "." /d "_DEBUG" /d "PTW32_RC_MSC"
 BSC32=bscmake.exe
 # ADD BASE BSC32 /nologo
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
 # ADD LINK32 kernel32.lib user32.lib ws2_32.lib /nologo /dll /map /debug /machine:I386 /out:".\pthreadVC2.dll" /pdbtype:sept
 # SUBTRACT LINK32 /pdb:none
 !ENDIF 
 # Begin Target
 # Name "pthread - Win32 Release"
 # Name "pthread - Win32 Debug"
 # Begin Group "Source Files"
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 # Begin Source File
 SOURCE=.\pthread.c
 # End Source File
 # End Group
 # Begin Group "Header Files"
 # PROP Default_Filter "h;hpp;hxx;hm;inl"
 # Begin Source File
 SOURCE=.\implement.h
 # End Source File
 # Begin Source File
 SOURCE=.\pthread.h
 # End Source File
 # Begin Source File
 SOURCE=.\sched.h
 # End Source File
 # Begin Source File
 SOURCE=.\semaphore.h
 # End Source File
 # End Group
 # Begin Group "Resource Files"
 # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
 # Begin Source File
 SOURCE=.\version.rc
 !IF  "$(CFG)" == "pthread - Win32 Release"
 # ADD BASE RSC /l 0xc09
 # ADD RSC /l 0x409 /i "." /d "PTW32_RC_MSC"
 !ELSEIF  "$(CFG)" == "pthread - Win32 Debug"
 # ADD BASE RSC /l 0xc09
 # ADD RSC /l 0x409 /i "." /d "PTW32_RC_MSC"
 !ENDIF 
 # End Source File
 # End Group
 # End Target
 # End Project
--- a/deps/uv/deps/pthread-win32/pthread.dsw
+++ b/deps/uv/deps/pthread-win32/pthread.dsw
@ -1,29 +0,0 @@
 Microsoft Developer Studio Workspace File, Format Version 6.00
 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
 ###############################################################################
 Project: "pthread"=.\pthread.dsp - Package Owner=<4>
 Package=<5>
 {{{
 }}}
 Package=<4>
 {{{
 }}}
 ###############################################################################
 Global:
 Package=<5>
 {{{
 }}}
 Package=<3>
 {{{
 }}}
 ###############################################################################
--- a/deps/uv/deps/pthread-win32/pthread.h
+++ b/deps/uv/deps/pthread-win32/pthread.h
--- a/deps/uv/deps/pthread-win32/pthread_attr_destroy.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_destroy.c
@ -1,79 +0,0 @@
 /*
 * pthread_attr_destroy.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_attr_destroy (pthread_attr_t * attr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Destroys a thread attributes object.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *
      * DESCRIPTION
      *      Destroys a thread attributes object.
      *
      *      NOTES:
      *              1)      Does not affect threads created with 'attr'.
      *
      * RESULTS
      *              0               successfully destroyed attr,
      *              EINVAL          'attr' is invalid.
      *
      * ------------------------------------------------------
      */
 {
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  /*
   * Set the attribute object to a specific invalid value.
   */
  (*attr)->valid = 0;
  free (*attr);
  *attr = NULL;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_getdetachstate.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_getdetachstate.c
@ -1,86 +0,0 @@
 /*
 * pthread_attr_getdetachstate.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_attr_getdetachstate (const pthread_attr_t * attr, int *detachstate)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function determines whether threads created with
      *      'attr' will run detached.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *      detachstate
      *              pointer to an integer into which is returned one
      *              of:
      *
      *              PTHREAD_CREATE_JOINABLE
      *                              Thread ID is valid, must be joined
      *
      *              PTHREAD_CREATE_DETACHED
      *                              Thread ID is invalid, cannot be joined,
      *                              canceled, or modified
      *
      *
      * DESCRIPTION
      *      This function determines whether threads created with
      *      'attr' will run detached.
      *
      *      NOTES:
      *              1)      You cannot join or cancel detached threads.
      *
      * RESULTS
      *              0               successfully retrieved detach state,
      *              EINVAL          'attr' is invalid
      *
      * ------------------------------------------------------
      */
 {
  if (ptw32_is_attr (attr) != 0 || detachstate == NULL)
    {
      return EINVAL;
    }
  *detachstate = (*attr)->detachstate;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_getinheritsched.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_getinheritsched.c
@ -1,51 +0,0 @@
 /*
 * pthread_attr_getinheritsched.c
 * 
 * Description:
 * POSIX thread functions that deal with thread scheduling.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "sched.h"
 int
 pthread_attr_getinheritsched (const pthread_attr_t * attr, int *inheritsched)
 {
  if (ptw32_is_attr (attr) != 0 || inheritsched == NULL)
    {
      return EINVAL;
    }
  *inheritsched = (*attr)->inheritsched;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_getschedparam.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_getschedparam.c
@ -1,52 +0,0 @@
 /*
 * pthread_attr_getschedparam.c
 * 
 * Description:
 * POSIX thread functions that deal with thread scheduling.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "sched.h"
 int
 pthread_attr_getschedparam (const pthread_attr_t * attr,
 			    struct sched_param *param)
 {
  if (ptw32_is_attr (attr) != 0 || param == NULL)
    {
      return EINVAL;
    }
  memcpy (param, &(*attr)->param, sizeof (*param));
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_getschedpolicy.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_getschedpolicy.c
@ -1,61 +0,0 @@
 /*
 * pthread_attr_getschedpolicy.c
 * 
 * Description:
 * POSIX thread functions that deal with thread scheduling.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "sched.h"
 int
 pthread_attr_getschedpolicy (const pthread_attr_t * attr, int *policy)
 {
  if (ptw32_is_attr (attr) != 0 || policy == NULL)
    {
      return EINVAL;
    }
  /*
   * Validate the policy arg.
   * Check that a policy constant wasn't passed rather than &policy.
   */
  if (policy <= (int *) SCHED_MAX)
    {
      return EINVAL;
    }
  *policy = SCHED_OTHER;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_getscope.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_getscope.c
@ -1,54 +0,0 @@
 /*
 * pthread_attr_getscope.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /* ignore warning "unreferenced formal parameter" */
 #if defined(_MSC_VER)
 #pragma warning( disable : 4100 )
 #endif
 int
 pthread_attr_getscope (const pthread_attr_t * attr, int *contentionscope)
 {
 #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
  *contentionscope = (*attr)->contentionscope;
  return 0;
 #else
  return ENOSYS;
 #endif
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_getstackaddr.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_getstackaddr.c
@ -1,97 +0,0 @@
 /*
 * pthread_attr_getstackaddr.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /* ignore warning "unreferenced formal parameter" */
 #if defined(_MSC_VER)
 #pragma warning( disable : 4100 )
 #endif
 int
 pthread_attr_getstackaddr (const pthread_attr_t * attr, void **stackaddr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function determines the address of the stack
      *      on which threads created with 'attr' will run.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *      stackaddr
      *              pointer into which is returned the stack address.
      *
      *
      * DESCRIPTION
      *      This function determines the address of the stack
      *      on which threads created with 'attr' will run.
      *
      *      NOTES:
      *              1)      Function supported only if this macro is
      *                      defined:
      *
      *                              _POSIX_THREAD_ATTR_STACKADDR
      *
      *              2)      Create only one thread for each stack
      *                      address..
      *
      * RESULTS
      *              0               successfully retreived stack address,
      *              EINVAL          'attr' is invalid
      *              ENOSYS          function not supported
      *
      * ------------------------------------------------------
      */
 {
 #if defined( _POSIX_THREAD_ATTR_STACKADDR )
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  *stackaddr = (*attr)->stackaddr;
  return 0;
 #else
  return ENOSYS;
 #endif /* _POSIX_THREAD_ATTR_STACKADDR */
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_getstacksize.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_getstacksize.c
@ -1,100 +0,0 @@
 /*
 * pthread_attr_getstacksize.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /* ignore warning "unreferenced formal parameter" */
 #if defined(_MSC_VER)
 #pragma warning( disable : 4100 )
 #endif
 int
 pthread_attr_getstacksize (const pthread_attr_t * attr, size_t * stacksize)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function determines the size of the stack on
      *      which threads created with 'attr' will run.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *      stacksize
      *              pointer to size_t into which is returned the
      *              stack size, in bytes.
      *
      *
      * DESCRIPTION
      *      This function determines the size of the stack on
      *      which threads created with 'attr' will run.
      *
      *      NOTES:
      *              1)      Function supported only if this macro is
      *                      defined:
      *
      *                              _POSIX_THREAD_ATTR_STACKSIZE
      *
      *              2)      Use on newly created attributes object to
      *                      find the default stack size.
      *
      * RESULTS
      *              0               successfully retrieved stack size,
      *              EINVAL          'attr' is invalid
      *              ENOSYS          function not supported
      *
      * ------------------------------------------------------
      */
 {
 #if defined(_POSIX_THREAD_ATTR_STACKSIZE)
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  /* Everything is okay. */
  *stacksize = (*attr)->stacksize;
  return 0;
 #else
  return ENOSYS;
 #endif /* _POSIX_THREAD_ATTR_STACKSIZE */
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_init.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_init.c
@ -1,117 +0,0 @@
 /*
 * pthread_attr_init.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_attr_init (pthread_attr_t * attr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Initializes a thread attributes object with default
      *      attributes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *
      * DESCRIPTION
      *      Initializes a thread attributes object with default
      *      attributes.
      *
      *      NOTES:
      *              1)      Used to define thread attributes
      *
      * RESULTS
      *              0               successfully initialized attr,
      *              ENOMEM          insufficient memory for attr.
      *
      * ------------------------------------------------------
      */
 {
  pthread_attr_t attr_result;
  if (attr == NULL)
    {
      /* This is disallowed. */
      return EINVAL;
    }
  attr_result = (pthread_attr_t) malloc (sizeof (*attr_result));
  if (attr_result == NULL)
    {
      return ENOMEM;
    }
 #if defined(_POSIX_THREAD_ATTR_STACKSIZE)
  /*
   * Default to zero size. Unless changed explicitly this
   * will allow Win32 to set the size to that of the
   * main thread.
   */
  attr_result->stacksize = 0;
 #endif
 #if defined(_POSIX_THREAD_ATTR_STACKADDR)
  /* FIXME: Set this to something sensible when we support it. */
  attr_result->stackaddr = NULL;
 #endif
  attr_result->detachstate = PTHREAD_CREATE_JOINABLE;
 #if defined(HAVE_SIGSET_T)
  memset (&(attr_result->sigmask), 0, sizeof (sigset_t));
 #endif /* HAVE_SIGSET_T */
  /*
   * Win32 sets new threads to THREAD_PRIORITY_NORMAL and
   * not to that of the parent thread. We choose to default to
   * this arrangement.
   */
  attr_result->param.sched_priority = THREAD_PRIORITY_NORMAL;
  attr_result->inheritsched = PTHREAD_EXPLICIT_SCHED;
  attr_result->contentionscope = PTHREAD_SCOPE_SYSTEM;
  attr_result->valid = PTW32_ATTR_VALID;
  *attr = attr_result;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_setdetachstate.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_setdetachstate.c
@ -1,91 +0,0 @@
 /*
 * pthread_attr_setdetachstate.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function specifies whether threads created with
      *      'attr' will run detached.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *      detachstate
      *              an integer containing one of:
      *
      *              PTHREAD_CREATE_JOINABLE
      *                              Thread ID is valid, must be joined
      *
      *              PTHREAD_CREATE_DETACHED
      *                              Thread ID is invalid, cannot be joined,
      *                              canceled, or modified
      *
      *
      * DESCRIPTION
      *      This function specifies whether threads created with
      *      'attr' will run detached.
      *
      *      NOTES:
      *              1)      You cannot join or cancel detached threads.
      *
      * RESULTS
      *              0               successfully set detach state,
      *              EINVAL          'attr' or 'detachstate' is invalid
      *
      * ------------------------------------------------------
      */
 {
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  if (detachstate != PTHREAD_CREATE_JOINABLE &&
      detachstate != PTHREAD_CREATE_DETACHED)
    {
      return EINVAL;
    }
  (*attr)->detachstate = detachstate;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_setinheritsched.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_setinheritsched.c
@ -1,57 +0,0 @@
 /*
 * pthread_attr_setinheritsched.c
 * 
 * Description:
 * POSIX thread functions that deal with thread scheduling.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "sched.h"
 int
 pthread_attr_setinheritsched (pthread_attr_t * attr, int inheritsched)
 {
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  if (PTHREAD_INHERIT_SCHED != inheritsched
      && PTHREAD_EXPLICIT_SCHED != inheritsched)
    {
      return EINVAL;
    }
  (*attr)->inheritsched = inheritsched;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_setschedparam.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_setschedparam.c
@ -1,63 +0,0 @@
 /*
 * pthread_attr_setschedparam.c
 * 
 * Description:
 * POSIX thread functions that deal with thread scheduling.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "sched.h"
 int
 pthread_attr_setschedparam (pthread_attr_t * attr,
 			    const struct sched_param *param)
 {
  int priority;
  if (ptw32_is_attr (attr) != 0 || param == NULL)
    {
      return EINVAL;
    }
  priority = param->sched_priority;
  /* Validate priority level. */
  if (priority < sched_get_priority_min (SCHED_OTHER) ||
      priority > sched_get_priority_max (SCHED_OTHER))
    {
      return EINVAL;
    }
  memcpy (&(*attr)->param, param, sizeof (*param));
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_setschedpolicy.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_setschedpolicy.c
@ -1,55 +0,0 @@
 /*
 * pthread_attr_setschedpolicy.c
 * 
 * Description:
 * POSIX thread functions that deal with thread scheduling.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "sched.h"
 int
 pthread_attr_setschedpolicy (pthread_attr_t * attr, int policy)
 {
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  if (policy != SCHED_OTHER)
    {
      return ENOTSUP;
    }
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_setscope.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_setscope.c
@ -1,62 +0,0 @@
 /*
 * pthread_attr_setscope.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /* ignore warning "unreferenced formal parameter" */
 #if defined(_MSC_VER)
 #pragma warning( disable : 4100 )
 #endif
 int
 pthread_attr_setscope (pthread_attr_t * attr, int contentionscope)
 {
 #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
  switch (contentionscope)
    {
    case PTHREAD_SCOPE_SYSTEM:
      (*attr)->contentionscope = contentionscope;
      return 0;
    case PTHREAD_SCOPE_PROCESS:
      return ENOTSUP;
    default:
      return EINVAL;
    }
 #else
  return ENOSYS;
 #endif
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_setstackaddr.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_setstackaddr.c
@ -1,97 +0,0 @@
 /*
 * pthread_attr_setstackaddr.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_attr_setstackaddr (pthread_attr_t * attr, void *stackaddr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Threads created with 'attr' will run on the stack
      *      starting at 'stackaddr'.
      *      Stack must be at least PTHREAD_STACK_MIN bytes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *      stackaddr
      *              the address of the stack to use
      *
      *
      * DESCRIPTION
      *      Threads created with 'attr' will run on the stack
      *      starting at 'stackaddr'.
      *      Stack must be at least PTHREAD_STACK_MIN bytes.
      *
      *      NOTES:
      *              1)      Function supported only if this macro is
      *                      defined:
      *
      *                              _POSIX_THREAD_ATTR_STACKADDR
      *
      *              2)      Create only one thread for each stack
      *                      address..
      *
      *              3)      Ensure that stackaddr is aligned.
      *
      * RESULTS
      *              0               successfully set stack address,
      *              EINVAL          'attr' is invalid
      *              ENOSYS          function not supported
      *
      * ------------------------------------------------------
      */
 {
 #if defined( _POSIX_THREAD_ATTR_STACKADDR )
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  (*attr)->stackaddr = stackaddr;
  return 0;
 #else
  return ENOSYS;
 #endif /* _POSIX_THREAD_ATTR_STACKADDR */
 }
--- a/deps/uv/deps/pthread-win32/pthread_attr_setstacksize.c
+++ b/deps/uv/deps/pthread-win32/pthread_attr_setstacksize.c
@ -1,110 +0,0 @@
 /*
 * pthread_attr_setstacksize.c
 *
 * Description:
 * This translation unit implements operations on thread attribute objects.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_attr_setstacksize (pthread_attr_t * attr, size_t stacksize)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function specifies the size of the stack on
      *      which threads created with 'attr' will run.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_attr_t
      *
      *      stacksize
      *              stack size, in bytes.
      *
      *
      * DESCRIPTION
      *      This function specifies the size of the stack on
      *      which threads created with 'attr' will run.
      *
      *      NOTES:
      *              1)      Function supported only if this macro is
      *                      defined:
      *
      *                              _POSIX_THREAD_ATTR_STACKSIZE
      *
      *              2)      Find the default first (using
      *                      pthread_attr_getstacksize), then increase
      *                      by multiplying.
      *
      *              3)      Only use if thread needs more than the
      *                      default.
      *
      * RESULTS
      *              0               successfully set stack size,
      *              EINVAL          'attr' is invalid or stacksize too
      *                              small or too big.
      *              ENOSYS          function not supported
      *
      * ------------------------------------------------------
      */
 {
 #if defined(_POSIX_THREAD_ATTR_STACKSIZE)
 #if PTHREAD_STACK_MIN > 0
  /*  Verify that the stack size is within range. */
  if (stacksize < PTHREAD_STACK_MIN)
    {
      return EINVAL;
    }
 #endif
  if (ptw32_is_attr (attr) != 0)
    {
      return EINVAL;
    }
  /* Everything is okay. */
  (*attr)->stacksize = stacksize;
  return 0;
 #else
  return ENOSYS;
 #endif /* _POSIX_THREAD_ATTR_STACKSIZE */
 }
--- a/deps/uv/deps/pthread-win32/pthread_barrier_destroy.c
+++ b/deps/uv/deps/pthread-win32/pthread_barrier_destroy.c
@ -1,103 +0,0 @@
 /*
 * pthread_barrier_destroy.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_barrier_destroy (pthread_barrier_t * barrier)
 {
  int result = 0;
  pthread_barrier_t b;
  ptw32_mcs_local_node_t node;
  if (barrier == NULL || *barrier == (pthread_barrier_t) PTW32_OBJECT_INVALID)
    {
      return EINVAL;
    }
  if (0 != ptw32_mcs_lock_try_acquire(&(*barrier)->lock, &node))
    {
      return EBUSY;
    }
  b = *barrier;
  if (b->nCurrentBarrierHeight < b->nInitialBarrierHeight)
    {
      result = EBUSY;
    }
  else
 	{
      if (0 == (result = sem_destroy (&(b->semBarrierBreeched))))
        {
          *barrier = (pthread_barrier_t) PTW32_OBJECT_INVALID;
          /*
           * Release the lock before freeing b.
           *
           * FIXME: There may be successors which, when we release the lock,
           * will be linked into b->lock, which will be corrupted at some
           * point with undefined results for the application. To fix this
           * will require changing pthread_barrier_t from a pointer to
           * pthread_barrier_t_ to an instance. This is a change to the ABI
           * and will require a major version number increment.
           */
          ptw32_mcs_lock_release(&node);
 	  (void) free (b);
 	  return 0;
 	}
      else
        {
          /*
           * This should not ever be reached.
           * Restore the barrier to working condition before returning.
           */
          (void) sem_init (&(b->semBarrierBreeched), b->pshared, 0);
        }
      if (result != 0)
        {
          /*
           * The barrier still exists and is valid
           * in the event of any error above.
           */
          result = EBUSY;
        }
    }
  ptw32_mcs_lock_release(&node);
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_barrier_init.c
+++ b/deps/uv/deps/pthread-win32/pthread_barrier_init.c
@ -1,69 +0,0 @@
 /*
 * pthread_barrier_init.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_barrier_init (pthread_barrier_t * barrier,
 		      const pthread_barrierattr_t * attr, unsigned int count)
 {
  pthread_barrier_t b;
  if (barrier == NULL || count == 0)
    {
      return EINVAL;
    }
  if (NULL != (b = (pthread_barrier_t) calloc (1, sizeof (*b))))
    {
      b->pshared = (attr != NULL && *attr != NULL
 		    ? (*attr)->pshared : PTHREAD_PROCESS_PRIVATE);
      b->nCurrentBarrierHeight = b->nInitialBarrierHeight = count;
      b->lock = 0;
      if (0 == sem_init (&(b->semBarrierBreeched), b->pshared, 0))
 	    {
 	      *barrier = b;
 	      return 0;
 	    }
      (void) free (b);
    }
  return ENOMEM;
 }
--- a/deps/uv/deps/pthread-win32/pthread_barrier_wait.c
+++ b/deps/uv/deps/pthread-win32/pthread_barrier_wait.c
@ -1,104 +0,0 @@
 /*
 * pthread_barrier_wait.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_barrier_wait (pthread_barrier_t * barrier)
 {
  int result;
  pthread_barrier_t b;
  ptw32_mcs_local_node_t node;
  if (barrier == NULL || *barrier == (pthread_barrier_t) PTW32_OBJECT_INVALID)
    {
      return EINVAL;
    }
  ptw32_mcs_lock_acquire(&(*barrier)->lock, &node);
  b = *barrier;
  if (--b->nCurrentBarrierHeight == 0)
    {
      /*
       * We are the last thread to arrive at the barrier before it releases us.
       * Move our MCS local node to the global scope barrier handle so that the
       * last thread out (not necessarily us) can release the lock.
       */
      ptw32_mcs_node_transfer(&b->proxynode, &node);
      /*
       * Any threads that have not quite entered sem_wait below when the
       * multiple_post has completed will nevertheless continue through
       * the semaphore (barrier).
       */
      result = (b->nInitialBarrierHeight > 1
                ? sem_post_multiple (&(b->semBarrierBreeched),
 				     b->nInitialBarrierHeight - 1) : 0);
    }
  else
    {
      ptw32_mcs_lock_release(&node);
      /*
       * Use the non-cancelable version of sem_wait().
       *
       * It is possible that all nInitialBarrierHeight-1 threads are
       * at this point when the last thread enters the barrier, resets
       * nCurrentBarrierHeight = nInitialBarrierHeight and leaves.
       * If pthread_barrier_destroy is called at that moment then the
       * barrier will be destroyed along with the semas.
       */
      result = ptw32_semwait (&(b->semBarrierBreeched));
    }
  if ((PTW32_INTERLOCKED_LONG)PTW32_INTERLOCKED_INCREMENT_LONG((PTW32_INTERLOCKED_LONGPTR)&b->nCurrentBarrierHeight)
 		  == (PTW32_INTERLOCKED_LONG)b->nInitialBarrierHeight)
    {
      /*
       * We are the last thread to cross this barrier
       */
      ptw32_mcs_lock_release(&b->proxynode);
      if (0 == result)
        {
          result = PTHREAD_BARRIER_SERIAL_THREAD;
        }
    }
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_barrierattr_destroy.c
+++ b/deps/uv/deps/pthread-win32/pthread_barrierattr_destroy.c
@ -1,83 +0,0 @@
 /*
 * pthread_barrier_attr_destroy.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_barrierattr_destroy (pthread_barrierattr_t * attr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Destroys a barrier attributes object. The object can
      *      no longer be used.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_barrierattr_t
      *
      *
      * DESCRIPTION
      *      Destroys a barrier attributes object. The object can
      *      no longer be used.
      *
      *      NOTES:
      *              1)      Does not affect barrieres created using 'attr'
      *
      * RESULTS
      *              0               successfully released attr,
      *              EINVAL          'attr' is invalid.
      *
      * ------------------------------------------------------
      */
 {
  int result = 0;
  if (attr == NULL || *attr == NULL)
    {
      result = EINVAL;
    }
  else
    {
      pthread_barrierattr_t ba = *attr;
      *attr = NULL;
      free (ba);
    }
  return (result);
 }				/* pthread_barrierattr_destroy */
--- a/deps/uv/deps/pthread-win32/pthread_barrierattr_getpshared.c
+++ b/deps/uv/deps/pthread-win32/pthread_barrierattr_getpshared.c
@ -1,95 +0,0 @@
 /*
 * pthread_barrier_attr_getpshared.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_barrierattr_getpshared (const pthread_barrierattr_t * attr,
 				int *pshared)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Determine whether barriers created with 'attr' can be
      *      shared between processes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_barrierattr_t
      *
      *      pshared
      *              will be set to one of:
      *
      *                      PTHREAD_PROCESS_SHARED
      *                              May be shared if in shared memory
      *
      *                      PTHREAD_PROCESS_PRIVATE
      *                              Cannot be shared.
      *
      *
      * DESCRIPTION
      *      Mutexes creatd with 'attr' can be shared between
      *      processes if pthread_barrier_t variable is allocated
      *      in memory shared by these processes.
      *      NOTES:
      *              1)      pshared barriers MUST be allocated in shared
      *                      memory.
      *              2)      The following macro is defined if shared barriers
      *                      are supported:
      *                              _POSIX_THREAD_PROCESS_SHARED
      *
      * RESULTS
      *              0               successfully retrieved attribute,
      *              EINVAL          'attr' is invalid,
      *
      * ------------------------------------------------------
      */
 {
  int result;
  if ((attr != NULL && *attr != NULL) && (pshared != NULL))
    {
      *pshared = (*attr)->pshared;
      result = 0;
    }
  else
    {
      result = EINVAL;
    }
  return (result);
 }				/* pthread_barrierattr_getpshared */
--- a/deps/uv/deps/pthread-win32/pthread_barrierattr_init.c
+++ b/deps/uv/deps/pthread-win32/pthread_barrierattr_init.c
@ -1,85 +0,0 @@
 /*
 * pthread_barrier_attr_init.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_barrierattr_init (pthread_barrierattr_t * attr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Initializes a barrier attributes object with default
      *      attributes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_barrierattr_t
      *
      *
      * DESCRIPTION
      *      Initializes a barrier attributes object with default
      *      attributes.
      *
      *      NOTES:
      *              1)      Used to define barrier types
      *
      * RESULTS
      *              0               successfully initialized attr,
      *              ENOMEM          insufficient memory for attr.
      *
      * ------------------------------------------------------
      */
 {
  pthread_barrierattr_t ba;
  int result = 0;
  ba = (pthread_barrierattr_t) calloc (1, sizeof (*ba));
  if (ba == NULL)
    {
      result = ENOMEM;
    }
  else
    {
      ba->pshared = PTHREAD_PROCESS_PRIVATE;
    }
  *attr = ba;
  return (result);
 }				/* pthread_barrierattr_init */
--- a/deps/uv/deps/pthread-win32/pthread_barrierattr_setpshared.c
+++ b/deps/uv/deps/pthread-win32/pthread_barrierattr_setpshared.c
@ -1,119 +0,0 @@
 /*
 * pthread_barrier_attr_setpshared.c
 *
 * Description:
 * This translation unit implements barrier primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_barrierattr_setpshared (pthread_barrierattr_t * attr, int pshared)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Barriers created with 'attr' can be shared between
      *      processes if pthread_barrier_t variable is allocated
      *      in memory shared by these processes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_barrierattr_t
      *
      *      pshared
      *              must be one of:
      *
      *                      PTHREAD_PROCESS_SHARED
      *                              May be shared if in shared memory
      *
      *                      PTHREAD_PROCESS_PRIVATE
      *                              Cannot be shared.
      *
      * DESCRIPTION
      *      Mutexes creatd with 'attr' can be shared between
      *      processes if pthread_barrier_t variable is allocated
      *      in memory shared by these processes.
      *
      *      NOTES:
      *              1)      pshared barriers MUST be allocated in shared
      *                      memory.
      *
      *              2)      The following macro is defined if shared barriers
      *                      are supported:
      *                              _POSIX_THREAD_PROCESS_SHARED
      *
      * RESULTS
      *              0               successfully set attribute,
      *              EINVAL          'attr' or pshared is invalid,
      *              ENOSYS          PTHREAD_PROCESS_SHARED not supported,
      *
      * ------------------------------------------------------
      */
 {
  int result;
  if ((attr != NULL && *attr != NULL) &&
      ((pshared == PTHREAD_PROCESS_SHARED) ||
       (pshared == PTHREAD_PROCESS_PRIVATE)))
    {
      if (pshared == PTHREAD_PROCESS_SHARED)
 	{
 #if !defined( _POSIX_THREAD_PROCESS_SHARED )
 	  result = ENOSYS;
 	  pshared = PTHREAD_PROCESS_PRIVATE;
 #else
 	  result = 0;
 #endif /* _POSIX_THREAD_PROCESS_SHARED */
 	}
      else
 	{
 	  result = 0;
 	}
      (*attr)->pshared = pshared;
    }
  else
    {
      result = EINVAL;
    }
  return (result);
 }				/* pthread_barrierattr_setpshared */
--- a/deps/uv/deps/pthread-win32/pthread_cancel.c
+++ b/deps/uv/deps/pthread-win32/pthread_cancel.c
@ -1,189 +0,0 @@
 /*
 * pthread_cancel.c
 *
 * Description:
 * POSIX thread functions related to thread cancellation.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "context.h"
 static void
 ptw32_cancel_self (void)
 {
  ptw32_throw (PTW32_EPS_CANCEL);
  /* Never reached */
 }
 static void CALLBACK
 ptw32_cancel_callback (ULONG_PTR unused)
 {
  ptw32_throw (PTW32_EPS_CANCEL);
  /* Never reached */
 }
 /*
 * ptw32_RegisterCancelation() -
 * Must have args of same type as QueueUserAPCEx because this function
 * is a substitute for QueueUserAPCEx if it's not available.
 */
 DWORD
 ptw32_RegisterCancelation (PAPCFUNC unused1, HANDLE threadH, DWORD unused2)
 {
  CONTEXT context;
  context.ContextFlags = CONTEXT_CONTROL;
  GetThreadContext (threadH, &context);
  PTW32_PROGCTR (context) = (DWORD_PTR) ptw32_cancel_self;
  SetThreadContext (threadH, &context);
  return 0;
 }
 int
 pthread_cancel (pthread_t thread)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function requests cancellation of 'thread'.
      *
      * PARAMETERS
      *      thread
      *              reference to an instance of pthread_t
      *
      *
      * DESCRIPTION
      *      This function requests cancellation of 'thread'.
      *      NOTE: cancellation is asynchronous; use pthread_join to
      *                wait for termination of 'thread' if necessary.
      *
      * RESULTS
      *              0               successfully requested cancellation,
      *              ESRCH           no thread found corresponding to 'thread',
      *              ENOMEM          implicit self thread create failed.
      * ------------------------------------------------------
      */
 {
  int result;
  int cancel_self;
  pthread_t self;
  ptw32_thread_t * tp;
  ptw32_mcs_local_node_t stateLock;
  result = pthread_kill (thread, 0);
  if (0 != result)
    {
      return result;
    }
  if ((self = pthread_self ()).p == NULL)
    {
      return ENOMEM;
    };
  /*
   * For self cancellation we need to ensure that a thread can't
   * deadlock itself trying to cancel itself asynchronously
   * (pthread_cancel is required to be an async-cancel
   * safe function).
   */
  cancel_self = pthread_equal (thread, self);
  tp = (ptw32_thread_t *) thread.p;
  /*
   * Lock for async-cancel safety.
   */
  ptw32_mcs_lock_acquire (&tp->stateLock, &stateLock);
  if (tp->cancelType == PTHREAD_CANCEL_ASYNCHRONOUS
      && tp->cancelState == PTHREAD_CANCEL_ENABLE
      && tp->state < PThreadStateCanceling)
    {
      if (cancel_self)
 	{
 	  tp->state = PThreadStateCanceling;
 	  tp->cancelState = PTHREAD_CANCEL_DISABLE;
 	  ptw32_mcs_lock_release (&stateLock);
 	  ptw32_throw (PTW32_EPS_CANCEL);
 	  /* Never reached */
 	}
      else
 	{
 	  HANDLE threadH = tp->threadH;
 	  SuspendThread (threadH);
 	  if (WaitForSingleObject (threadH, 0) == WAIT_TIMEOUT)
 	    {
 	      tp->state = PThreadStateCanceling;
 	      tp->cancelState = PTHREAD_CANCEL_DISABLE;
 	      /*
 	       * If alertdrv and QueueUserAPCEx is available then the following
 	       * will result in a call to QueueUserAPCEx with the args given, otherwise
 	       * this will result in a call to ptw32_RegisterCancelation and only
 	       * the threadH arg will be used.
 	       */
 	      ptw32_register_cancelation ((PAPCFUNC)ptw32_cancel_callback, threadH, 0);
 	      ptw32_mcs_lock_release (&stateLock);
 	      ResumeThread (threadH);
 	    }
 	}
    }
  else
    {
      /*
       * Set for deferred cancellation.
       */
      if (tp->state < PThreadStateCancelPending)
 	{
 	  tp->state = PThreadStateCancelPending;
 	  if (!SetEvent (tp->cancelEvent))
 	    {
 	      result = ESRCH;
 	    }
 	}
      else if (tp->state >= PThreadStateCanceling)
 	{
 	  result = ESRCH;
 	}
      ptw32_mcs_lock_release (&stateLock);
    }
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_cond_destroy.c
+++ b/deps/uv/deps/pthread-win32/pthread_cond_destroy.c
@ -1,253 +0,0 @@
 /*
 * pthread_cond_destroy.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_cond_destroy (pthread_cond_t * cond)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function destroys a condition variable
      *
      *
      * PARAMETERS
      *      cond
      *              pointer to an instance of pthread_cond_t
      *
      *
      * DESCRIPTION
      *      This function destroys a condition variable.
      *
      *      NOTES:
      *              1)      A condition variable can be destroyed
      *                      immediately after all the threads that
      *                      are blocked on it are awakened. e.g.
      *
      *                      struct list {
      *                        pthread_mutex_t lm;
      *                        ...
      *                      }
      *
      *                      struct elt {
      *                        key k;
      *                        int busy;
      *                        pthread_cond_t notbusy;
      *                        ...
      *                      }
      *
      *                      
      *                      struct elt *
      *                      list_find(struct list *lp, key k)
      *                      {
      *                        struct elt *ep;
      *
      *                        pthread_mutex_lock(&lp->lm);
      *                        while ((ep = find_elt(l,k) != NULL) && ep->busy)
      *                          pthread_cond_wait(&ep->notbusy, &lp->lm);
      *                        if (ep != NULL)
      *                          ep->busy = 1;
      *                        pthread_mutex_unlock(&lp->lm);
      *                        return(ep);
      *                      }
      *
      *                      delete_elt(struct list *lp, struct elt *ep)
      *                      {
      *                        pthread_mutex_lock(&lp->lm);
      *                        assert(ep->busy);
      *                        ... remove ep from list ...
      *                        ep->busy = 0;
      *                    (A) pthread_cond_broadcast(&ep->notbusy);
      *                        pthread_mutex_unlock(&lp->lm);
      *                    (B) pthread_cond_destroy(&rp->notbusy);
      *                        free(ep);
      *                      }
      *
      *                      In this example, the condition variable
      *                      and its list element may be freed (line B)
      *                      immediately after all threads waiting for
      *                      it are awakened (line A), since the mutex
      *                      and the code ensure that no other thread
      *                      can touch the element to be deleted.
      *
      * RESULTS
      *              0               successfully released condition variable,
      *              EINVAL          'cond' is invalid,
      *              EBUSY           'cond' is in use,
      *
      * ------------------------------------------------------
      */
 {
  pthread_cond_t cv;
  int result = 0, result1 = 0, result2 = 0;
  /*
   * Assuming any race condition here is harmless.
   */
  if (cond == NULL || *cond == NULL)
    {
      return EINVAL;
    }
  if (*cond != PTHREAD_COND_INITIALIZER)
    {
      ptw32_mcs_local_node_t node;
      ptw32_mcs_lock_acquire(&ptw32_cond_list_lock, &node);
      cv = *cond;
      /*
       * Close the gate; this will synchronize this thread with
       * all already signaled waiters to let them retract their
       * waiter status - SEE NOTE 1 ABOVE!!!
       */
      if (ptw32_semwait (&(cv->semBlockLock)) != 0) /* Non-cancelable */
 	{
 	  result = errno;
 	}
      else
        {
          /*
           * !TRY! lock mtxUnblockLock; try will detect busy condition
           * and will not cause a deadlock with respect to concurrent
           * signal/broadcast.
           */
          if ((result = pthread_mutex_trylock (&(cv->mtxUnblockLock))) != 0)
 	    {
 	      (void) sem_post (&(cv->semBlockLock));
 	    }
 	}
      if (result != 0)
        {
          ptw32_mcs_lock_release(&node);
          return result;
        }
      /*
       * Check whether cv is still busy (still has waiters)
       */
      if (cv->nWaitersBlocked > cv->nWaitersGone)
 	{
 	  if (sem_post (&(cv->semBlockLock)) != 0)
 	    {
 	      result = errno;
 	    }
 	  result1 = pthread_mutex_unlock (&(cv->mtxUnblockLock));
 	  result2 = EBUSY;
 	}
      else
 	{
 	  /*
 	   * Now it is safe to destroy
 	   */
 	  *cond = NULL;
 	  if (sem_destroy (&(cv->semBlockLock)) != 0)
 	    {
 	      result = errno;
 	    }
 	  if (sem_destroy (&(cv->semBlockQueue)) != 0)
 	    {
 	      result1 = errno;
 	    }
 	  if ((result2 = pthread_mutex_unlock (&(cv->mtxUnblockLock))) == 0)
 	    {
 	      result2 = pthread_mutex_destroy (&(cv->mtxUnblockLock));
 	    }
 	  /* Unlink the CV from the list */
 	  if (ptw32_cond_list_head == cv)
 	    {
 	      ptw32_cond_list_head = cv->next;
 	    }
 	  else
 	    {
 	      cv->prev->next = cv->next;
 	    }
 	  if (ptw32_cond_list_tail == cv)
 	    {
 	      ptw32_cond_list_tail = cv->prev;
 	    }
 	  else
 	    {
 	      cv->next->prev = cv->prev;
 	    }
 	  (void) free (cv);
 	}
      ptw32_mcs_lock_release(&node);
    }
  else
    {
      ptw32_mcs_local_node_t node;
      /*
       * See notes in ptw32_cond_check_need_init() above also.
       */
      ptw32_mcs_lock_acquire(&ptw32_cond_test_init_lock, &node);
      /*
       * Check again.
       */
      if (*cond == PTHREAD_COND_INITIALIZER)
 	{
 	  /*
 	   * This is all we need to do to destroy a statically
 	   * initialised cond that has not yet been used (initialised).
 	   * If we get to here, another thread waiting to initialise
 	   * this cond will get an EINVAL. That's OK.
 	   */
 	  *cond = NULL;
 	}
      else
 	{
 	  /*
 	   * The cv has been initialised while we were waiting
 	   * so assume it's in use.
 	   */
 	  result = EBUSY;
 	}
      ptw32_mcs_lock_release(&node);
    }
  return ((result != 0) ? result : ((result1 != 0) ? result1 : result2));
 }
--- a/deps/uv/deps/pthread-win32/pthread_cond_init.c
+++ b/deps/uv/deps/pthread-win32/pthread_cond_init.c
@ -1,167 +0,0 @@
 /*
 * pthread_cond_init.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * attr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function initializes a condition variable.
      *
      * PARAMETERS
      *      cond
      *              pointer to an instance of pthread_cond_t
      *
      *      attr
      *              specifies optional creation attributes.
      *
      *
      * DESCRIPTION
      *      This function initializes a condition variable.
      *
      * RESULTS
      *              0               successfully created condition variable,
      *              EINVAL          'attr' is invalid,
      *              EAGAIN          insufficient resources (other than
      *                              memory,
      *              ENOMEM          insufficient memory,
      *              EBUSY           'cond' is already initialized,
      *
      * ------------------------------------------------------
      */
 {
  int result;
  pthread_cond_t cv = NULL;
  if (cond == NULL)
    {
      return EINVAL;
    }
  if ((attr != NULL && *attr != NULL) &&
      ((*attr)->pshared == PTHREAD_PROCESS_SHARED))
    {
      /*
       * Creating condition variable that can be shared between
       * processes.
       */
      result = ENOSYS;
      goto DONE;
    }
  cv = (pthread_cond_t) calloc (1, sizeof (*cv));
  if (cv == NULL)
    {
      result = ENOMEM;
      goto DONE;
    }
  cv->nWaitersBlocked = 0;
  cv->nWaitersToUnblock = 0;
  cv->nWaitersGone = 0;
  if (sem_init (&(cv->semBlockLock), 0, 1) != 0)
    {
      result = errno;
      goto FAIL0;
    }
  if (sem_init (&(cv->semBlockQueue), 0, 0) != 0)
    {
      result = errno;
      goto FAIL1;
    }
  if ((result = pthread_mutex_init (&(cv->mtxUnblockLock), 0)) != 0)
    {
      goto FAIL2;
    }
  result = 0;
  goto DONE;
  /*
   * -------------
   * Failed...
   * -------------
   */
 FAIL2:
  (void) sem_destroy (&(cv->semBlockQueue));
 FAIL1:
  (void) sem_destroy (&(cv->semBlockLock));
 FAIL0:
  (void) free (cv);
  cv = NULL;
 DONE:
  if (0 == result)
    {
      ptw32_mcs_local_node_t node;
      ptw32_mcs_lock_acquire(&ptw32_cond_list_lock, &node);
      cv->next = NULL;
      cv->prev = ptw32_cond_list_tail;
      if (ptw32_cond_list_tail != NULL)
 	{
 	  ptw32_cond_list_tail->next = cv;
 	}
      ptw32_cond_list_tail = cv;
      if (ptw32_cond_list_head == NULL)
 	{
 	  ptw32_cond_list_head = cv;
 	}
      ptw32_mcs_lock_release(&node);
    }
  *cond = cv;
  return result;
 }				/* pthread_cond_init */
--- a/deps/uv/deps/pthread-win32/pthread_cond_signal.c
+++ b/deps/uv/deps/pthread-win32/pthread_cond_signal.c
@ -1,231 +0,0 @@
 /*
 * pthread_cond_signal.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 *
 * -------------------------------------------------------------
 * Algorithm:
 * See the comments at the top of pthread_cond_wait.c.
 */
 #include "pthread.h"
 #include "implement.h"
 static INLINE int
 ptw32_cond_unblock (pthread_cond_t * cond, int unblockAll)
     /*
      * Notes.
      *
      * Does not use the external mutex for synchronisation,
      * therefore semBlockLock is needed.
      * mtxUnblockLock is for LEVEL-2 synch. LEVEL-2 is the
      * state where the external mutex is not necessarily locked by
      * any thread, ie. between cond_wait unlocking and re-acquiring
      * the lock after having been signaled or a timeout or
      * cancellation.
      *
      * Uses the following CV elements:
      *   nWaitersBlocked
      *   nWaitersToUnblock
      *   nWaitersGone
      *   mtxUnblockLock
      *   semBlockLock
      *   semBlockQueue
      */
 {
  int result;
  pthread_cond_t cv;
  int nSignalsToIssue;
  if (cond == NULL || *cond == NULL)
    {
      return EINVAL;
    }
  cv = *cond;
  /*
   * No-op if the CV is static and hasn't been initialised yet.
   * Assuming that any race condition is harmless.
   */
  if (cv == PTHREAD_COND_INITIALIZER)
    {
      return 0;
    }
  if ((result = pthread_mutex_lock (&(cv->mtxUnblockLock))) != 0)
    {
      return result;
    }
  if (0 != cv->nWaitersToUnblock)
    {
      if (0 == cv->nWaitersBlocked)
 	{
 	  return pthread_mutex_unlock (&(cv->mtxUnblockLock));
 	}
      if (unblockAll)
 	{
 	  cv->nWaitersToUnblock += (nSignalsToIssue = cv->nWaitersBlocked);
 	  cv->nWaitersBlocked = 0;
 	}
      else
 	{
 	  nSignalsToIssue = 1;
 	  cv->nWaitersToUnblock++;
 	  cv->nWaitersBlocked--;
 	}
    }
  else if (cv->nWaitersBlocked > cv->nWaitersGone)
    {
      /* Use the non-cancellable version of sem_wait() */
      if (ptw32_semwait (&(cv->semBlockLock)) != 0)
 	{
 	  result = errno;
 	  (void) pthread_mutex_unlock (&(cv->mtxUnblockLock));
 	  return result;
 	}
      if (0 != cv->nWaitersGone)
 	{
 	  cv->nWaitersBlocked -= cv->nWaitersGone;
 	  cv->nWaitersGone = 0;
 	}
      if (unblockAll)
 	{
 	  nSignalsToIssue = cv->nWaitersToUnblock = cv->nWaitersBlocked;
 	  cv->nWaitersBlocked = 0;
 	}
      else
 	{
 	  nSignalsToIssue = cv->nWaitersToUnblock = 1;
 	  cv->nWaitersBlocked--;
 	}
    }
  else
    {
      return pthread_mutex_unlock (&(cv->mtxUnblockLock));
    }
  if ((result = pthread_mutex_unlock (&(cv->mtxUnblockLock))) == 0)
    {
      if (sem_post_multiple (&(cv->semBlockQueue), nSignalsToIssue) != 0)
 	{
 	  result = errno;
 	}
    }
  return result;
 }				/* ptw32_cond_unblock */
 int
 pthread_cond_signal (pthread_cond_t * cond)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function signals a condition variable, waking
      *      one waiting thread.
      *      If SCHED_FIFO or SCHED_RR policy threads are waiting
      *      the highest priority waiter is awakened; otherwise,
      *      an unspecified waiter is awakened.
      *
      * PARAMETERS
      *      cond
      *              pointer to an instance of pthread_cond_t
      *
      *
      * DESCRIPTION
      *      This function signals a condition variable, waking
      *      one waiting thread.
      *      If SCHED_FIFO or SCHED_RR policy threads are waiting
      *      the highest priority waiter is awakened; otherwise,
      *      an unspecified waiter is awakened.
      *
      *      NOTES:
      *
      *      1)      Use when any waiter can respond and only one need
      *              respond (all waiters being equal).
      *
      * RESULTS
      *              0               successfully signaled condition,
      *              EINVAL          'cond' is invalid,
      *
      * ------------------------------------------------------
      */
 {
  /*
   * The '0'(FALSE) unblockAll arg means unblock ONE waiter.
   */
  return (ptw32_cond_unblock (cond, 0));
 }				/* pthread_cond_signal */
 int
 pthread_cond_broadcast (pthread_cond_t * cond)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function broadcasts the condition variable,
      *      waking all current waiters.
      *
      * PARAMETERS
      *      cond
      *              pointer to an instance of pthread_cond_t
      *
      *
      * DESCRIPTION
      *      This function signals a condition variable, waking
      *      all waiting threads.
      *
      *      NOTES:
      *
      *      1)      Use when more than one waiter may respond to
      *              predicate change or if any waiting thread may
      *              not be able to respond
      *
      * RESULTS
      *              0               successfully signalled condition to all
      *                              waiting threads,
      *              EINVAL          'cond' is invalid
      *              ENOSPC          a required resource has been exhausted,
      *
      * ------------------------------------------------------
      */
 {
  /*
   * The TRUE unblockAll arg means unblock ALL waiters.
   */
  return (ptw32_cond_unblock (cond, PTW32_TRUE));
 }				/* pthread_cond_broadcast */
--- a/deps/uv/deps/pthread-win32/pthread_cond_wait.c
+++ b/deps/uv/deps/pthread-win32/pthread_cond_wait.c
@ -1,567 +0,0 @@
 /*
 * pthread_cond_wait.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 *
 * -------------------------------------------------------------
 * Algorithm:
 * The algorithm used in this implementation is that developed by
 * Alexander Terekhov in colaboration with Louis Thomas. The bulk
 * of the discussion is recorded in the file README.CV, which contains
 * several generations of both colaborators original algorithms. The final
 * algorithm used here is the one referred to as
 *
 *     Algorithm 8a / IMPL_SEM,UNBLOCK_STRATEGY == UNBLOCK_ALL
 * 
 * presented below in pseudo-code as it appeared:
 *
 *
 * given:
 * semBlockLock - bin.semaphore
 * semBlockQueue - semaphore
 * mtxExternal - mutex or CS
 * mtxUnblockLock - mutex or CS
 * nWaitersGone - int
 * nWaitersBlocked - int
 * nWaitersToUnblock - int
 * 
 * wait( timeout ) {
 * 
 *   [auto: register int result          ]     // error checking omitted
 *   [auto: register int nSignalsWasLeft ]
 *   [auto: register int nWaitersWasGone ]
 * 
 *   sem_wait( semBlockLock );
 *   nWaitersBlocked++;
 *   sem_post( semBlockLock );
 * 
 *   unlock( mtxExternal );
 *   bTimedOut = sem_wait( semBlockQueue,timeout );
 * 
 *   lock( mtxUnblockLock );
 *   if ( 0 != (nSignalsWasLeft = nWaitersToUnblock) ) {
 *     if ( bTimeout ) {                       // timeout (or canceled)
 *       if ( 0 != nWaitersBlocked ) {
 *         nWaitersBlocked--;
 *       }
 *       else {
 *         nWaitersGone++;                     // count spurious wakeups.
 *       }
 *     }
 *     if ( 0 == --nWaitersToUnblock ) {
 *       if ( 0 != nWaitersBlocked ) {
 *         sem_post( semBlockLock );           // open the gate.
 *         nSignalsWasLeft = 0;                // do not open the gate
 *                                             // below again.
 *       }
 *       else if ( 0 != (nWaitersWasGone = nWaitersGone) ) {
 *         nWaitersGone = 0;
 *       }
 *     }
 *   }
 *   else if ( INT_MAX/2 == ++nWaitersGone ) { // timeout/canceled or
 *                                             // spurious semaphore :-)
 *     sem_wait( semBlockLock );
 *     nWaitersBlocked -= nWaitersGone;     // something is going on here
 *                                          //  - test of timeouts? :-)
 *     sem_post( semBlockLock );
 *     nWaitersGone = 0;
 *   }
 *   unlock( mtxUnblockLock );
 * 
 *   if ( 1 == nSignalsWasLeft ) {
 *     if ( 0 != nWaitersWasGone ) {
 *       // sem_adjust( semBlockQueue,-nWaitersWasGone );
 *       while ( nWaitersWasGone-- ) {
 *         sem_wait( semBlockQueue );       // better now than spurious later
 *       }
 *     } sem_post( semBlockLock );          // open the gate
 *   }
 * 
 *   lock( mtxExternal );
 * 
 *   return ( bTimedOut ) ? ETIMEOUT : 0;
 * }
 * 
 * signal(bAll) {
 * 
 *   [auto: register int result         ]
 *   [auto: register int nSignalsToIssue]
 * 
 *   lock( mtxUnblockLock );
 * 
 *   if ( 0 != nWaitersToUnblock ) {        // the gate is closed!!!
 *     if ( 0 == nWaitersBlocked ) {        // NO-OP
 *       return unlock( mtxUnblockLock );
 *     }
 *     if (bAll) {
 *       nWaitersToUnblock += nSignalsToIssue=nWaitersBlocked;
 *       nWaitersBlocked = 0;
 *     }
 *     else {
 *       nSignalsToIssue = 1;
 *       nWaitersToUnblock++;
 *       nWaitersBlocked--;
 *     }
 *   }
 *   else if ( nWaitersBlocked > nWaitersGone ) { // HARMLESS RACE CONDITION!
 *     sem_wait( semBlockLock );                  // close the gate
 *     if ( 0 != nWaitersGone ) {
 *       nWaitersBlocked -= nWaitersGone;
 *       nWaitersGone = 0;
 *     }
 *     if (bAll) {
 *       nSignalsToIssue = nWaitersToUnblock = nWaitersBlocked;
 *       nWaitersBlocked = 0;
 *     }
 *     else {
 *       nSignalsToIssue = nWaitersToUnblock = 1;
 *       nWaitersBlocked--;
 *     }
 *   }
 *   else { // NO-OP
 *     return unlock( mtxUnblockLock );
 *   }
 * 
 *   unlock( mtxUnblockLock );
 *   sem_post( semBlockQueue,nSignalsToIssue );
 *   return result;
 * }
 * -------------------------------------------------------------
 *
 *     Algorithm 9 / IMPL_SEM,UNBLOCK_STRATEGY == UNBLOCK_ALL
 * 
 * presented below in pseudo-code; basically 8a...
 *                                      ...BUT W/O "spurious wakes" prevention:
 *
 *
 * given:
 * semBlockLock - bin.semaphore
 * semBlockQueue - semaphore
 * mtxExternal - mutex or CS
 * mtxUnblockLock - mutex or CS
 * nWaitersGone - int
 * nWaitersBlocked - int
 * nWaitersToUnblock - int
 * 
 * wait( timeout ) {
 * 
 *   [auto: register int result          ]     // error checking omitted
 *   [auto: register int nSignalsWasLeft ]
 * 
 *   sem_wait( semBlockLock );
 *   ++nWaitersBlocked;
 *   sem_post( semBlockLock );
 * 
 *   unlock( mtxExternal );
 *   bTimedOut = sem_wait( semBlockQueue,timeout );
 * 
 *   lock( mtxUnblockLock );
 *   if ( 0 != (nSignalsWasLeft = nWaitersToUnblock) ) {
 *     --nWaitersToUnblock;
 *   }
 *   else if ( INT_MAX/2 == ++nWaitersGone ) { // timeout/canceled or
 *                                             // spurious semaphore :-)
 *     sem_wait( semBlockLock );
 *     nWaitersBlocked -= nWaitersGone;        // something is going on here
 *                                             //  - test of timeouts? :-)
 *     sem_post( semBlockLock );
 *     nWaitersGone = 0;
 *   }
 *   unlock( mtxUnblockLock );
 * 
 *   if ( 1 == nSignalsWasLeft ) {
 *     sem_post( semBlockLock );               // open the gate
 *   }
 * 
 *   lock( mtxExternal );
 * 
 *   return ( bTimedOut ) ? ETIMEOUT : 0;
 * }
 * 
 * signal(bAll) {
 * 
 *   [auto: register int result         ]
 *   [auto: register int nSignalsToIssue]
 * 
 *   lock( mtxUnblockLock );
 * 
 *   if ( 0 != nWaitersToUnblock ) {        // the gate is closed!!!
 *     if ( 0 == nWaitersBlocked ) {        // NO-OP
 *       return unlock( mtxUnblockLock );
 *     }
 *     if (bAll) {
 *       nWaitersToUnblock += nSignalsToIssue=nWaitersBlocked;
 *       nWaitersBlocked = 0;
 *     }
 *     else {
 *       nSignalsToIssue = 1;
 *       ++nWaitersToUnblock;
 *       --nWaitersBlocked;
 *     }
 *   }
 *   else if ( nWaitersBlocked > nWaitersGone ) { // HARMLESS RACE CONDITION!
 *     sem_wait( semBlockLock );                  // close the gate
 *     if ( 0 != nWaitersGone ) {
 *       nWaitersBlocked -= nWaitersGone;
 *       nWaitersGone = 0;
 *     }
 *     if (bAll) {
 *       nSignalsToIssue = nWaitersToUnblock = nWaitersBlocked;
 *       nWaitersBlocked = 0;
 *     }
 *     else {
 *       nSignalsToIssue = nWaitersToUnblock = 1;
 *       --nWaitersBlocked;
 *     }
 *   }
 *   else { // NO-OP
 *     return unlock( mtxUnblockLock );
 *   }
 *
 *   unlock( mtxUnblockLock );
 *   sem_post( semBlockQueue,nSignalsToIssue );
 *   return result;
 * }
 * -------------------------------------------------------------
 *
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 * Arguments for cond_wait_cleanup, since we can only pass a
 * single void * to it.
 */
 typedef struct
 {
  pthread_mutex_t *mutexPtr;
  pthread_cond_t cv;
  int *resultPtr;
 } ptw32_cond_wait_cleanup_args_t;
 static void PTW32_CDECL
 ptw32_cond_wait_cleanup (void *args)
 {
  ptw32_cond_wait_cleanup_args_t *cleanup_args =
    (ptw32_cond_wait_cleanup_args_t *) args;
  pthread_cond_t cv = cleanup_args->cv;
  int *resultPtr = cleanup_args->resultPtr;
  int nSignalsWasLeft;
  int result;
  /*
   * Whether we got here as a result of signal/broadcast or because of
   * timeout on wait or thread cancellation we indicate that we are no
   * longer waiting. The waiter is responsible for adjusting waiters
   * (to)unblock(ed) counts (protected by unblock lock).
   */
  if ((result = pthread_mutex_lock (&(cv->mtxUnblockLock))) != 0)
    {
      *resultPtr = result;
      return;
    }
  if (0 != (nSignalsWasLeft = cv->nWaitersToUnblock))
    {
      --(cv->nWaitersToUnblock);
    }
  else if (INT_MAX / 2 == ++(cv->nWaitersGone))
    {
      /* Use the non-cancellable version of sem_wait() */
      if (ptw32_semwait (&(cv->semBlockLock)) != 0)
 	{
 	  *resultPtr = errno;
 	  /*
 	   * This is a fatal error for this CV,
 	   * so we deliberately don't unlock
 	   * cv->mtxUnblockLock before returning.
 	   */
 	  return;
 	}
      cv->nWaitersBlocked -= cv->nWaitersGone;
      if (sem_post (&(cv->semBlockLock)) != 0)
 	{
 	  *resultPtr = errno;
 	  /*
 	   * This is a fatal error for this CV,
 	   * so we deliberately don't unlock
 	   * cv->mtxUnblockLock before returning.
 	   */
 	  return;
 	}
      cv->nWaitersGone = 0;
    }
  if ((result = pthread_mutex_unlock (&(cv->mtxUnblockLock))) != 0)
    {
      *resultPtr = result;
      return;
    }
  if (1 == nSignalsWasLeft)
    {
      if (sem_post (&(cv->semBlockLock)) != 0)
 	{
 	  *resultPtr = errno;
 	  return;
 	}
    }
  /*
   * XSH: Upon successful return, the mutex has been locked and is owned
   * by the calling thread.
   */
  if ((result = pthread_mutex_lock (cleanup_args->mutexPtr)) != 0)
    {
      *resultPtr = result;
    }
 }				/* ptw32_cond_wait_cleanup */
 static INLINE int
 ptw32_cond_timedwait (pthread_cond_t * cond,
 		      pthread_mutex_t * mutex, const struct timespec *abstime)
 {
  int result = 0;
  pthread_cond_t cv;
  ptw32_cond_wait_cleanup_args_t cleanup_args;
  if (cond == NULL || *cond == NULL)
    {
      return EINVAL;
    }
  /*
   * We do a quick check to see if we need to do more work
   * to initialise a static condition variable. We check
   * again inside the guarded section of ptw32_cond_check_need_init()
   * to avoid race conditions.
   */
  if (*cond == PTHREAD_COND_INITIALIZER)
    {
      result = ptw32_cond_check_need_init (cond);
    }
  if (result != 0 && result != EBUSY)
    {
      return result;
    }
  cv = *cond;
  /* Thread can be cancelled in sem_wait() but this is OK */
  if (sem_wait (&(cv->semBlockLock)) != 0)
    {
      return errno;
    }
  ++(cv->nWaitersBlocked);
  if (sem_post (&(cv->semBlockLock)) != 0)
    {
      return errno;
    }
  /*
   * Setup this waiter cleanup handler
   */
  cleanup_args.mutexPtr = mutex;
  cleanup_args.cv = cv;
  cleanup_args.resultPtr = &result;
 #if defined(_MSC_VER) && _MSC_VER < 1400
 #pragma inline_depth(0)
 #endif
  pthread_cleanup_push (ptw32_cond_wait_cleanup, (void *) &cleanup_args);
  /*
   * Now we can release 'mutex' and...
   */
  if ((result = pthread_mutex_unlock (mutex)) == 0)
    {
      /*
       * ...wait to be awakened by
       *              pthread_cond_signal, or
       *              pthread_cond_broadcast, or
       *              timeout, or
       *              thread cancellation
       *
       * Note:
       *
       *      sem_timedwait is a cancellation point,
       *      hence providing the mechanism for making
       *      pthread_cond_wait a cancellation point.
       *      We use the cleanup mechanism to ensure we
       *      re-lock the mutex and adjust (to)unblock(ed) waiters
       *      counts if we are cancelled, timed out or signalled.
       */
      if (sem_timedwait (&(cv->semBlockQueue), abstime) != 0)
 	{
 	  result = errno;
 	}
    }
  /*
   * Always cleanup
   */
  pthread_cleanup_pop (1);
 #if defined(_MSC_VER) && _MSC_VER < 1400
 #pragma inline_depth()
 #endif
  /*
   * "result" can be modified by the cleanup handler.
   */
  return result;
 }				/* ptw32_cond_timedwait */
 int
 pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function waits on a condition variable until
      *      awakened by a signal or broadcast.
      *
      *      Caller MUST be holding the mutex lock; the
      *      lock is released and the caller is blocked waiting
      *      on 'cond'. When 'cond' is signaled, the mutex
      *      is re-acquired before returning to the caller.
      *
      * PARAMETERS
      *      cond
      *              pointer to an instance of pthread_cond_t
      *
      *      mutex
      *              pointer to an instance of pthread_mutex_t
      *
      *
      * DESCRIPTION
      *      This function waits on a condition variable until
      *      awakened by a signal or broadcast.
      *
      *      NOTES:
      *
      *      1)      The function must be called with 'mutex' LOCKED
      *              by the calling thread, or undefined behaviour
      *              will result.
      *
      *      2)      This routine atomically releases 'mutex' and causes
      *              the calling thread to block on the condition variable.
      *              The blocked thread may be awakened by 
      *                      pthread_cond_signal or 
      *                      pthread_cond_broadcast.
      *
      * Upon successful completion, the 'mutex' has been locked and 
      * is owned by the calling thread.
      *
      *
      * RESULTS
      *              0               caught condition; mutex released,
      *              EINVAL          'cond' or 'mutex' is invalid,
      *              EINVAL          different mutexes for concurrent waits,
      *              EINVAL          mutex is not held by the calling thread,
      *
      * ------------------------------------------------------
      */
 {
  /*
   * The NULL abstime arg means INFINITE waiting.
   */
  return (ptw32_cond_timedwait (cond, mutex, NULL));
 }				/* pthread_cond_wait */
 int
 pthread_cond_timedwait (pthread_cond_t * cond,
 			pthread_mutex_t * mutex,
 			const struct timespec *abstime)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function waits on a condition variable either until
      *      awakened by a signal or broadcast; or until the time
      *      specified by abstime passes.
      *
      * PARAMETERS
      *      cond
      *              pointer to an instance of pthread_cond_t
      *
      *      mutex
      *              pointer to an instance of pthread_mutex_t
      *
      *      abstime
      *              pointer to an instance of (const struct timespec)
      *
      *
      * DESCRIPTION
      *      This function waits on a condition variable either until
      *      awakened by a signal or broadcast; or until the time
      *      specified by abstime passes.
      *
      *      NOTES:
      *      1)      The function must be called with 'mutex' LOCKED
      *              by the calling thread, or undefined behaviour
      *              will result.
      *
      *      2)      This routine atomically releases 'mutex' and causes
      *              the calling thread to block on the condition variable.
      *              The blocked thread may be awakened by 
      *                      pthread_cond_signal or 
      *                      pthread_cond_broadcast.
      *
      *
      * RESULTS
      *              0               caught condition; mutex released,
      *              EINVAL          'cond', 'mutex', or abstime is invalid,
      *              EINVAL          different mutexes for concurrent waits,
      *              EINVAL          mutex is not held by the calling thread,
      *              ETIMEDOUT       abstime ellapsed before cond was signaled.
      *
      * ------------------------------------------------------
      */
 {
  if (abstime == NULL)
    {
      return EINVAL;
    }
  return (ptw32_cond_timedwait (cond, mutex, abstime));
 }				/* pthread_cond_timedwait */
--- a/deps/uv/deps/pthread-win32/pthread_condattr_destroy.c
+++ b/deps/uv/deps/pthread-win32/pthread_condattr_destroy.c
@ -1,86 +0,0 @@
 /*
 * condvar_attr_destroy.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_condattr_destroy (pthread_condattr_t * attr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Destroys a condition variable attributes object.
      *      The object can no longer be used.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_condattr_t
      *
      *
      * DESCRIPTION
      *      Destroys a condition variable attributes object.
      *      The object can no longer be used.
      *
      *      NOTES:
      *      1)      Does not affect condition variables created
      *              using 'attr'
      *
      * RESULTS
      *              0               successfully released attr,
      *              EINVAL          'attr' is invalid.
      *
      * ------------------------------------------------------
      */
 {
  int result = 0;
  if (attr == NULL || *attr == NULL)
    {
      result = EINVAL;
    }
  else
    {
      (void) free (*attr);
      *attr = NULL;
      result = 0;
    }
  return result;
 }				/* pthread_condattr_destroy */
--- a/deps/uv/deps/pthread-win32/pthread_condattr_getpshared.c
+++ b/deps/uv/deps/pthread-win32/pthread_condattr_getpshared.c
@ -1,97 +0,0 @@
 /*
 * pthread_condattr_getpshared.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_condattr_getpshared (const pthread_condattr_t * attr, int *pshared)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Determine whether condition variables created with 'attr'
      *      can be shared between processes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_condattr_t
      *
      *      pshared
      *              will be set to one of:
      *
      *                      PTHREAD_PROCESS_SHARED
      *                              May be shared if in shared memory
      *
      *                      PTHREAD_PROCESS_PRIVATE
      *                              Cannot be shared.
      *
      *
      * DESCRIPTION
      *      Condition Variables created with 'attr' can be shared
      *      between processes if pthread_cond_t variable is allocated
      *      in memory shared by these processes.
      *      NOTES:
      *      1)      pshared condition variables MUST be allocated in
      *              shared memory.
      *
      *      2)      The following macro is defined if shared mutexes
      *              are supported:
      *                      _POSIX_THREAD_PROCESS_SHARED
      *
      * RESULTS
      *              0               successfully retrieved attribute,
      *              EINVAL          'attr' or 'pshared' is invalid,
      *
      * ------------------------------------------------------
      */
 {
  int result;
  if ((attr != NULL && *attr != NULL) && (pshared != NULL))
    {
      *pshared = (*attr)->pshared;
      result = 0;
    }
  else
    {
      result = EINVAL;
    }
  return result;
 }				/* pthread_condattr_getpshared */
--- a/deps/uv/deps/pthread-win32/pthread_condattr_init.c
+++ b/deps/uv/deps/pthread-win32/pthread_condattr_init.c
@ -1,87 +0,0 @@
 /*
 * pthread_condattr_init.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_condattr_init (pthread_condattr_t * attr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Initializes a condition variable attributes object
      *      with default attributes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_condattr_t
      *
      *
      * DESCRIPTION
      *      Initializes a condition variable attributes object
      *      with default attributes.
      *
      *      NOTES:
      *              1)      Use to define condition variable types
      *              2)      It is up to the application to ensure
      *                      that it doesn't re-init an attribute
      *                      without destroying it first. Otherwise
      *                      a memory leak is created.
      *
      * RESULTS
      *              0               successfully initialized attr,
      *              ENOMEM          insufficient memory for attr.
      *
      * ------------------------------------------------------
      */
 {
  pthread_condattr_t attr_result;
  int result = 0;
  attr_result = (pthread_condattr_t) calloc (1, sizeof (*attr_result));
  if (attr_result == NULL)
    {
      result = ENOMEM;
    }
  *attr = attr_result;
  return result;
 }				/* pthread_condattr_init */
--- a/deps/uv/deps/pthread-win32/pthread_condattr_setpshared.c
+++ b/deps/uv/deps/pthread-win32/pthread_condattr_setpshared.c
@ -1,117 +0,0 @@
 /*
 * pthread_condattr_setpshared.c
 *
 * Description:
 * This translation unit implements condition variables and their primitives.
 *
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      Mutexes created with 'attr' can be shared between
      *      processes if pthread_mutex_t variable is allocated
      *      in memory shared by these processes.
      *
      * PARAMETERS
      *      attr
      *              pointer to an instance of pthread_mutexattr_t
      *
      *      pshared
      *              must be one of:
      *
      *                      PTHREAD_PROCESS_SHARED
      *                              May be shared if in shared memory
      *
      *                      PTHREAD_PROCESS_PRIVATE
      *                              Cannot be shared.
      *
      * DESCRIPTION
      *      Mutexes creatd with 'attr' can be shared between
      *      processes if pthread_mutex_t variable is allocated
      *      in memory shared by these processes.
      *
      *      NOTES:
      *              1)      pshared mutexes MUST be allocated in shared
      *                      memory.
      *
      *              2)      The following macro is defined if shared mutexes
      *                      are supported:
      *                              _POSIX_THREAD_PROCESS_SHARED
      *
      * RESULTS
      *              0               successfully set attribute,
      *              EINVAL          'attr' or pshared is invalid,
      *              ENOSYS          PTHREAD_PROCESS_SHARED not supported,
      *
      * ------------------------------------------------------
      */
 {
  int result;
  if ((attr != NULL && *attr != NULL)
      && ((pshared == PTHREAD_PROCESS_SHARED)
 	  || (pshared == PTHREAD_PROCESS_PRIVATE)))
    {
      if (pshared == PTHREAD_PROCESS_SHARED)
 	{
 #if !defined( _POSIX_THREAD_PROCESS_SHARED )
 	  result = ENOSYS;
 	  pshared = PTHREAD_PROCESS_PRIVATE;
 #else
 	  result = 0;
 #endif /* _POSIX_THREAD_PROCESS_SHARED */
 	}
      else
 	{
 	  result = 0;
 	}
      (*attr)->pshared = pshared;
    }
  else
    {
      result = EINVAL;
    }
  return result;
 }				/* pthread_condattr_setpshared */
--- a/deps/uv/deps/pthread-win32/pthread_delay_np.c
+++ b/deps/uv/deps/pthread-win32/pthread_delay_np.c
@ -1,172 +0,0 @@
 /*
 * pthreads_delay_np.c
 *
 * Description:
 * This translation unit implements non-portable thread functions.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 * pthread_delay_np
 *
 * DESCRIPTION
 *
 *       This routine causes a thread to delay execution for a specific period of time.
 *       This period ends at the current time plus the specified interval. The routine
 *       will not return before the end of the period is reached, but may return an
 *       arbitrary amount of time after the period has gone by. This can be due to
 *       system load, thread priorities, and system timer granularity. 
 *
 *       Specifying an interval of zero (0) seconds and zero (0) nanoseconds is
 *       allowed and can be used to force the thread to give up the processor or to
 *       deliver a pending cancelation request. 
 *
 *       The timespec structure contains the following two fields: 
 *
 *            tv_sec is an integer number of seconds. 
 *            tv_nsec is an integer number of nanoseconds. 
 *
 *  Return Values
 *
 *  If an error condition occurs, this routine returns an integer value indicating
 *  the type of error. Possible return values are as follows: 
 *
 *  0 
 *           Successful completion.
 *  [EINVAL] 
 *           The value specified by interval is invalid. 
 *
 * Example
 *
 * The following code segment would wait for 5 and 1/2 seconds
 *
 *  struct timespec tsWait;
 *  int      intRC;
 *
 *  tsWait.tv_sec  = 5;
 *  tsWait.tv_nsec = 500000000L;
 *  intRC = pthread_delay_np(&tsWait);
 */
 int
 pthread_delay_np (struct timespec *interval)
 {
  DWORD wait_time;
  DWORD secs_in_millisecs;
  DWORD millisecs;
  DWORD status;
  pthread_t self;
  ptw32_thread_t * sp;
  if (interval == NULL)
    {
      return EINVAL;
    }
  if (interval->tv_sec == 0L && interval->tv_nsec == 0L)
    {
      pthread_testcancel ();
      Sleep (0);
      pthread_testcancel ();
      return (0);
    }
  /* convert secs to millisecs */
  secs_in_millisecs = (DWORD)interval->tv_sec * 1000L;
  /* convert nanosecs to millisecs (rounding up) */
  millisecs = (interval->tv_nsec + 999999L) / 1000000L;
 #if defined(__WATCOMC__)
 #pragma disable_message (124)
 #endif
  /*
   * Most compilers will issue a warning 'comparison always 0'
   * because the variable type is unsigned, but we need to keep this
   * for some reason I can't recall now.
   */
  if (0 > (wait_time = secs_in_millisecs + millisecs))
    {
      return EINVAL;
    }
 #if defined(__WATCOMC__)
 #pragma enable_message (124)
 #endif
  if (NULL == (self = pthread_self ()).p)
    {
      return ENOMEM;
    }
  sp = (ptw32_thread_t *) self.p;
  if (sp->cancelState == PTHREAD_CANCEL_ENABLE)
    {
      /*
       * Async cancelation won't catch us until wait_time is up.
       * Deferred cancelation will cancel us immediately.
       */
      if (WAIT_OBJECT_0 ==
 	  (status = WaitForSingleObject (sp->cancelEvent, wait_time)))
 	{
          ptw32_mcs_local_node_t stateLock;
 	  /*
 	   * Canceling!
 	   */
 	  ptw32_mcs_lock_acquire (&sp->stateLock, &stateLock);
 	  if (sp->state < PThreadStateCanceling)
 	    {
 	      sp->state = PThreadStateCanceling;
 	      sp->cancelState = PTHREAD_CANCEL_DISABLE;
 	      ptw32_mcs_lock_release (&stateLock);
 	      ptw32_throw (PTW32_EPS_CANCEL);
 	    }
 	  ptw32_mcs_lock_release (&stateLock);
 	  return ESRCH;
 	}
      else if (status != WAIT_TIMEOUT)
 	{
 	  return EINVAL;
 	}
    }
  else
    {
      Sleep (wait_time);
    }
  return (0);
 }
--- a/deps/uv/deps/pthread-win32/pthread_detach.c
+++ b/deps/uv/deps/pthread-win32/pthread_detach.c
@ -1,136 +0,0 @@
 /*
 * pthread_detach.c
 *
 * Description:
 * This translation unit implements functions related to thread
 * synchronisation.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 * Not needed yet, but defining it should indicate clashes with build target
 * environment that should be fixed.
 */
 #if !defined(WINCE)
 #  include <signal.h>
 #endif
 int
 pthread_detach (pthread_t thread)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function detaches the given thread.
      *
      * PARAMETERS
      *      thread
      *              an instance of a pthread_t
      *
      *
      * DESCRIPTION
      *      This function detaches the given thread. You may use it to
      *      detach the main thread or to detach a joinable thread.
      *      NOTE:   detached threads cannot be joined;
      *              storage is freed immediately on termination.
      *
      * RESULTS
      *              0               successfully detached the thread,
      *              EINVAL          thread is not a joinable thread,
      *              ENOSPC          a required resource has been exhausted,
      *              ESRCH           no thread could be found for 'thread',
      *
      * ------------------------------------------------------
      */
 {
  int result;
  BOOL destroyIt = PTW32_FALSE;
  ptw32_thread_t * tp = (ptw32_thread_t *) thread.p;
  ptw32_mcs_local_node_t node;
  ptw32_mcs_lock_acquire(&ptw32_thread_reuse_lock, &node);
  if (NULL == tp
      || thread.x != tp->ptHandle.x)
    {
      result = ESRCH;
    }
  else if (PTHREAD_CREATE_DETACHED == tp->detachState)
    {
      result = EINVAL;
    }
  else
    {
      ptw32_mcs_local_node_t stateLock;
      /*
       * Joinable ptw32_thread_t structs are not scavenged until
       * a join or detach is done. The thread may have exited already,
       * but all of the state and locks etc are still there.
       */
      result = 0;
      ptw32_mcs_lock_acquire (&tp->stateLock, &stateLock);
      if (tp->state != PThreadStateLast)
        {
          tp->detachState = PTHREAD_CREATE_DETACHED;
        }
      else if (tp->detachState != PTHREAD_CREATE_DETACHED)
        {
          /*
           * Thread is joinable and has exited or is exiting.
           */
          destroyIt = PTW32_TRUE;
        }
      ptw32_mcs_lock_release (&stateLock);
    }
  ptw32_mcs_lock_release(&node);
  if (result == 0)
    {
      /* Thread is joinable */
      if (destroyIt)
 	{
 	  /* The thread has exited or is exiting but has not been joined or
 	   * detached. Need to wait in case it's still exiting.
 	   */
 	  (void) WaitForSingleObject(tp->threadH, INFINITE);
 	  ptw32_threadDestroy (thread);
 	}
    }
  return (result);
 }				/* pthread_detach */
--- a/deps/uv/deps/pthread-win32/pthread_equal.c
+++ b/deps/uv/deps/pthread-win32/pthread_equal.c
@ -1,76 +0,0 @@
 /*
 * pthread_equal.c
 *
 * Description:
 * This translation unit implements miscellaneous thread functions.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_equal (pthread_t t1, pthread_t t2)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function returns nonzero if t1 and t2 are equal, else
      *      returns zero
      *
      * PARAMETERS
      *      t1,
      *      t2
      *              thread IDs
      *
      *
      * DESCRIPTION
      *      This function returns nonzero if t1 and t2 are equal, else
      *      returns zero.
      *
      * RESULTS
      *              non-zero        if t1 and t2 refer to the same thread,
      *              0               t1 and t2 do not refer to the same thread
      *
      * ------------------------------------------------------
      */
 {
  int result;
  /*
   * We also accept NULL == NULL - treating NULL as a thread
   * for this special case, because there is no error that we can return.
   */
  result = ( t1.p == t2.p && t1.x == t2.x );
  return (result);
 }				/* pthread_equal */
--- a/deps/uv/deps/pthread-win32/pthread_exit.c
+++ b/deps/uv/deps/pthread-win32/pthread_exit.c
@ -1,106 +0,0 @@
 /*
 * pthread_exit.c
 *
 * Description:
 * This translation unit implements routines associated with exiting from
 * a thread.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #if !defined(_UWIN)
 /*#   include <process.h> */
 #endif
 void
 pthread_exit (void *value_ptr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function terminates the calling thread, returning
      *      the value 'value_ptr' to any joining thread.
      *
      * PARAMETERS
      *      value_ptr
      *              a generic data value (i.e. not the address of a value)
      *
      *
      * DESCRIPTION
      *      This function terminates the calling thread, returning
      *      the value 'value_ptr' to any joining thread.
      *      NOTE: thread should be joinable.
      *
      * RESULTS
      *              N/A
      *
      * ------------------------------------------------------
      */
 {
  ptw32_thread_t * sp;
  /*
   * Don't use pthread_self() to avoid creating an implicit POSIX thread handle
   * unnecessarily.
   */
  sp = (ptw32_thread_t *) pthread_getspecific (ptw32_selfThreadKey);
 #if defined(_UWIN)
  if (--pthread_count <= 0)
    exit ((int) value_ptr);
 #endif
  if (NULL == sp)
    {
      /*
       * A POSIX thread handle was never created. I.e. this is a
       * Win32 thread that has never called a pthreads-win32 routine that
       * required a POSIX handle.
       *
       * Implicit POSIX handles are cleaned up in ptw32_throw() now.
       */
 #if ! (defined (__MINGW64__) || defined(__MINGW32__)) || defined (__MSVCRT__)  || defined (__DMC__)
      _endthreadex ((unsigned) (size_t) value_ptr);
 #else
      _endthread ();
 #endif
      /* Never reached */
    }
  sp->exitStatus = value_ptr;
  ptw32_throw (PTW32_EPS_EXIT);
  /* Never reached. */
 }
--- a/deps/uv/deps/pthread-win32/pthread_getconcurrency.c
+++ b/deps/uv/deps/pthread-win32/pthread_getconcurrency.c
@ -1,45 +0,0 @@
 /*
 * pthread_getconcurrency.c
 *
 * Description:
 * This translation unit implements miscellaneous thread functions.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_getconcurrency (void)
 {
  return ptw32_concurrency;
 }
--- a/deps/uv/deps/pthread-win32/pthread_getschedparam.c
+++ b/deps/uv/deps/pthread-win32/pthread_getschedparam.c
@ -1,75 +0,0 @@
 /*
 * sched_getschedparam.c
 * 
 * Description:
 * POSIX thread functions that deal with thread scheduling.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 #include "sched.h"
 int
 pthread_getschedparam (pthread_t thread, int *policy,
 		       struct sched_param *param)
 {
  int result;
  /* Validate the thread id. */
  result = pthread_kill (thread, 0);
  if (0 != result)
    {
      return result;
    }
  /*
   * Validate the policy and param args.
   * Check that a policy constant wasn't passed rather than &policy.
   */
  if (policy <= (int *) SCHED_MAX || param == NULL)
    {
      return EINVAL;
    }
  /* Fill out the policy. */
  *policy = SCHED_OTHER;
  /*
   * This function must return the priority value set by
   * the most recent pthread_setschedparam() or pthread_create()
   * for the target thread. It must not return the actual thread
   * priority as altered by any system priority adjustments etc.
   */
  param->sched_priority = ((ptw32_thread_t *)thread.p)->sched_priority;
  return 0;
 }
--- a/deps/uv/deps/pthread-win32/pthread_getspecific.c
+++ b/deps/uv/deps/pthread-win32/pthread_getspecific.c
@ -1,87 +0,0 @@
 /*
 * pthread_getspecific.c
 *
 * Description:
 * POSIX thread functions which implement thread-specific data (TSD).
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 void *
 pthread_getspecific (pthread_key_t key)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function returns the current value of key in the
      *      calling thread. If no value has been set for 'key' in 
      *      the thread, NULL is returned.
      *
      * PARAMETERS
      *      key
      *              an instance of pthread_key_t
      *
      *
      * DESCRIPTION
      *      This function returns the current value of key in the
      *      calling thread. If no value has been set for 'key' in 
      *      the thread, NULL is returned.
      *
      * RESULTS
      *              key value or NULL on failure
      *
      * ------------------------------------------------------
      */
 {
  void * ptr;
  if (key == NULL)
    {
      ptr = NULL;
    }
  else
    {
      int lasterror = GetLastError ();
 #if defined(RETAIN_WSALASTERROR)
      int lastWSAerror = WSAGetLastError ();
 #endif
      ptr = TlsGetValue (key->key);
      SetLastError (lasterror);
 #if defined(RETAIN_WSALASTERROR)
      WSASetLastError (lastWSAerror);
 #endif
    }
  return ptr;
 }
--- a/deps/uv/deps/pthread-win32/pthread_getunique_np.c
+++ b/deps/uv/deps/pthread-win32/pthread_getunique_np.c
@ -1,47 +0,0 @@
 /*
 * pthread_getunique_np.c
 *
 * Description:
 * This translation unit implements non-portable thread functions.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 *
 */
 unsigned __int64
 pthread_getunique_np (pthread_t thread)
 {
  return ((ptw32_thread_t*)thread.p)->seqNumber;
 }
--- a/deps/uv/deps/pthread-win32/pthread_getw32threadhandle_np.c
+++ b/deps/uv/deps/pthread-win32/pthread_getw32threadhandle_np.c
@ -1,65 +0,0 @@
 /*
 * pthread_getw32threadhandle_np.c
 *
 * Description:
 * This translation unit implements non-portable thread functions.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 * pthread_getw32threadhandle_np()
 *
 * Returns the win32 thread handle that the POSIX
 * thread "thread" is running as.
 *
 * Applications can use the win32 handle to set
 * win32 specific attributes of the thread.
 */
 HANDLE
 pthread_getw32threadhandle_np (pthread_t thread)
 {
  return ((ptw32_thread_t *)thread.p)->threadH;
 }
 /*
 * pthread_getw32threadid_np()
 *
 * Returns the win32 thread id that the POSIX
 * thread "thread" is running as.
 */
 DWORD
 pthread_getw32threadid_np (pthread_t thread)
 {
  return ((ptw32_thread_t *)thread.p)->thread;
 }
--- a/deps/uv/deps/pthread-win32/pthread_join.c
+++ b/deps/uv/deps/pthread-win32/pthread_join.c
@ -1,157 +0,0 @@
 /*
 * pthread_join.c
 *
 * Description:
 * This translation unit implements functions related to thread
 * synchronisation.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 * Not needed yet, but defining it should indicate clashes with build target
 * environment that should be fixed.
 */
 #if !defined(WINCE)
 #  include <signal.h>
 #endif
 int
 pthread_join (pthread_t thread, void **value_ptr)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function waits for 'thread' to terminate and
      *      returns the thread's exit value if 'value_ptr' is not
      *      NULL. This also detaches the thread on successful
      *      completion.
      *
      * PARAMETERS
      *      thread
      *              an instance of pthread_t
      *
      *      value_ptr
      *              pointer to an instance of pointer to void
      *
      *
      * DESCRIPTION
      *      This function waits for 'thread' to terminate and
      *      returns the thread's exit value if 'value_ptr' is not
      *      NULL. This also detaches the thread on successful
      *      completion.
      *      NOTE:   detached threads cannot be joined or canceled
      *
      * RESULTS
      *              0               'thread' has completed
      *              EINVAL          thread is not a joinable thread,
      *              ESRCH           no thread could be found with ID 'thread',
      *              ENOENT          thread couldn't find it's own valid handle,
      *              EDEADLK         attempt to join thread with self
      *
      * ------------------------------------------------------
      */
 {
  int result;
  pthread_t self;
  ptw32_thread_t * tp = (ptw32_thread_t *) thread.p;
  ptw32_mcs_local_node_t node;
  ptw32_mcs_lock_acquire(&ptw32_thread_reuse_lock, &node);
  if (NULL == tp
      || thread.x != tp->ptHandle.x)
    {
      result = ESRCH;
    }
  else if (PTHREAD_CREATE_DETACHED == tp->detachState)
    {
      result = EINVAL;
    }
  else
    {
      result = 0;
    }
  ptw32_mcs_lock_release(&node);
  if (result == 0)
    {
      /* 
       * The target thread is joinable and can't be reused before we join it.
       */
      self = pthread_self();
      if (NULL == self.p)
 	{
 	  result = ENOENT;
 	}
      else if (pthread_equal (self, thread))
 	{
 	  result = EDEADLK;
 	}
      else
 	{
 	  /*
 	   * Pthread_join is a cancelation point.
 	   * If we are canceled then our target thread must not be
 	   * detached (destroyed). This is guarranteed because
 	   * pthreadCancelableWait will not return if we
 	   * are canceled.
 	   */
 	  result = pthreadCancelableWait (tp->threadH);
 	  if (0 == result)
 	    {
 	      if (value_ptr != NULL)
 		{
 		  *value_ptr = tp->exitStatus;
 		}
 	      /*
 	       * The result of making multiple simultaneous calls to
 	       * pthread_join() or pthread_detach() specifying the same
 	       * target is undefined.
 	       */
 	      result = pthread_detach (thread);
 	    }
 	  else
 	    {
 	      result = ESRCH;
 	    }
 	}
    }
  return (result);
 }				/* pthread_join */
--- a/deps/uv/deps/pthread-win32/pthread_key_create.c
+++ b/deps/uv/deps/pthread-win32/pthread_key_create.c
@ -1,108 +0,0 @@
 /*
 * pthread_key_create.c
 *
 * Description:
 * POSIX thread functions which implement thread-specific data (TSD).
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /* TLS_OUT_OF_INDEXES not defined on WinCE */
 #if !defined(TLS_OUT_OF_INDEXES)
 #define TLS_OUT_OF_INDEXES 0xffffffff
 #endif
 int
 pthread_key_create (pthread_key_t * key, void (*destructor) (void *))
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function creates a thread-specific data key visible
      *      to all threads. All existing and new threads have a value
      *      NULL for key until set using pthread_setspecific. When any
      *      thread with a non-NULL value for key terminates, 'destructor'
      *      is called with key's current value for that thread.
      *
      * PARAMETERS
      *      key
      *              pointer to an instance of pthread_key_t
      *
      *
      * DESCRIPTION
      *      This function creates a thread-specific data key visible
      *      to all threads. All existing and new threads have a value
      *      NULL for key until set using pthread_setspecific. When any
      *      thread with a non-NULL value for key terminates, 'destructor'
      *      is called with key's current value for that thread.
      *
      * RESULTS
      *              0               successfully created semaphore,
      *              EAGAIN          insufficient resources or PTHREAD_KEYS_MAX
      *                              exceeded,
      *              ENOMEM          insufficient memory to create the key,
      *
      * ------------------------------------------------------
      */
 {
  int result = 0;
  pthread_key_t newkey;
  if ((newkey = (pthread_key_t) calloc (1, sizeof (*newkey))) == NULL)
    {
      result = ENOMEM;
    }
  else if ((newkey->key = TlsAlloc ()) == TLS_OUT_OF_INDEXES)
    {
      result = EAGAIN;
      free (newkey);
      newkey = NULL;
    }
  else if (destructor != NULL)
    {
      /*
       * Have to manage associations between thread and key;
       * Therefore, need a lock that allows competing threads
       * to gain exclusive access to the key->threads list.
       *
       * The mutex will only be created when it is first locked.
       */
      newkey->keyLock = 0;
      newkey->destructor = destructor;
    }
  *key = newkey;
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_key_delete.c
+++ b/deps/uv/deps/pthread-win32/pthread_key_delete.c
@ -1,125 +0,0 @@
 /*
 * pthread_key_delete.c
 *
 * Description:
 * POSIX thread functions which implement thread-specific data (TSD).
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_key_delete (pthread_key_t key)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function deletes a thread-specific data key. This
      *      does not change the value of the thread specific data key
      *      for any thread and does not run the key's destructor
      *      in any thread so it should be used with caution.
      *
      * PARAMETERS
      *      key
      *              pointer to an instance of pthread_key_t
      *
      *
      * DESCRIPTION
      *      This function deletes a thread-specific data key. This
      *      does not change the value of the thread specific data key
      *      for any thread and does not run the key's destructor
      *      in any thread so it should be used with caution.
      *
      * RESULTS
      *              0               successfully deleted the key,
      *              EINVAL          key is invalid,
      *
      * ------------------------------------------------------
      */
 {
  ptw32_mcs_local_node_t keyLock;
  int result = 0;
  if (key != NULL)
    {
      if (key->threads != NULL && key->destructor != NULL)
 	{
 	  ThreadKeyAssoc *assoc;
 	  ptw32_mcs_lock_acquire (&(key->keyLock), &keyLock);
 	  /*
 	   * Run through all Thread<-->Key associations
 	   * for this key.
 	   *
 	   * While we hold at least one of the locks guarding
 	   * the assoc, we know that the assoc pointed to by
 	   * key->threads is valid.
 	   */
 	  while ((assoc = (ThreadKeyAssoc *) key->threads) != NULL)
 	    {
              ptw32_mcs_local_node_t threadLock;
 	      ptw32_thread_t * thread = assoc->thread;
 	      if (assoc == NULL)
 		{
 		  /* Finished */
 		  break;
 		}
 	      ptw32_mcs_lock_acquire (&(thread->threadLock), &threadLock);
 	      /*
 	       * Since we are starting at the head of the key's threads
 	       * chain, this will also point key->threads at the next assoc.
 	       * While we hold key->keyLock, no other thread can insert
 	       * a new assoc via pthread_setspecific.
 	       */
 	      ptw32_tkAssocDestroy (assoc);
 	      ptw32_mcs_lock_release (&threadLock);
 	      ptw32_mcs_lock_release (&keyLock);
 	    }
 	}
      TlsFree (key->key);
      if (key->destructor != NULL)
 	{
 	  /* A thread could be holding the keyLock */
 	  ptw32_mcs_lock_acquire (&(key->keyLock), &keyLock);
 	  ptw32_mcs_lock_release (&keyLock);
 	}
 #if defined( _DEBUG )
      memset ((char *) key, 0, sizeof (*key));
 #endif
      free (key);
    }
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_kill.c
+++ b/deps/uv/deps/pthread-win32/pthread_kill.c
@ -1,105 +0,0 @@
 /*
 * pthread_kill.c
 *
 * Description:
 * This translation unit implements the pthread_kill routine.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 /*
 * Not needed yet, but defining it should indicate clashes with build target
 * environment that should be fixed.
 */
 #if !defined(WINCE)
 #  include <signal.h>
 #endif
 int
 pthread_kill (pthread_t thread, int sig)
     /*
      * ------------------------------------------------------
      * DOCPUBLIC
      *      This function requests that a signal be delivered to the
      *      specified thread. If sig is zero, error checking is
      *      performed but no signal is actually sent such that this
      *      function can be used to check for a valid thread ID.
      *
      * PARAMETERS
      *      thread  reference to an instances of pthread_t
      *      sig     signal. Currently only a value of 0 is supported.
      *
      *
      * DESCRIPTION
      *      This function requests that a signal be delivered to the
      *      specified thread. If sig is zero, error checking is
      *      performed but no signal is actually sent such that this
      *      function can be used to check for a valid thread ID.
      *
      * RESULTS
      *              ESRCH           the thread is not a valid thread ID,
      *              EINVAL          the value of the signal is invalid
      *                              or unsupported.
      *              0               the signal was successfully sent.
      *
      * ------------------------------------------------------
      */
 {
  int result = 0;
  ptw32_thread_t * tp;
  ptw32_mcs_local_node_t node;
  ptw32_mcs_lock_acquire(&ptw32_thread_reuse_lock, &node);
  tp = (ptw32_thread_t *) thread.p;
  if (NULL == tp
      || thread.x != tp->ptHandle.x
      || NULL == tp->threadH)
    {
      result = ESRCH;
    }
  ptw32_mcs_lock_release(&node);
  if (0 == result && 0 != sig)
    {
      /*
       * Currently does not support any signals.
       */
      result = EINVAL;
    }
  return result;
 }				/* pthread_kill */
--- a/deps/uv/deps/pthread-win32/pthread_mutex_consistent.c
+++ b/deps/uv/deps/pthread-win32/pthread_mutex_consistent.c
@ -1,187 +0,0 @@
 /*
 * pthread_mutex_consistent.c
 *
 * Description:
 * This translation unit implements mutual exclusion (mutex) primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 /*
 * From the Sun Multi-threaded Programming Guide
 *
 * robustness defines the behavior when the owner of the mutex terminates without unlocking the
 * mutex, usually because its process terminated abnormally. The value of robustness that is
 * defined in pthread.h is PTHREAD_MUTEX_ROBUST or PTHREAD_MUTEX_STALLED. The
 * default value is PTHREAD_MUTEX_STALLED .
 * ■ PTHREAD_MUTEX_STALLED
 * When the owner of the mutex terminates without unlocking the mutex, all subsequent calls
 * to pthread_mutex_lock() are blocked from progress in an unspecified manner.
 * ■ PTHREAD_MUTEX_ROBUST
 * When the owner of the mutex terminates without unlocking the mutex, the mutex is
 * unlocked. The next owner of this mutex acquires the mutex with an error return of
 * EOWNERDEAD.
 * Note – Your application must always check the return code from pthread_mutex_lock() for
 * a mutex initialized with the PTHREAD_MUTEX_ROBUST attribute.
 * ■ The new owner of this mutex should make the state protected by the mutex consistent.
 * This state might have been left inconsistent when the previous owner terminated.
 * ■ If the new owner is able to make the state consistent, call
 * pthread_mutex_consistent() for the mutex before unlocking the mutex. This
 * marks the mutex as consistent and subsequent calls to pthread_mutex_lock() and
 * pthread_mutex_unlock() will behave in the normal manner.
 * ■ If the new owner is not able to make the state consistent, do not call
 * pthread_mutex_consistent() for the mutex, but unlock the mutex.
 * All waiters are woken up and all subsequent calls to pthread_mutex_lock() fail to
 * acquire the mutex. The return code is ENOTRECOVERABLE. The mutex can be made
 * consistent by calling pthread_mutex_destroy() to uninitialize the mutex, and calling
 * pthread_mutex_int() to reinitialize the mutex.However, the state that was protected
 * by the mutex remains inconsistent and some form of application recovery is required.
 * ■ If the thread that acquires the lock with EOWNERDEAD terminates without unlocking the
 * mutex, the next owner acquires the lock with an EOWNERDEAD return code.
 */
 #if !defined(_UWIN)
 /*#   include <process.h> */
 #endif
 #include "pthread.h"
 #include "implement.h"
 int
 ptw32_robust_mutex_inherit(pthread_mutex_t * mutex)
 {
  int result;
  pthread_mutex_t mx = *mutex;
  ptw32_robust_node_t* robust = mx->robustNode;
  switch ((LONG)PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(
            (PTW32_INTERLOCKED_LONGPTR)&robust->stateInconsistent,
            (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_INCONSISTENT,
            (PTW32_INTERLOCKED_LONG)-1 /* The terminating thread sets this */))
    {
      case -1L:
          result = EOWNERDEAD;
          break;
      case (LONG)PTW32_ROBUST_NOTRECOVERABLE:
          result = ENOTRECOVERABLE;
          break;
      default:
          result = 0;
          break;
    }
  return result;
 }
 /*
 * The next two internal support functions depend on only being
 * called by the thread that owns the robust mutex. This enables
 * us to avoid additional locks.
 * Any mutex currently in the thread's robust mutex list is held
 * by the thread, again eliminating the need for locks.
 * The forward/backward links allow the thread to unlock mutexes
 * in any order, not necessarily the reverse locking order.
 * This is all possible because it is an error if a thread that
 * does not own the [robust] mutex attempts to unlock it.
 */
 void
 ptw32_robust_mutex_add(pthread_mutex_t* mutex, pthread_t self)
 {
  ptw32_robust_node_t** list;
  pthread_mutex_t mx = *mutex;
  ptw32_thread_t* tp = (ptw32_thread_t*)self.p;
  ptw32_robust_node_t* robust = mx->robustNode;
  list = &tp->robustMxList;
  mx->ownerThread = self;
  if (NULL == *list)
    {
      robust->prev = NULL;
      robust->next = NULL;
      *list = robust;
    }
  else
    {
      robust->prev = NULL;
      robust->next = *list;
      (*list)->prev = robust;
      *list = robust;
    }
 }
 void
 ptw32_robust_mutex_remove(pthread_mutex_t* mutex, ptw32_thread_t* otp)
 {
  ptw32_robust_node_t** list;
  pthread_mutex_t mx = *mutex;
  ptw32_robust_node_t* robust = mx->robustNode;
  list = &(((ptw32_thread_t*)mx->ownerThread.p)->robustMxList);
  mx->ownerThread.p = otp;
  if (robust->next != NULL)
    {
      robust->next->prev = robust->prev;
    }
  if (robust->prev != NULL)
    {
      robust->prev->next = robust->next;
    }
  if (*list == robust)
    {
      *list = robust->next;
    }
 }
 int
 pthread_mutex_consistent (pthread_mutex_t* mutex)
 {
  pthread_mutex_t mx = *mutex;
  int result = 0;
  /*
   * Let the system deal with invalid pointers.
   */
  if (mx == NULL)
    {
      return EINVAL;
    }
  if (mx->kind >= 0
        || (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_INCONSISTENT != PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(
                                                (PTW32_INTERLOCKED_LONGPTR)&mx->robustNode->stateInconsistent,
                                                (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_CONSISTENT,
                                                (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_INCONSISTENT))
    {
      result = EINVAL;
    }
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_mutex_destroy.c
+++ b/deps/uv/deps/pthread-win32/pthread_mutex_destroy.c
@ -1,148 +0,0 @@
 /*
 * pthread_mutex_destroy.c
 *
 * Description:
 * This translation unit implements mutual exclusion (mutex) primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_mutex_destroy (pthread_mutex_t * mutex)
 {
  int result = 0;
  pthread_mutex_t mx;
  /*
   * Let the system deal with invalid pointers.
   */
  /*
   * Check to see if we have something to delete.
   */
  if (*mutex < PTHREAD_ERRORCHECK_MUTEX_INITIALIZER)
    {
      mx = *mutex;
      result = pthread_mutex_trylock (&mx);
      /*
       * If trylock succeeded and the mutex is not recursively locked it
       * can be destroyed.
       */
      if (0 == result || ENOTRECOVERABLE == result)
 	{
 	  if (mx->kind != PTHREAD_MUTEX_RECURSIVE || 1 == mx->recursive_count)
 	    {
 	      /*
 	       * FIXME!!!
 	       * The mutex isn't held by another thread but we could still
 	       * be too late invalidating the mutex below since another thread
 	       * may already have entered mutex_lock and the check for a valid
 	       * *mutex != NULL.
 	       */
 	      *mutex = NULL;
 	      result = (0 == result)?pthread_mutex_unlock(&mx):0;
 	      if (0 == result)
 		{
                  if (mx->robustNode != NULL)
                    {
                      free(mx->robustNode);
                    }
 		  if (!CloseHandle (mx->event))
 		    {
 		      *mutex = mx;
 		      result = EINVAL;
 		    }
 		  else
 		    {
 		      free (mx);
 		    }
 		}
 	      else
 		{
 		  /*
 		   * Restore the mutex before we return the error.
 		   */
 		  *mutex = mx;
 		}
 	    }
 	  else			/* mx->recursive_count > 1 */
 	    {
 	      /*
 	       * The mutex must be recursive and already locked by us (this thread).
 	       */
 	      mx->recursive_count--;	/* Undo effect of pthread_mutex_trylock() above */
 	      result = EBUSY;
 	    }
 	}
    }
  else
    {
      ptw32_mcs_local_node_t node;
      /*
       * See notes in ptw32_mutex_check_need_init() above also.
       */
      ptw32_mcs_lock_acquire(&ptw32_mutex_test_init_lock, &node);
      /*
       * Check again.
       */
      if (*mutex >= PTHREAD_ERRORCHECK_MUTEX_INITIALIZER)
 	{
 	  /*
 	   * This is all we need to do to destroy a statically
 	   * initialised mutex that has not yet been used (initialised).
 	   * If we get to here, another thread
 	   * waiting to initialise this mutex will get an EINVAL.
 	   */
 	  *mutex = NULL;
 	}
      else
 	{
 	  /*
 	   * The mutex has been initialised while we were waiting
 	   * so assume it's in use.
 	   */
 	  result = EBUSY;
 	}
      ptw32_mcs_lock_release(&node);
    }
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_mutex_init.c
+++ b/deps/uv/deps/pthread-win32/pthread_mutex_init.c
@ -1,130 +0,0 @@
 /*
 * pthread_mutex_init.c
 *
 * Description:
 * This translation unit implements mutual exclusion (mutex) primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t * attr)
 {
  int result = 0;
  pthread_mutex_t mx;
  if (mutex == NULL)
    {
      return EINVAL;
    }
  if (attr != NULL && *attr != NULL)
    {
      if ((*attr)->pshared == PTHREAD_PROCESS_SHARED)
        {
          /*
           * Creating mutex that can be shared between
           * processes.
           */
 #if _POSIX_THREAD_PROCESS_SHARED >= 0
          /*
           * Not implemented yet.
           */
 #error ERROR [__FILE__, line __LINE__]: Process shared mutexes are not supported yet.
 #else
          return ENOSYS;
 #endif /* _POSIX_THREAD_PROCESS_SHARED */
        }
    }
  mx = (pthread_mutex_t) calloc (1, sizeof (*mx));
  if (mx == NULL)
    {
      result = ENOMEM;
    }
  else
    {
      mx->lock_idx = 0;
      mx->recursive_count = 0;
      mx->robustNode = NULL;
      if (attr == NULL || *attr == NULL)
        {
          mx->kind = PTHREAD_MUTEX_DEFAULT;
        }
      else
        {
          mx->kind = (*attr)->kind;
          if ((*attr)->robustness == PTHREAD_MUTEX_ROBUST)
            {
              /*
               * Use the negative range to represent robust types.
               * Replaces a memory fetch with a register negate and incr
               * in pthread_mutex_lock etc.
               *
               * Map 0,1,..,n to -1,-2,..,(-n)-1
               */
              mx->kind = -mx->kind - 1;
              mx->robustNode = (ptw32_robust_node_t*) malloc(sizeof(ptw32_robust_node_t));
              mx->robustNode->stateInconsistent = PTW32_ROBUST_CONSISTENT;
              mx->robustNode->mx = mx;
              mx->robustNode->next = NULL;
              mx->robustNode->prev = NULL;
            }
        }
      mx->ownerThread.p = NULL;
      mx->event = CreateEvent (NULL, PTW32_FALSE,    /* manual reset = No */
                              PTW32_FALSE,           /* initial state = not signaled */
                              NULL);                 /* event name */
      if (0 == mx->event)
        {
          result = ENOSPC;
          free (mx);
          mx = NULL;
        }
    }
  *mutex = mx;
  return (result);
 }
--- a/deps/uv/deps/pthread-win32/pthread_mutex_lock.c
+++ b/deps/uv/deps/pthread-win32/pthread_mutex_lock.c
@ -1,269 +0,0 @@
 /*
 * pthread_mutex_lock.c
 *
 * Description:
 * This translation unit implements mutual exclusion (mutex) primitives.
 *
 * --------------------------------------------------------------------------
 *
 *      Pthreads-win32 - POSIX Threads Library for Win32
 *      Copyright(C) 1998 John E. Bossom
 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
 * 
 *      Contact Email: rpj@callisto.canberra.edu.au
 * 
 *      The current list of contributors is contained
 *      in the file CONTRIBUTORS included with the source
 *      code distribution. The list can also be seen at the
 *      following World Wide Web location:
 *      http://sources.redhat.com/pthreads-win32/contributors.html
 * 
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2 of the License, or (at your option) any later version.
 * 
 *      This library is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *      Lesser General Public License for more details.
 * 
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with this library in the file COPYING.LIB;
 *      if not, write to the Free Software Foundation, Inc.,
 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #if !defined(_UWIN)
 /*#   include <process.h> */
 #endif
 #include "pthread.h"
 #include "implement.h"
 int
 pthread_mutex_lock (pthread_mutex_t * mutex)
 {
  int kind;
  pthread_mutex_t mx;
  int result = 0;
  /*
   * Let the system deal with invalid pointers.
   */
  if (*mutex == NULL)
    {
      return EINVAL;
    }
  /*
   * We do a quick check to see if we need to do more work
   * to initialise a static mutex. We check
   * again inside the guarded section of ptw32_mutex_check_need_init()
   * to avoid race conditions.
   */
  if (*mutex >= PTHREAD_ERRORCHECK_MUTEX_INITIALIZER)
    {
      if ((result = ptw32_mutex_check_need_init (mutex)) != 0)
 	{
 	  return (result);
 	}
    }
  mx = *mutex;
  kind = mx->kind;
  if (kind >= 0)
    {
      /* Non-robust */
      if (PTHREAD_MUTEX_NORMAL == kind)
        {
          if ((PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_EXCHANGE_LONG(
 		       (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
 		       (PTW32_INTERLOCKED_LONG) 1) != 0)
 	    {
 	      while ((PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_EXCHANGE_LONG(
                              (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
 			      (PTW32_INTERLOCKED_LONG) -1) != 0)
 	        {
 	          if (WAIT_OBJECT_0 != WaitForSingleObject (mx->event, INFINITE))
 	            {
 	              result = EINVAL;
 		      break;
 	            }
 	        }
 	    }
        }
      else
        {
          pthread_t self = pthread_self();
          if ((PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(
                       (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
 		       (PTW32_INTERLOCKED_LONG) 1,
 		       (PTW32_INTERLOCKED_LONG) 0) == 0)
 	    {
 	      mx->recursive_count = 1;
 	      mx->ownerThread = self;
 	    }
          else
 	    {
 	      if (pthread_equal (mx->ownerThread, self))
 	        {
 	          if (kind == PTHREAD_MUTEX_RECURSIVE)
 		    {
 		      mx->recursive_count++;
 		    }
 	          else
 		    {
 		      result = EDEADLK;
 		    }
 	        }
 	      else
 	        {
 	          while ((PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_EXCHANGE_LONG(
                                  (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
 			          (PTW32_INTERLOCKED_LONG) -1) != 0)
 		    {
 	              if (WAIT_OBJECT_0 != WaitForSingleObject (mx->event, INFINITE))
 		        {
 	                  result = EINVAL;
 		          break;
 		        }
 		    }
 	          if (0 == result)
 		    {
 		      mx->recursive_count = 1;
 		      mx->ownerThread = self;
 		    }
 	        }
 	    }
        }
    }
  else
    {
      /*
       * Robust types
       * All types record the current owner thread.
       * The mutex is added to a per thread list when ownership is acquired.
       */
      ptw32_robust_state_t* statePtr = &mx->robustNode->stateInconsistent;
      if ((PTW32_INTERLOCKED_LONG)PTW32_ROBUST_NOTRECOVERABLE == PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(
                                                 (PTW32_INTERLOCKED_LONGPTR)statePtr,
                                                 (PTW32_INTERLOCKED_LONG)0))
        {
          result = ENOTRECOVERABLE;
        }
      else
        {
          pthread_t self = pthread_self();
          kind = -kind - 1; /* Convert to non-robust range */
          if (PTHREAD_MUTEX_NORMAL == kind)
            {
              if ((PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_EXCHANGE_LONG(
                           (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
                           (PTW32_INTERLOCKED_LONG) 1) != 0)
                {
                  while (0 == (result = ptw32_robust_mutex_inherit(mutex))
                           && (PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_EXCHANGE_LONG(
                                       (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
                                       (PTW32_INTERLOCKED_LONG) -1) != 0)
                    {
                      if (WAIT_OBJECT_0 != WaitForSingleObject (mx->event, INFINITE))
                        {
                          result = EINVAL;
                          break;
                        }
                      if ((PTW32_INTERLOCKED_LONG)PTW32_ROBUST_NOTRECOVERABLE ==
                                  PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(
                                    (PTW32_INTERLOCKED_LONGPTR)statePtr,
                                    (PTW32_INTERLOCKED_LONG)0))
                        {
                          /* Unblock the next thread */
                          SetEvent(mx->event);
                          result = ENOTRECOVERABLE;
                          break;
                        }
                    }
                }
              if (0 == result || EOWNERDEAD == result)
                {
                  /*
                   * Add mutex to the per-thread robust mutex currently-held list.
                   * If the thread terminates, all mutexes in this list will be unlocked.
                   */
                  ptw32_robust_mutex_add(mutex, self);
                }
            }
          else
            {
              if ((PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(
                           (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
                           (PTW32_INTERLOCKED_LONG) 1,
                           (PTW32_INTERLOCKED_LONG) 0) == 0)
                {
                  mx->recursive_count = 1;
                  /*
                   * Add mutex to the per-thread robust mutex currently-held list.
                   * If the thread terminates, all mutexes in this list will be unlocked.
                   */
                  ptw32_robust_mutex_add(mutex, self);
                }
              else
                {
                  if (pthread_equal (mx->ownerThread, self))
                    {
                      if (PTHREAD_MUTEX_RECURSIVE == kind)
                        {
                          mx->recursive_count++;
                        }
                      else
                        {
                          result = EDEADLK;
                        }
                    }
                  else
                    {
                      while (0 == (result = ptw32_robust_mutex_inherit(mutex))
                               && (PTW32_INTERLOCKED_LONG) PTW32_INTERLOCKED_EXCHANGE_LONG(
                                           (PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx,
                                           (PTW32_INTERLOCKED_LONG) -1) != 0)
                        {
                          if (WAIT_OBJECT_0 != WaitForSingleObject (mx->event, INFINITE))
                            {
                              result = EINVAL;
                              break;
                            }
                          if ((PTW32_INTERLOCKED_LONG)PTW32_ROBUST_NOTRECOVERABLE ==
                                      PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(
                                        (PTW32_INTERLOCKED_LONGPTR)statePtr,
                                        (PTW32_INTERLOCKED_LONG)0))
                            {
                              /* Unblock the next thread */
                              SetEvent(mx->event);
                              result = ENOTRECOVERABLE;
                              break;
                            }
                        }
                      if (0 == result || EOWNERDEAD == result)
                        {
                          mx->recursive_count = 1;
                          /*
                           * Add mutex to the per-thread robust mutex currently-held list.
                           * If the thread terminates, all mutexes in this list will be unlocked.
                           */
                          ptw32_robust_mutex_add(mutex, self);
                        }
                    }
 	        }
            }
        }
    }
  return (result);
 }