merge trunktip_463

15 files changed, 3462 insertions, 1735 deletions

diff --git a/unix/Makefile.in b/unix/Makefile.in
index c4f6136..12d4a6d 100644
--- a/unix/Makefile.in
+++ b/unix/Makefile.in
@@ -345,7 +345,7 @@ UNIX_OBJS = tclUnixChan.o tclUnixEvent.o tclUnixFCmd.o \
 	tclUnixTime.o tclUnixInit.o tclUnixThrd.o \
 	tclUnixCompat.o
 
-NOTIFY_OBJS = tclUnixNotfy.o
+NOTIFY_OBJS = tclEpollNotfy.o tclKqueueNotfy.o tclSelectNotfy.o
 
 MAC_OSX_OBJS = tclMacOSXBundle.o tclMacOSXFCmd.o tclMacOSXNotify.o
 
@@ -565,7 +565,9 @@ UNIX_SRCS = \
 	$(UNIX_DIR)/tclUnixCompat.c
 
 NOTIFY_SRCS = \
-	$(UNIX_DIR)/tclUnixNotfy.c
+	$(UNIX_DIR)/tclEpollNotfy.c \
+	$(UNIX_DIR)/tclKqueueNotfy.c \
+	$(UNIX_DIR)/tclSelectNotfy.c
 
 DL_SRCS = \
 	$(UNIX_DIR)/tclLoadAix.c \
@@ -841,8 +843,8 @@ install-libraries: libraries
 	    do \
 	    $(INSTALL_DATA) $$i "$(SCRIPT_INSTALL_DIR)"/http1.0; \
 	    done;
-	@echo "Installing package http 2.8.10 as a Tcl Module";
-	@$(INSTALL_DATA) $(TOP_DIR)/library/http/http.tcl "$(SCRIPT_INSTALL_DIR)"/../tcl8/8.6/http-2.8.10.tm;
+	@echo "Installing package http 2.8.11 as a Tcl Module";
+	@$(INSTALL_DATA) $(TOP_DIR)/library/http/http.tcl "$(SCRIPT_INSTALL_DIR)"/../tcl8/8.6/http-2.8.11.tm;
 	@echo "Installing package opt0.4 files to $(SCRIPT_INSTALL_DIR)/opt0.4/";
 	@for i in $(TOP_DIR)/library/opt/*.tcl ; \
 	    do \
@@ -1559,8 +1561,14 @@ tclUnixFCmd.o: $(UNIX_DIR)/tclUnixFCmd.c
 tclUnixFile.o: $(UNIX_DIR)/tclUnixFile.c $(FSHDR)
 	$(CC) -c $(CC_SWITCHES) $(UNIX_DIR)/tclUnixFile.c
 
-tclUnixNotfy.o: $(UNIX_DIR)/tclUnixNotfy.c
-	$(CC) -c $(CC_SWITCHES) $(UNIX_DIR)/tclUnixNotfy.c
+tclEpollNotfy.o: $(UNIX_DIR)/tclEpollNotfy.c
+	$(CC) -c $(CC_SWITCHES) $(UNIX_DIR)/tclEpollNotfy.c
+
+tclKqueueNotfy.o: $(UNIX_DIR)/tclKqueueNotfy.c
+	$(CC) -c $(CC_SWITCHES) $(UNIX_DIR)/tclKqueueNotfy.c
+
+tclSelectNotfy.o: $(UNIX_DIR)/tclSelectNotfy.c
+	$(CC) -c $(CC_SWITCHES) $(UNIX_DIR)/tclSelectNotfy.c
 
 tclUnixPipe.o: $(UNIX_DIR)/tclUnixPipe.c
 	$(CC) -c $(CC_SWITCHES) $(UNIX_DIR)/tclUnixPipe.c
diff --git a/unix/configure b/unix/configure
index 741ae47..a9132b57 100755
--- a/unix/configure
+++ b/unix/configure
@@ -4890,8 +4890,8 @@ if ${tcl_cv_sys_version+:} false; then :
   $as_echo_n "(cached) " >&6
 else
 
-	if test -f /usr/lib/NextStep/software_version; then
-	    tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
+	if test "${TEA_PLATFORM}" = "windows" ; then
+	    tcl_cv_sys_version=windows
 	else
 	    tcl_cv_sys_version=`uname -s`-`uname -r`
 	    if test "$?" -ne 0 ; then
@@ -4899,12 +4899,6 @@ else
 $as_echo "$as_me: WARNING: can't find uname command" >&2;}
 		tcl_cv_sys_version=unknown
 	    else
-		# Special check for weird MP-RAS system (uname returns weird
-		# results, and the version is kept in special file).
-
-		if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then
-		    tcl_cv_sys_version=MP-RAS-`awk '{print $3}' /etc/.relid`
-		fi
 		if test "`uname -s`" = "AIX" ; then
 		    tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
 		fi
@@ -5090,7 +5084,7 @@ fi
     PLAT_OBJS=""
     PLAT_SRCS=""
     LDAIX_SRC=""
-    if test x"${SHLIB_VERSION}" = x; then :
+    if test "x${SHLIB_VERSION}" = x; then :
   SHLIB_VERSION="1.0"
 fi
     case $system in
@@ -5302,9 +5296,9 @@ $as_echo "$ac_cv_cygwin" >&6; }
 	    fi
 	    do64bit_ok=yes
 	    if test "x${SHARED_BUILD}" = "x1"; then
-		echo "running cd ${TCL_SRC_DIR}/win; ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args"
+		echo "running cd ../win; ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args"
 		# The eval makes quoting arguments work.
-		if cd ${TCL_SRC_DIR}/win; eval ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args; cd ../unix
+		if cd ../win; eval ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args; cd ../unix
 		then :
 		else
 		    { echo "configure: error: configure failed for ../win" 1>&2; exit 1; }
@@ -5724,70 +5718,28 @@ fi
 		LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 fi
 	    ;;
-	MP-RAS-02*)
-	    SHLIB_CFLAGS="-K PIC"
-	    SHLIB_LD='${CC} -G'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
-	MP-RAS-*)
-	    SHLIB_CFLAGS="-K PIC"
-	    SHLIB_LD='${CC} -G'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    LDFLAGS="$LDFLAGS -Wl,-Bexport"
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
 	OpenBSD-*)
 	    arch=`arch -s`
 	    case "$arch" in
-	    vax)
-		# Equivalent using configure option --disable-load
-		# Step 4 will set the necessary variables
-		DL_OBJS=""
-		SHLIB_LD_LIBS=""
-		LDFLAGS=""
+	    alpha|sparc64)
+		SHLIB_CFLAGS="-fPIC"
 		;;
 	    *)
-		case "$arch" in
-		alpha|sparc|sparc64)
-		    SHLIB_CFLAGS="-fPIC"
-		    ;;
-		*)
-		    SHLIB_CFLAGS="-fpic"
-		    ;;
-		esac
-		SHLIB_LD='${CC} -shared ${SHLIB_CFLAGS}'
-		SHLIB_SUFFIX=".so"
-		DL_OBJS="tclLoadDl.o"
-		DL_LIBS=""
-		if test $doRpath = yes; then :
-
-		    CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
-fi
-		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-		SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.${SHLIB_VERSION}'
-		LDFLAGS="-Wl,-export-dynamic"
-		;;
-	    esac
-	    case "$arch" in
-	    vax)
-		CFLAGS_OPTIMIZE="-O1"
-		;;
-	    sh)
-		CFLAGS_OPTIMIZE="-O0"
-		;;
-	    *)
-		CFLAGS_OPTIMIZE="-O2"
+		SHLIB_CFLAGS="-fpic"
 		;;
 	    esac
+	    SHLIB_LD='${CC} -shared ${SHLIB_CFLAGS}'
+	    SHLIB_SUFFIX=".so"
+	    DL_OBJS="tclLoadDl.o"
+	    DL_LIBS=""
+	    if test $doRpath = yes; then :
+
+		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
+fi
+	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+	    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.${SHLIB_VERSION}'
+	    LDFLAGS="-Wl,-export-dynamic"
+	    CFLAGS_OPTIMIZE="-O2"
 	    if test "${TCL_THREADS}" = "1"; then :
 
 		# On OpenBSD:	Compile with -pthread
@@ -6170,16 +6122,6 @@ fi
 
 fi
 	    ;;
-	NEXTSTEP-*)
-	    SHLIB_CFLAGS=""
-	    SHLIB_LD='${CC} -nostdlib -r'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadNext.o"
-	    DL_LIBS=""
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
 	OS/390-*)
 	    SHLIB_LD_LIBS=""
 	    CFLAGS_OPTIMIZE=""		# Optimizer is buggy
@@ -6187,35 +6129,6 @@ fi
 $as_echo "#define _OE_SOCKETS 1" >>confdefs.h
 
 	    ;;
-	OSF1-1.0|OSF1-1.1|OSF1-1.2)
-	    # OSF/1 1.[012] from OSF, and derivatives, including Paragon OSF/1
-	    SHLIB_CFLAGS=""
-	    # Hack: make package name same as library name
-	    SHLIB_LD='ld -R -export :'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadOSF.o"
-	    DL_LIBS=""
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
-	OSF1-1.*)
-	    # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2
-	    SHLIB_CFLAGS="-fPIC"
-	    if test "$SHARED_BUILD" = 1; then :
-  SHLIB_LD="ld -shared"
-else
-
-	        SHLIB_LD="ld -non_shared"
-
-fi
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS=""
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
 	OSF1-V*)
 	    # Digital OSF/1
 	    SHLIB_CFLAGS=""
@@ -6297,35 +6210,6 @@ fi
 	    CC_SEARCH_FLAGS=""
 	    LD_SEARCH_FLAGS=""
 	    ;;
-	SINIX*5.4*)
-	    SHLIB_CFLAGS="-K PIC"
-	    SHLIB_LD='${CC} -G'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
-	SunOS-4*)
-	    SHLIB_CFLAGS="-PIC"
-	    SHLIB_LD="ld"
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
-	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-
-	    # SunOS can't handle version numbers with dots in them in library
-	    # specs, like -ltcl7.5, so use -ltcl75 instead.  Also, it
-	    # requires an extra version number at the end of .so file names.
-	    # So, the library has to have a name like libtcl75.so.1.0
-
-	    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.${SHLIB_VERSION}'
-	    UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
-	    TCL_LIB_VERSIONS_OK=nodots
-	    ;;
 	SunOS-5.[0-6])
 	    # Careful to not let 5.10+ fall into this case
 
@@ -8439,6 +8323,84 @@ $as_echo "#define NO_FD_SET 1" >>confdefs.h
 
 fi
 
+#------------------------------------------------------------------------
+#	Options for the notifier. Checks for epoll(7) on Linux, and
+#	kqueue(2) on {DragonFly,Free,Net,Open}BSD
+#------------------------------------------------------------------------
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for advanced notifier support" >&5
+$as_echo_n "checking for advanced notifier support... " >&6; }
+case x`uname -s` in
+  xLinux)
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: epoll(7)" >&5
+$as_echo "epoll(7)" >&6; }
+	for ac_header in sys/epoll.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "sys/epoll.h" "ac_cv_header_sys_epoll_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_epoll_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_SYS_EPOLL_H 1
+_ACEOF
+
+$as_echo "#define NOTIFIER_EPOLL 1" >>confdefs.h
+
+fi
+
+done
+
+	for ac_header in sys/eventfd.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "sys/eventfd.h" "ac_cv_header_sys_eventfd_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_eventfd_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_SYS_EVENTFD_H 1
+_ACEOF
+
+$as_echo "#define HAVE_EVENTFD 1" >>confdefs.h
+
+fi
+
+done
+;;
+  xDragonFlyBSD|xFreeBSD|xNetBSD|xOpenBSD)
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: kqueue(2)" >&5
+$as_echo "kqueue(2)" >&6; }
+	# Messy because we want to check if *all* the headers are present, and not
+	# just *any*
+	tcl_kqueue_headers=x
+	for ac_header in sys/types.h sys/event.h sys/time.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+ tcl_kqueue_headers=${tcl_kqueue_headers}y
+fi
+
+done
+
+	if test $tcl_kqueue_headers = xyyy; then :
+
+
+$as_echo "#define NOTIFIER_KQUEUE 1" >>confdefs.h
+
+fi;;
+  xDarwin)
+	# Assume that we've got CoreFoundation present (checked elsewhere because
+	# of wider impact).
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: OSX" >&5
+$as_echo "OSX" >&6; };;
+  *)
+	cat >>confdefs.h <<_ACEOF
+#define NOTIFIER_SELECT 1
+_ACEOF
+
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
+$as_echo "none" >&6; };;
+esac
+
 #------------------------------------------------------------------------------
 #       Find out all about time handling differences.
 #------------------------------------------------------------------------------
@@ -9977,8 +9939,8 @@ if ${tcl_cv_sys_version+:} false; then :
   $as_echo_n "(cached) " >&6
 else
 
-	if test -f /usr/lib/NextStep/software_version; then
-	    tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
+	if test "${TEA_PLATFORM}" = "windows" ; then
+	    tcl_cv_sys_version=windows
 	else
 	    tcl_cv_sys_version=`uname -s`-`uname -r`
 	    if test "$?" -ne 0 ; then
@@ -9986,12 +9948,6 @@ else
 $as_echo "$as_me: WARNING: can't find uname command" >&2;}
 		tcl_cv_sys_version=unknown
 	    else
-		# Special check for weird MP-RAS system (uname returns weird
-		# results, and the version is kept in special file).
-
-		if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then
-		    tcl_cv_sys_version=MP-RAS-`awk '{print $3}' /etc/.relid`
-		fi
 		if test "`uname -s`" = "AIX" ; then
 		    tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
 		fi
@@ -10013,13 +9969,6 @@ $as_echo "#define USE_FIONBIO 1" >>confdefs.h
 	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: FIONBIO" >&5
 $as_echo "FIONBIO" >&6; }
 	    ;;
-	SunOS-4*)
-
-$as_echo "#define USE_FIONBIO 1" >>confdefs.h
-
-	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: FIONBIO" >&5
-$as_echo "FIONBIO" >&6; }
-	    ;;
 	*)
 	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: O_NONBLOCK" >&5
 $as_echo "O_NONBLOCK" >&6; }
diff --git a/unix/configure.ac b/unix/configure.ac
index bafb970..b43da6d 100644
--- a/unix/configure.ac
+++ b/unix/configure.ac
@@ -300,6 +300,37 @@ if test $tcl_ok = no; then
     AC_DEFINE(NO_FD_SET, 1, [Do we have fd_set?])
 fi
 
+#------------------------------------------------------------------------
+#	Options for the notifier. Checks for epoll(7) on Linux, and
+#	kqueue(2) on {DragonFly,Free,Net,Open}BSD
+#------------------------------------------------------------------------
+
+AC_MSG_CHECKING([for advanced notifier support])
+case x`uname -s` in
+  xLinux)
+	AC_MSG_RESULT([epoll(7)])
+	AC_CHECK_HEADERS([sys/epoll.h],
+	    [AC_DEFINE(NOTIFIER_EPOLL, [1], [Is epoll(7) supported?])])
+	AC_CHECK_HEADERS([sys/eventfd.h],
+	    [AC_DEFINE(HAVE_EVENTFD, [1], [Is eventfd(2) supported?])]);;
+  xDragonFlyBSD|xFreeBSD|xNetBSD|xOpenBSD)
+	AC_MSG_RESULT([kqueue(2)])
+	# Messy because we want to check if *all* the headers are present, and not
+	# just *any*
+	tcl_kqueue_headers=x
+	AC_CHECK_HEADERS([sys/types.h sys/event.h sys/time.h],
+	    [tcl_kqueue_headers=${tcl_kqueue_headers}y])
+	AS_IF([test $tcl_kqueue_headers = xyyy], [
+	    AC_DEFINE(NOTIFIER_KQUEUE, [1], [Is kqueue(2) supported?])]);;
+  xDarwin)
+	# Assume that we've got CoreFoundation present (checked elsewhere because
+	# of wider impact).
+	AC_MSG_RESULT([OSX]);;
+  *)
+	AC_DEFINE_UNQUOTED(NOTIFIER_SELECT)
+	AC_MSG_RESULT([none]);;
+esac
+
 #------------------------------------------------------------------------------
 #       Find out all about time handling differences.
 #------------------------------------------------------------------------------
diff --git a/unix/tcl.m4 b/unix/tcl.m4
index c1d7a7d..45922e0 100644
--- a/unix/tcl.m4
+++ b/unix/tcl.m4
@@ -91,8 +91,9 @@ AC_DEFUN([SC_PATH_TCLCONFIG], [
 		for i in `ls -d ${libdir} 2>/dev/null` \
 			`ls -d ${exec_prefix}/lib 2>/dev/null` \
 			`ls -d ${prefix}/lib 2>/dev/null` \
-			`ls -d /usr/local/lib 2>/dev/null` \
 			`ls -d /usr/contrib/lib 2>/dev/null` \
+			`ls -d /usr/local/lib 2>/dev/null` \
+			`ls -d /usr/pkg/lib 2>/dev/null` \
 			`ls -d /usr/lib 2>/dev/null` \
 			`ls -d /usr/lib64 2>/dev/null` \
 			; do
@@ -611,7 +612,6 @@ AC_DEFUN([SC_ENABLE_FRAMEWORK], [
 #		TCL_THREADS
 #		_REENTRANT
 #		_THREAD_SAFE
-#
 #------------------------------------------------------------------------
 
 AC_DEFUN([SC_ENABLE_THREADS], [
@@ -727,7 +727,6 @@ AC_DEFUN([SC_ENABLE_THREADS], [
 #				Sets to $(LDFLAGS_OPTIMIZE) if false
 #		DBGX		Formerly used as debug library extension;
 #				always blank now.
-#
 #------------------------------------------------------------------------
 
 AC_DEFUN([SC_ENABLE_SYMBOLS], [
@@ -892,8 +891,7 @@ AC_DEFUN([SC_CONFIG_MANPAGES], [
 #
 #	Determine what the system is (some things cannot be easily checked
 #	on a feature-driven basis, alas). This can usually be done via the
-#	"uname" command, but there are a few systems, like Next, where
-#	this doesn't work.
+#	"uname" command.
 #
 # Arguments:
 #	none
@@ -902,25 +900,18 @@ AC_DEFUN([SC_CONFIG_MANPAGES], [
 #	Defines the following var:
 #
 #	system -	System/platform/version identification code.
-#
 #--------------------------------------------------------------------
 
 AC_DEFUN([SC_CONFIG_SYSTEM], [
     AC_CACHE_CHECK([system version], tcl_cv_sys_version, [
-	if test -f /usr/lib/NextStep/software_version; then
-	    tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
+	if test "${TEA_PLATFORM}" = "windows" ; then
+	    tcl_cv_sys_version=windows
 	else
 	    tcl_cv_sys_version=`uname -s`-`uname -r`
 	    if test "$?" -ne 0 ; then
 		AC_MSG_WARN([can't find uname command])
 		tcl_cv_sys_version=unknown
 	    else
-		# Special check for weird MP-RAS system (uname returns weird
-		# results, and the version is kept in special file).
-
-		if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then
-		    tcl_cv_sys_version=MP-RAS-`awk '{print $[3]}' /etc/.relid`
-		fi
 		if test "`uname -s`" = "AIX" ; then
 		    tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
 		fi
@@ -977,11 +968,11 @@ AC_DEFUN([SC_CONFIG_SYSTEM], [
 #       SHLIB_LD_LIBS - Dependent libraries for the linker to scan when
 #                       creating shared libraries.  This symbol typically
 #                       goes at the end of the "ld" commands that build
-#                       shared libraries. The value of the symbol is
+#                       shared libraries. The value of the symbol defaults to
 #                       "${LIBS}" if all of the dependent libraries should
 #                       be specified when creating a shared library.  If
-#                       dependent libraries should not be specified (as on
-#                       SunOS 4.x, where they cause the link to fail, or in
+#                       dependent libraries should not be specified (as on some
+#                       SunOS systems, where they cause the link to fail, or in
 #                       general if Tcl and Tk aren't themselves shared
 #                       libraries), then this symbol has an empty string
 #                       as its value.
@@ -1107,7 +1098,7 @@ AC_DEFUN([SC_CONFIG_CFLAGS], [
     PLAT_OBJS=""
     PLAT_SRCS=""
     LDAIX_SRC=""
-    AS_IF([test x"${SHLIB_VERSION}" = x], [SHLIB_VERSION="1.0"])
+    AS_IF([test "x${SHLIB_VERSION}" = x], [SHLIB_VERSION="1.0"])
     case $system in
 	AIX-*)
 	    AS_IF([test "${TCL_THREADS}" = "1" -a "$GCC" != "yes"], [
@@ -1236,9 +1227,9 @@ AC_DEFUN([SC_CONFIG_CFLAGS], [
 	    fi
 	    do64bit_ok=yes
 	    if test "x${SHARED_BUILD}" = "x1"; then
-		echo "running cd ${TCL_SRC_DIR}/win; ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args"
+		echo "running cd ../win; ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args"
 		# The eval makes quoting arguments work.
-		if cd ${TCL_SRC_DIR}/win; eval ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args; cd ../unix
+		if cd ../win; eval ${CONFIG_SHELL-/bin/sh} ./configure $ac_configure_args; cd ../unix
 		then :
 		else
 		    { echo "configure: error: configure failed for ../win" 1>&2; exit 1; }
@@ -1443,68 +1434,26 @@ AC_DEFUN([SC_CONFIG_CFLAGS], [
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'])
 	    ;;
-	MP-RAS-02*)
-	    SHLIB_CFLAGS="-K PIC"
-	    SHLIB_LD='${CC} -G'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
-	MP-RAS-*)
-	    SHLIB_CFLAGS="-K PIC"
-	    SHLIB_LD='${CC} -G'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    LDFLAGS="$LDFLAGS -Wl,-Bexport"
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
 	OpenBSD-*)
 	    arch=`arch -s`
 	    case "$arch" in
-	    vax)
-		# Equivalent using configure option --disable-load
-		# Step 4 will set the necessary variables
-		DL_OBJS=""
-		SHLIB_LD_LIBS=""
-		LDFLAGS=""
+	    alpha|sparc64)
+		SHLIB_CFLAGS="-fPIC"
 		;;
 	    *)
-		case "$arch" in
-		alpha|sparc|sparc64)
-		    SHLIB_CFLAGS="-fPIC"
-		    ;;
-		*)
-		    SHLIB_CFLAGS="-fpic"
-		    ;;
-		esac
-		SHLIB_LD='${CC} -shared ${SHLIB_CFLAGS}'
-		SHLIB_SUFFIX=".so"
-		DL_OBJS="tclLoadDl.o"
-		DL_LIBS=""
-		AS_IF([test $doRpath = yes], [
-		    CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'])
-		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-		SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.${SHLIB_VERSION}'
-		LDFLAGS="-Wl,-export-dynamic"
-		;;
-	    esac
-	    case "$arch" in
-	    vax)
-		CFLAGS_OPTIMIZE="-O1"
-		;;
-	    sh)
-		CFLAGS_OPTIMIZE="-O0"
-		;;
-	    *)
-		CFLAGS_OPTIMIZE="-O2"
+		SHLIB_CFLAGS="-fpic"
 		;;
 	    esac
+	    SHLIB_LD='${CC} -shared ${SHLIB_CFLAGS}'
+	    SHLIB_SUFFIX=".so"
+	    DL_OBJS="tclLoadDl.o"
+	    DL_LIBS=""
+	    AS_IF([test $doRpath = yes], [
+		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'])
+	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+	    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.${SHLIB_VERSION}'
+	    LDFLAGS="-Wl,-export-dynamic"
+	    CFLAGS_OPTIMIZE="-O2"
 	    AS_IF([test "${TCL_THREADS}" = "1"], [
 		# On OpenBSD:	Compile with -pthread
 		#		Don't link with -lpthread
@@ -1698,47 +1647,12 @@ AC_DEFUN([SC_CONFIG_CFLAGS], [
 		])
 	    ])
 	    ;;
-	NEXTSTEP-*)
-	    SHLIB_CFLAGS=""
-	    SHLIB_LD='${CC} -nostdlib -r'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadNext.o"
-	    DL_LIBS=""
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
 	OS/390-*)
 	    SHLIB_LD_LIBS=""
 	    CFLAGS_OPTIMIZE=""		# Optimizer is buggy
 	    AC_DEFINE(_OE_SOCKETS, 1,	# needed in sys/socket.h
 		[Should OS/390 do the right thing with sockets?])
 	    ;;
-	OSF1-1.0|OSF1-1.1|OSF1-1.2)
-	    # OSF/1 1.[012] from OSF, and derivatives, including Paragon OSF/1
-	    SHLIB_CFLAGS=""
-	    # Hack: make package name same as library name
-	    SHLIB_LD='ld -R -export $@:'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadOSF.o"
-	    DL_LIBS=""
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
-	OSF1-1.*)
-	    # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2
-	    SHLIB_CFLAGS="-fPIC"
-	    AS_IF([test "$SHARED_BUILD" = 1], [SHLIB_LD="ld -shared"], [
-	        SHLIB_LD="ld -non_shared"
-	    ])
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS=""
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
 	OSF1-V*)
 	    # Digital OSF/1
 	    SHLIB_CFLAGS=""
@@ -1800,35 +1714,6 @@ AC_DEFUN([SC_CONFIG_CFLAGS], [
 	    CC_SEARCH_FLAGS=""
 	    LD_SEARCH_FLAGS=""
 	    ;;
-	SINIX*5.4*)
-	    SHLIB_CFLAGS="-K PIC"
-	    SHLIB_LD='${CC} -G'
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    CC_SEARCH_FLAGS=""
-	    LD_SEARCH_FLAGS=""
-	    ;;
-	SunOS-4*)
-	    SHLIB_CFLAGS="-PIC"
-	    SHLIB_LD="ld"
-	    SHLIB_LD_LIBS=""
-	    SHLIB_SUFFIX=".so"
-	    DL_OBJS="tclLoadDl.o"
-	    DL_LIBS="-ldl"
-	    CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
-	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-
-	    # SunOS can't handle version numbers with dots in them in library
-	    # specs, like -ltcl7.5, so use -ltcl75 instead.  Also, it
-	    # requires an extra version number at the end of .so file names.
-	    # So, the library has to have a name like libtcl75.so.1.0
-
-	    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.${SHLIB_VERSION}'
-	    UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
-	    TCL_LIB_VERSIONS_OK=nodots
-	    ;;
 	SunOS-5.[[0-6]])
 	    # Careful to not let 5.10+ fall into this case
 
@@ -2337,10 +2222,6 @@ AC_DEFUN([SC_BLOCKING_STYLE], [
 	    AC_DEFINE(USE_FIONBIO, 1, [Should we use FIONBIO?])
 	    AC_MSG_RESULT([FIONBIO])
 	    ;;
-	SunOS-4*)
-	    AC_DEFINE(USE_FIONBIO, 1, [Should we use FIONBIO?])
-	    AC_MSG_RESULT([FIONBIO])
-	    ;;
 	*)
 	    AC_MSG_RESULT([O_NONBLOCK])
 	    ;;
diff --git a/unix/tclConfig.sh.in b/unix/tclConfig.sh.in
index 27fd513..fdc56b7 100644
--- a/unix/tclConfig.sh.in
+++ b/unix/tclConfig.sh.in
@@ -81,7 +81,7 @@ TCL_DL_LIBS='@DL_LIBS@'
 # an executable tclsh or tcltest binary.
 TCL_LD_FLAGS='@LDFLAGS@'
 
-# Flags to pass to ld, such as "-R /usr/local/tcl/lib", that tell the
+# Flags to pass to cc/ld, such as "-R /usr/local/tcl/lib", that tell the
 # run-time dynamic linker where to look for shared libraries such as
 # libtcl.so.  Used when linking applications.  Only works if there
 # is a variable "LIB_RUNTIME_DIR" defined in the Makefile.
diff --git a/unix/tclEpollNotfy.c b/unix/tclEpollNotfy.c
new file mode 100644
index 0000000..088f314
--- /dev/null
+++ b/unix/tclEpollNotfy.c
@@ -0,0 +1,806 @@
+/*
+ * tclEpollNotfy.c --
+ *
+ *	This file contains the implementation of the epoll()-based
+ *	Linux-specific notifier, which is the lowest-level part of the
+ *	Tcl event loop. This file works together with generic/tclNotify.c.
+ *
+ * Copyright (c) 1995-1997 Sun Microsystems, Inc.
+ * Copyright (c) 2016 Lucio Andrés Illanes Albornoz <l.illanes@gmx.de>
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifdef NOTIFIER_EPOLL
+
+#define _GNU_SOURCE		/* For pipe2(2) */
+#include "tclInt.h"
+#ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
+				 * in tclMacOSXNotify.c */
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/epoll.h>
+#ifdef HAVE_EVENTFD
+#include <sys/eventfd.h>
+#endif /* HAVE_EVENTFD */
+#include <sys/queue.h>
+#include <unistd.h>
+
+/*
+ * This structure is used to keep track of the notifier info for a registered
+ * file.
+ */
+
+struct PlatformEventData;
+typedef struct FileHandler {
+    int fd;
+    int mask;			/* Mask of desired events: TCL_READABLE,
+				 * etc. */
+    int readyMask;		/* Mask of events that have been seen since
+				 * the last time file handlers were invoked
+				 * for this file. */
+    Tcl_FileProc *proc;		/* Function to call, in the style of
+				 * Tcl_CreateFileHandler. */
+    ClientData clientData;	/* Argument to pass to proc. */
+    struct FileHandler *nextPtr;/* Next in list of all files we care about. */
+    LIST_ENTRY(FileHandler) readyNode;
+				/* Next/previous in list of FileHandlers asso-
+				 * ciated with regular files (S_IFREG) that are
+				 * ready for I/O. */
+    struct PlatformEventData *pedPtr;
+				/* Pointer to PlatformEventData associating this
+				 * FileHandler with epoll(7) events. */
+} FileHandler;
+
+/*
+ * The following structure associates a FileHandler and the thread that owns it
+ * with the file descriptors of interest and their event masks passed to epoll_ctl(2)
+ * and their corresponding event(s) returned by epoll_wait(2).
+ */
+
+struct ThreadSpecificData;
+struct PlatformEventData {
+    FileHandler *filePtr;
+    struct ThreadSpecificData *tsdPtr;
+};
+
+/*
+ * The following structure is what is added to the Tcl event queue when file
+ * handlers are ready to fire.
+ */
+
+typedef struct {
+    Tcl_Event header;		/* Information that is standard for all
+				 * events. */
+    int fd;			/* File descriptor that is ready. Used to find
+				 * the FileHandler structure for the file
+				 * (can't point directly to the FileHandler
+				 * structure because it could go away while
+				 * the event is queued). */
+} FileHandlerEvent;
+
+/*
+ * The following static structure contains the state information for the
+ * epoll based implementation of the Tcl notifier. One of these structures is
+ * created for each thread that is using the notifier.
+ */
+
+LIST_HEAD(PlatformReadyFileHandlerList, FileHandler);
+typedef struct ThreadSpecificData {
+    FileHandler *firstFileHandlerPtr;
+				/* Pointer to head of file handler list. */
+    struct PlatformReadyFileHandlerList firstReadyFileHandlerPtr;
+				/* Pointer to head of list of FileHandlers
+				 * associated with regular files (S_IFREG)
+				 * that are ready for I/O. */
+    pthread_mutex_t notifierMutex;
+				/* Mutex protecting notifier termination in
+				 * PlatformEventsFinalize. */
+#ifdef HAVE_EVENTFD
+    int triggerEventFd;		/* eventfd(2) used by other threads to wake
+				 * up this thread for inter-thread IPC. */
+#else
+    int triggerPipe[2];		/* pipe(2) used by other threads to wake
+				 * up this thread for inter-thread IPC. */
+#endif /* HAVE_EVENTFD */
+    int eventsFd;		/* epoll(7) file descriptor used to wait for fds */
+    struct epoll_event *readyEvents;
+				/* Pointer to at most maxReadyEvents events
+				 * returned by epoll_wait(2). */
+    size_t maxReadyEvents;	/* Count of epoll_events in readyEvents. */
+} ThreadSpecificData;
+
+static Tcl_ThreadDataKey dataKey;
+
+void PlatformEventsControl(FileHandler *filePtr, ThreadSpecificData *tsdPtr, int op, int isNew);
+static void PlatformEventsFinalize(void);
+void PlatformEventsInit(void);
+static int PlatformEventsTranslate(struct epoll_event *event);
+static int PlatformEventsWait(struct epoll_event *events, size_t numEvents, struct timeval *timePtr);
+
+#include "tclUnixNotfy.c"
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_InitNotifier --
+ *
+ *	Initializes the platform specific notifier state.
+ *
+ * Results:
+ *	Returns a handle to the notifier state for this thread.
+ *
+ * Side effects:
+ *	If no initNotifierProc notifier hook exists, PlatformEventsInit
+ *	is called.
+ *
+ *----------------------------------------------------------------------
+ */
+
+ClientData
+Tcl_InitNotifier(void)
+{
+    if (tclNotifierHooks.initNotifierProc) {
+	return tclNotifierHooks.initNotifierProc();
+    } else {
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+	PlatformEventsInit();
+	return tsdPtr;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_FinalizeNotifier --
+ *
+ *	This function is called to cleanup the notifier state before a thread
+ *	is terminated.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If no finalizeNotifierProc notifier hook exists, PlatformEvents-
+ *	Finalize is called.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_FinalizeNotifier(
+    ClientData clientData)		/* Not used. */
+{
+    if (tclNotifierHooks.finalizeNotifierProc) {
+	tclNotifierHooks.finalizeNotifierProc(clientData);
+	return;
+    } else {
+	PlatformEventsFinalize();
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsControl --
+ *
+ *	This function registers interest for the file descriptor and the mask
+ *	of TCL_* bits associated with filePtr on the epoll file descriptor
+ *	associated with tsdPtr.
+ *	Future calls to epoll_wait will return filePtr and tsdPtr alongside with
+ *	the event registered here via the PlatformEventData struct.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If adding a new file descriptor, a PlatformEventData struct will be
+ *	allocated and associated with filePtr.
+ *	fstat is called on the file descriptor; if it is associated with
+ *	a regular file (S_IFREG,) filePtr is considered to be ready for I/O
+ *	and added to or deleted from the corresponding list in tsdPtr.
+ *	If it is not associated with a regular file, the file descriptor is
+ *	added, modified concerning its mask of events of interest, or deleted
+ *	from the epoll file descriptor of the calling thread.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+PlatformEventsControl(
+	FileHandler *filePtr,
+	ThreadSpecificData *tsdPtr,
+	int op,
+	int isNew)
+{
+    struct epoll_event newEvent;
+    struct PlatformEventData *newPedPtr;
+    struct stat fdStat;
+
+    newEvent.events = 0;
+    if (filePtr->mask & (TCL_READABLE | TCL_EXCEPTION)) {
+	newEvent.events |= EPOLLIN;
+    }
+    if (filePtr->mask & TCL_WRITABLE) {
+	newEvent.events |= EPOLLOUT;
+    }
+    if (isNew) {
+        newPedPtr = ckalloc(sizeof(*newPedPtr));
+        newPedPtr->filePtr = filePtr;
+        newPedPtr->tsdPtr = tsdPtr;
+	filePtr->pedPtr = newPedPtr;
+    }
+    newEvent.data.ptr = filePtr->pedPtr;
+
+    /*
+     * N.B.	As discussed in Tcl_WaitForEvent(), epoll(7) does not sup-
+     *		port regular files (S_IFREG.) Therefore, filePtr is in these
+     *		cases simply added or deleted from the list of FileHandlers
+     *		associated with regular files belonging to tsdPtr.
+     */
+
+    if (fstat(filePtr->fd, &fdStat) == -1) {
+	Tcl_Panic("fstat: %s", strerror(errno));
+    } else if ((fdStat.st_mode & S_IFMT) == S_IFREG) {
+	switch (op) {
+	case EPOLL_CTL_ADD:
+	    if (isNew) {
+		LIST_INSERT_HEAD(&tsdPtr->firstReadyFileHandlerPtr, filePtr, readyNode);
+	    }
+	    break;
+	case EPOLL_CTL_DEL:
+	    LIST_REMOVE(filePtr, readyNode);
+	    break;
+	}
+	return;
+   } else if (epoll_ctl(tsdPtr->eventsFd, op, filePtr->fd, &newEvent) == -1) {
+	Tcl_Panic("epoll_ctl: %s", strerror(errno));
+   }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsFinalize --
+ *
+ *	This function closes the eventfd and the epoll file descriptor and
+ *	frees the epoll_event structs owned by the thread of the caller.
+ *	The above operations are protected by tsdPtr->notifierMutex, which
+ *	is destroyed thereafter.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ * 	While tsdPtr->notifierMutex is held:
+ *	The per-thread eventfd(2) is closed, if non-zero, and set to -1.
+ *	The per-thread epoll(7) fd is closed, if non-zero, and set to 0.
+ *	The per-thread epoll_event structs are freed, if any, and set to 0.
+ *
+ *	tsdPtr->notifierMutex is destroyed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+PlatformEventsFinalize(
+	void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    pthread_mutex_lock(&tsdPtr->notifierMutex);
+#ifdef HAVE_EVENTFD
+    if (tsdPtr->triggerEventFd) {
+	close(tsdPtr->triggerEventFd);
+	tsdPtr->triggerEventFd = -1;
+    }
+#else
+    if (tsdPtr->triggerPipe[0]) {
+	close(tsdPtr->triggerPipe[0]);
+	tsdPtr->triggerPipe[0] = -1;
+    }
+    if (tsdPtr->triggerPipe[1]) {
+	close(tsdPtr->triggerPipe[1]);
+	tsdPtr->triggerPipe[1] = -1;
+    }
+#endif /* HAVE_EVENTFD */
+    if (tsdPtr->eventsFd > 0) {
+	close(tsdPtr->eventsFd);
+	tsdPtr->eventsFd = 0;
+    }
+    if (tsdPtr->readyEvents) {
+	ckfree(tsdPtr->readyEvents);
+	tsdPtr->maxReadyEvents = 0;
+    }
+    pthread_mutex_unlock(&tsdPtr->notifierMutex);
+    if ((errno = pthread_mutex_destroy(&tsdPtr->notifierMutex))) {
+	Tcl_Panic("pthread_mutex_destroy: %s", strerror(errno));
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsInit --
+ *
+ *	This function abstracts creating a kqueue fd via the epoll_create
+ *	system call and allocating memory for the epoll_event structs in
+ *	tsdPtr for the thread of the caller.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The following per-thread entities are initialised:
+ *	notifierMutex is initialised.
+ *	The eventfd(2) is created w/ EFD_CLOEXEC and EFD_NONBLOCK.
+ *	The epoll(7) fd is created w/ EPOLL_CLOEXEC.
+ *	A FileHandler struct is allocated and initialised for the event-
+ *	fd(2), registering interest for TCL_READABLE on it via Platform-
+ *	EventsControl().
+ *	readyEvents and maxReadyEvents are initialised with 512 epoll_events.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+PlatformEventsInit(
+	void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    FileHandler *filePtr;
+
+    errno = pthread_mutex_init(&tsdPtr->notifierMutex, NULL);
+    if (errno) {
+	Tcl_Panic("Tcl_InitNotifier: %s", "could not create mutex");
+    }
+    filePtr = ckalloc(sizeof(*filePtr));
+#ifdef HAVE_EVENTFD
+    if ((tsdPtr->triggerEventFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK)) <= 0) {
+	Tcl_Panic("Tcl_InitNotifier: %s", "could not create trigger eventfd");
+    }
+    filePtr->fd = tsdPtr->triggerEventFd;
+#else
+    if (pipe2(tsdPtr->triggerPipe, O_CLOEXEC | O_NONBLOCK) != 0) {
+	Tcl_Panic("Tcl_InitNotifier: %s", "could not create trigger pipe");
+    }
+    filePtr->fd = tsdPtr->triggerPipe[0];
+#endif
+    if ((tsdPtr->eventsFd = epoll_create1(EPOLL_CLOEXEC)) == -1) {
+	Tcl_Panic("epoll_create1: %s", strerror(errno));
+    }
+    filePtr->mask = TCL_READABLE;
+    PlatformEventsControl(filePtr, tsdPtr, EPOLL_CTL_ADD, 1);
+    if (!tsdPtr->readyEvents) {
+        tsdPtr->maxReadyEvents = 512;
+	tsdPtr->readyEvents = ckalloc(tsdPtr->maxReadyEvents
+	    * sizeof(tsdPtr->readyEvents[0]));
+    }
+    LIST_INIT(&tsdPtr->firstReadyFileHandlerPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsTranslate --
+ *
+ *	This function translates the platform-specific mask of returned
+ *	events in eventPtr to a mask of TCL_* bits.
+ *
+ * Results:
+ *	Returns the translated mask.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+PlatformEventsTranslate(
+	struct epoll_event *eventPtr)
+{
+    int mask;
+
+    mask = 0;
+    if (eventPtr->events & (EPOLLIN | EPOLLHUP)) {
+	mask |= TCL_READABLE;
+    }
+    if (eventPtr->events & EPOLLOUT) {
+	mask |= TCL_WRITABLE;
+    }
+    if (eventPtr->events & EPOLLERR) {
+	mask |= TCL_EXCEPTION;
+    }
+    return mask;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsWait --
+ *
+ *	This function abstracts waiting for I/O events via epoll_wait.
+ *
+ * Results:
+ *	Returns -1 if epoll_wait failed. Returns 0 if polling and if no
+ *	events became available whilst polling. Returns a pointer to and
+ *	the count of all returned events in all other cases.
+ *
+ * Side effects:
+ *	gettimeofday(2), epoll_wait(2), and gettimeofday(2) are called,
+ *	in the specified order.
+ *	If timePtr specifies a positive value, it is updated to reflect
+ *	the amount of time that has passed; if its value would {under,
+ *	over}flow, it is set to zero.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+PlatformEventsWait(
+    struct epoll_event *events,
+    size_t numEvents,
+    struct timeval *timePtr)
+{
+    int numFound;
+    struct timeval tv0, tv1, tv_delta;
+    int timeout;
+
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    /*
+     * If timePtr is NULL, epoll_wait(2) will wait indefinitely. If it
+     * specifies a timeout of {0,0}, epoll_wait(2) will poll. Otherwise,
+     * the timeout will simply be converted to milliseconds.
+     */
+
+    if (!timePtr) {
+	timeout = -1;
+    } else if (!timePtr->tv_sec && !timePtr->tv_usec) {
+	timeout = 0;
+    } else {
+	timeout = (int)timePtr->tv_sec;
+    }
+
+    /*
+     * Call (and possibly block on) epoll_wait(2) and substract the delta
+     * of gettimeofday(2) before and after the call from timePtr if the
+     * latter is not NULL. Return the number of events returned by epoll_wait(2).
+     */
+
+    gettimeofday(&tv0, NULL);
+    numFound = epoll_wait(tsdPtr->eventsFd, events, (int)numEvents, timeout);
+    gettimeofday(&tv1, NULL);
+    if (timePtr && (timePtr->tv_sec && timePtr->tv_usec)) {
+	timersub(&tv1, &tv0, &tv_delta);
+	if (!timercmp(&tv_delta, timePtr, >)) {
+		timersub(timePtr, &tv_delta, timePtr);
+	} else {
+		timePtr->tv_sec = 0;
+		timePtr->tv_usec = 0;
+	}
+    }
+    return numFound;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateFileHandler --
+ *
+ *	This function registers a file handler with the epoll notifier
+ *	of the thread of the caller.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Creates a new file handler structure.
+ *	PlatformEventsControl() is called for the new file handler structure.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_CreateFileHandler(
+    int fd,			/* Handle of stream to watch. */
+    int mask,			/* OR'ed combination of TCL_READABLE,
+				 * TCL_WRITABLE, and TCL_EXCEPTION: indicates
+				 * conditions under which proc should be
+				 * called. */
+    Tcl_FileProc *proc,		/* Function to call for each selected
+				 * event. */
+    ClientData clientData)	/* Arbitrary data to pass to proc. */
+{
+    int isNew;
+
+    if (tclNotifierHooks.createFileHandlerProc) {
+	tclNotifierHooks.createFileHandlerProc(fd, mask, proc, clientData);
+	return;
+    } else {
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+	FileHandler *filePtr;
+
+	for (filePtr = tsdPtr->firstFileHandlerPtr; filePtr != NULL;
+		filePtr = filePtr->nextPtr) {
+	    if (filePtr->fd == fd) {
+		break;
+	    }
+	}
+	if (filePtr == NULL) {
+	    filePtr = ckalloc(sizeof(FileHandler));
+	    filePtr->fd = fd;
+	    filePtr->readyMask = 0;
+	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
+	    tsdPtr->firstFileHandlerPtr = filePtr;
+	    isNew = 1;
+	} else {
+	    isNew = 0;
+	}
+	filePtr->proc = proc;
+	filePtr->clientData = clientData;
+	filePtr->mask = mask;
+
+	PlatformEventsControl(filePtr, tsdPtr, isNew ?
+	    EPOLL_CTL_ADD : EPOLL_CTL_MOD, isNew);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DeleteFileHandler --
+ *
+ *	Cancel a previously-arranged callback arrangement for a file on
+ *	the epoll file descriptor of the thread of the caller.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If a callback was previously registered on file, remove it.
+ *	PlatformEventsControl() is called for the file handler structure.
+ *	The PlatformEventData struct associated with the new file handler
+ *	structure is freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_DeleteFileHandler(
+    int fd)			/* Stream id for which to remove callback
+				 * function. */
+{
+    if (tclNotifierHooks.deleteFileHandlerProc) {
+	tclNotifierHooks.deleteFileHandlerProc(fd);
+	return;
+    } else {
+	FileHandler *filePtr, *prevPtr;
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+	/*
+	 * Find the entry for the given file (and return if there isn't one).
+	 */
+
+	for (prevPtr = NULL, filePtr = tsdPtr->firstFileHandlerPtr; ;
+		prevPtr = filePtr, filePtr = filePtr->nextPtr) {
+	    if (filePtr == NULL) {
+		return;
+	    }
+	    if (filePtr->fd == fd) {
+		break;
+	    }
+	}
+
+	/*
+	 * Update the check masks for this file.
+	 */
+
+	PlatformEventsControl(filePtr, tsdPtr, EPOLL_CTL_DEL, 0);
+	if (filePtr->pedPtr) {
+	    ckfree(filePtr->pedPtr);
+	}
+
+	/*
+	 * Clean up information in the callback record.
+	 */
+
+	if (prevPtr == NULL) {
+	    tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
+	} else {
+	    prevPtr->nextPtr = filePtr->nextPtr;
+	}
+	ckfree(filePtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_WaitForEvent --
+ *
+ *	This function is called by Tcl_DoOneEvent to wait for new events on
+ *	the message queue. If the block time is 0, then Tcl_WaitForEvent just
+ *	polls without blocking.
+ *	The waiting logic is implemented in PlatformEventsWait.
+ *
+ * Results:
+ *	Returns -1 if PlatformEventsWait() would block forever, otherwise
+ *	returns 0.
+ *
+ * Side effects:
+ *	Queues file events that are detected by PlatformEventsWait().
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_WaitForEvent(
+    const Tcl_Time *timePtr)		/* Maximum block time, or NULL. */
+{
+    if (tclNotifierHooks.waitForEventProc) {
+	return tclNotifierHooks.waitForEventProc(timePtr);
+    } else {
+	FileHandler *filePtr;
+	int mask;
+	Tcl_Time vTime;
+	/*
+	 * Impl. notes: timeout & timeoutPtr are used if, and only if threads
+	 * are not enabled. They are the arguments for the regular epoll_wait()
+	 * used when the core is not thread-enabled.
+	 */
+
+	struct timeval timeout, *timeoutPtr;
+	int numFound, numEvent;
+	struct PlatformEventData *pedPtr;
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+	int numQueued;
+	ssize_t i;
+
+	/*
+	 * Set up the timeout structure. Note that if there are no events to
+	 * check for, we return with a negative result rather than blocking
+	 * forever.
+	 */
+
+	if (timePtr != NULL) {
+	    /*
+	     * TIP #233 (Virtualized Time). Is virtual time in effect? And do
+	     * we actually have something to scale? If yes to both then we
+	     * call the handler to do this scaling.
+	     */
+
+	    if (timePtr->sec != 0 || timePtr->usec != 0) {
+		vTime = *timePtr;
+		tclScaleTimeProcPtr(&vTime, tclTimeClientData);
+		timePtr = &vTime;
+	    }
+	    timeout.tv_sec = timePtr->sec;
+	    timeout.tv_usec = timePtr->usec;
+	    timeoutPtr = &timeout;
+	} else {
+	    timeoutPtr = NULL;
+	}
+
+	/*
+	 * Walk the list of FileHandlers associated with regular files
+	 * (S_IFREG) belonging to tsdPtr, queue Tcl events for them, and
+	 * update their mask of events of interest.
+	 * As epoll(7) does not support regular files, the behaviour of
+	 * {select,poll}(2) is simply simulated here: fds associated with
+	 * regular files are added to this list by PlatformEventsControl()
+	 * and processed here before calling (and possibly blocking) on
+	 * PlatformEventsWait().
+	 */
+
+	numQueued = 0;
+	LIST_FOREACH(filePtr, &tsdPtr->firstReadyFileHandlerPtr, readyNode) {
+	    mask = 0;
+	    if (filePtr->mask & TCL_READABLE) {
+		mask |= TCL_READABLE;
+	    }
+	    if (filePtr->mask & TCL_WRITABLE) {
+		mask |= TCL_WRITABLE;
+	    }
+
+	    /*
+	     * Don't bother to queue an event if the mask was previously
+	     * non-zero since an event must still be on the queue.
+	     */
+
+	    if (filePtr->readyMask == 0) {
+		FileHandlerEvent *fileEvPtr =
+		    ckalloc(sizeof(FileHandlerEvent));
+
+		fileEvPtr->header.proc = FileHandlerEventProc;
+		fileEvPtr->fd = filePtr->fd;
+		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
+		numQueued++;
+	    }
+	    filePtr->readyMask = mask;
+	}
+
+	/*
+	 * If any events were queued in the above loop, force PlatformEvents-
+	 * Wait() to poll as there already are events that need to be processed
+	 * at this point.
+	 */
+
+	if (numQueued) {
+	    timeout.tv_sec = 0;
+	    timeout.tv_usec = 0;
+	    timeoutPtr = &timeout;
+	}
+
+	/*
+	 * Wait or poll for new events, queue Tcl events for the FileHandlers
+	 * corresponding to them, and update the FileHandlers' mask of events
+	 * of interest registered by the last call to Tcl_CreateFileHandler().
+	 *
+	 * Events for the eventfd(2)/trigger pipe are processed here in order
+	 * to facilitate inter-thread IPC. If another thread intends to wake
+	 * up this thread whilst it's blocking on PlatformEventsWait(), it
+	 * write(2)s to the eventfd(2)/trigger pipe (see Tcl_AlertNotifier(),)
+	 * which in turn will cause PlatformEventsWait() to return immediately.
+	 */
+
+	numFound = PlatformEventsWait(tsdPtr->readyEvents, tsdPtr->maxReadyEvents, timeoutPtr);
+	for (numEvent = 0; numEvent < numFound; numEvent++) {
+	    pedPtr = tsdPtr->readyEvents[numEvent].data.ptr;
+	    filePtr = pedPtr->filePtr;
+	    mask = PlatformEventsTranslate(&tsdPtr->readyEvents[numEvent]);
+#ifdef HAVE_EVENTFD
+	    if (filePtr->fd == tsdPtr->triggerEventFd) {
+		uint64_t eventFdVal;
+		i = read(tsdPtr->triggerEventFd, &eventFdVal, sizeof(eventFdVal));
+		if ((i != sizeof(eventFdVal)) && (errno != EAGAIN)) {
+#else
+	    if (filePtr->fd == tsdPtr->triggerPipe[0]) {
+		char triggerPipeVal;
+		i = read(tsdPtr->triggerPipe[0], &triggerPipeVal, sizeof(triggerPipeVal));
+		if ((i != sizeof(triggerPipeVal)) && (errno != EAGAIN)) {
+#endif
+			Tcl_Panic("Tcl_WaitForEvent: "
+				"read from %p->triggerEventFd: %s",
+				(void *)tsdPtr, strerror(errno));
+		} else {
+		    continue;
+		}
+	    }
+	    if (!mask) {
+		continue;
+	    }
+
+	    /*
+	     * Don't bother to queue an event if the mask was previously
+	     * non-zero since an event must still be on the queue.
+	     */
+
+	    if (filePtr->readyMask == 0) {
+		FileHandlerEvent *fileEvPtr =
+			ckalloc(sizeof(FileHandlerEvent));
+
+		fileEvPtr->header.proc = FileHandlerEventProc;
+		fileEvPtr->fd = filePtr->fd;
+		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
+	    }
+	    filePtr->readyMask = mask;
+	}
+	return 0;
+    }
+}
+
+#endif /* !HAVE_COREFOUNDATION */
+
+#endif /* NOTIFIER_EPOLL */
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tclKqueueNotfy.c b/unix/tclKqueueNotfy.c
new file mode 100644
index 0000000..049829e
--- /dev/null
+++ b/unix/tclKqueueNotfy.c
@@ -0,0 +1,842 @@
+/*
+ * tclKqueueNotfy.c --
+ *
+ *	This file contains the implementation of the kqueue()-based
+ *	DragonFly/Free/Net/OpenBSD-specific notifier, which is the lowest-
+ *	level part of the Tcl event loop. This file works together with
+ *	generic/tclNotify.c.
+ *
+ * Copyright (c) 1995-1997 Sun Microsystems, Inc.
+ * Copyright (c) 2016 Lucio Andrés Illanes Albornoz <l.illanes@gmx.de>
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifdef NOTIFIER_KQUEUE
+
+#include "tclInt.h"
+#ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
+				 * in tclMacOSXNotify.c */
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/queue.h>
+#include <sys/time.h>
+
+/*
+ * This structure is used to keep track of the notifier info for a registered
+ * file.
+ */
+
+struct PlatformEventData;
+typedef struct FileHandler {
+    int fd;
+    int mask;			/* Mask of desired events: TCL_READABLE,
+				 * etc. */
+    int readyMask;		/* Mask of events that have been seen since
+				 * the last time file handlers were invoked
+				 * for this file. */
+    Tcl_FileProc *proc;		/* Function to call, in the style of
+				 * Tcl_CreateFileHandler. */
+    ClientData clientData;	/* Argument to pass to proc. */
+    struct FileHandler *nextPtr;/* Next in list of all files we care about. */
+    LIST_ENTRY(FileHandler) readyNode;
+				/* Next/previous in list of FileHandlers asso-
+				 * ciated with regular files (S_IFREG) that are
+				 * ready for I/O. */
+    struct PlatformEventData *pedPtr;
+				/* Pointer to PlatformEventData associating this
+				 * FileHandler with kevent(2) events. */
+} FileHandler;
+
+/*
+ * The following structure associates a FileHandler and the thread that owns it
+ * with the file descriptors of interest and their event masks passed to kevent(2)
+ * and their corresponding event(s) returned by kevent(2).
+ */
+
+struct ThreadSpecificData;
+struct PlatformEventData {
+    FileHandler *filePtr;
+    struct ThreadSpecificData *tsdPtr;
+};
+
+/*
+ * The following structure is what is added to the Tcl event queue when file
+ * handlers are ready to fire.
+ */
+
+typedef struct {
+    Tcl_Event header;		/* Information that is standard for all
+				 * events. */
+    int fd;			/* File descriptor that is ready. Used to find
+				 * the FileHandler structure for the file
+				 * (can't point directly to the FileHandler
+				 * structure because it could go away while
+				 * the event is queued). */
+} FileHandlerEvent;
+
+/*
+ * The following static structure contains the state information for the
+ * kqueue based implementation of the Tcl notifier. One of these structures is
+ * created for each thread that is using the notifier.
+ */
+
+LIST_HEAD(PlatformReadyFileHandlerList, FileHandler);
+typedef struct ThreadSpecificData {
+    FileHandler *firstFileHandlerPtr;
+				/* Pointer to head of file handler list. */
+    struct PlatformReadyFileHandlerList firstReadyFileHandlerPtr;
+				/* Pointer to head of list of FileHandlers
+				 * associated with regular files (S_IFREG)
+				 * that are ready for I/O. */
+    pthread_mutex_t notifierMutex;
+				/* Mutex protecting notifier termination in
+				 * PlatformEventsFinalize. */
+    int triggerPipe[2];		/* pipe(2) used by other threads to wake
+				 * up this thread for inter-thread IPC. */
+    int eventsFd;		/* kqueue(2) file descriptor used to wait for fds. */
+    struct kevent *readyEvents;	/* Pointer to at most maxReadyEvents events
+				 * returned by kevent(2). */
+    size_t maxReadyEvents;	/* Count of kevents in readyEvents. */
+} ThreadSpecificData;
+
+static Tcl_ThreadDataKey dataKey;
+
+void PlatformEventsControl(FileHandler *filePtr, ThreadSpecificData *tsdPtr, int op, int isNew);
+static void PlatformEventsFinalize(void);
+void PlatformEventsInit(void);
+static int PlatformEventsTranslate(struct kevent *eventPtr);
+static int PlatformEventsWait(struct kevent *events, size_t numEvents, struct timeval *timePtr);
+
+#include "tclUnixNotfy.c"
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_InitNotifier --
+ *
+ *	Initializes the platform specific notifier state.
+ *
+ * Results:
+ *	Returns a handle to the notifier state for this thread.
+ *
+ * Side effects:
+ *	If no initNotifierProc notifier hook exists, PlatformEventsInit
+ *	is called.
+ *
+ *----------------------------------------------------------------------
+ */
+
+ClientData
+Tcl_InitNotifier(void)
+{
+    if (tclNotifierHooks.initNotifierProc) {
+	return tclNotifierHooks.initNotifierProc();
+    } else {
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+	PlatformEventsInit();
+	return tsdPtr;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_FinalizeNotifier --
+ *
+ *	This function is called to cleanup the notifier state before a thread
+ *	is terminated.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If no finalizeNotifierProc notifier hook exists, PlatformEvents-
+ *	Finalize is called.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_FinalizeNotifier(
+    ClientData clientData)		/* Not used. */
+{
+    if (tclNotifierHooks.finalizeNotifierProc) {
+	tclNotifierHooks.finalizeNotifierProc(clientData);
+	return;
+    } else {
+	PlatformEventsFinalize();
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsControl --
+ *
+ *	This function registers interest for the file descriptor and the mask
+ *	of TCL_* bits associated with filePtr on the kqueue file descriptor
+ *	associated with tsdPtr.
+ *	Future calls to kevent will return filePtr and tsdPtr alongside with
+ *	the event registered here via the PlatformEventData struct.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If adding a new file descriptor, a PlatformEventData struct will be
+ *	allocated and associated with filePtr.
+ *	fstat is called on the file descriptor; if it is associated with
+ *	a regular file (S_IFREG,) filePtr is considered to be ready for I/O
+ *	and added to or deleted from the corresponding list in tsdPtr.
+ *	If it is not associated with a regular file, the file descriptor is
+ *	added, modified concerning its mask of events of interest, or deleted
+ *	from the epoll file descriptor of the calling thread.
+ *	If deleting a file descriptor, kevent(2) is called twice specifying
+ *	EVFILT_READ first and then EVFILT_WRITE (see note below.)
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+PlatformEventsControl(
+	FileHandler *filePtr,
+	ThreadSpecificData *tsdPtr,
+	int op,
+	int isNew)
+{
+    int numChanges;
+    struct kevent changeList[2];
+    struct PlatformEventData *newPedPtr;
+    struct stat fdStat;
+
+    if (isNew) {
+        newPedPtr = ckalloc(sizeof(*newPedPtr));
+        newPedPtr->filePtr = filePtr;
+        newPedPtr->tsdPtr = tsdPtr;
+        filePtr->pedPtr = newPedPtr;
+    }
+
+    /*
+     * N.B.	As discussed in Tcl_WaitForEvent(), kqueue(2) does not repro-
+     *		duce the `always ready' {select,poll}(2) behaviour for regular
+     *		files (S_IFREG) prior to FreeBSD 11.0-RELEASE. Therefore, file-
+     *		Ptr is in these cases simply added or deleted from the list of
+     *		FileHandlers associated with regular files belonging to tsdPtr.
+     */
+
+    if (fstat(filePtr->fd, &fdStat) == -1) {
+	Tcl_Panic("fstat: %s", strerror(errno));
+    } else if ((fdStat.st_mode & S_IFMT) == S_IFREG) {
+	switch (op) {
+	case EV_ADD:
+	    if (isNew) {
+		LIST_INSERT_HEAD(&tsdPtr->firstReadyFileHandlerPtr, filePtr, readyNode);
+	    }
+	    break;
+	case EV_DELETE:
+	    LIST_REMOVE(filePtr, readyNode);
+	    break;
+	}
+	return;
+    }
+
+    numChanges = 0;
+    switch (op) {
+    case EV_ADD:
+	if (filePtr->mask & (TCL_READABLE | TCL_EXCEPTION)) {
+	    EV_SET(&changeList[numChanges], (uintptr_t)filePtr->fd, EVFILT_READ,
+		op, 0, 0, filePtr->pedPtr);
+	    numChanges++;
+	}
+	if (filePtr->mask & TCL_WRITABLE) {
+	    EV_SET(&changeList[numChanges], (uintptr_t)filePtr->fd, EVFILT_WRITE,
+		op, 0, 0, filePtr->pedPtr);
+	    numChanges++;
+	}
+        if (numChanges) {
+	    if (kevent(tsdPtr->eventsFd, changeList, numChanges, NULL, 0, NULL) == -1) {
+		Tcl_Panic("kevent: %s", strerror(errno));
+	    }
+	}
+	break;
+    case EV_DELETE:
+	/*
+	 * N.B.	kqueue(2) has separate filters for readability and writabi-
+	 *		lity fd events. We therefore need to ensure that fds are
+	 *		ompletely removed from the kqueue(2) fd when deleting.
+	 *		This is exacerbated by changes to filePtr->mask w/o calls
+	 *		to PlatforEventsControl() after e.g. an exec(3) in a child
+	 *		process.
+	 *		As one of these calls can fail, two separate kevent(2) calls
+	 *		are made for EVFILT_{READ,WRITE}.
+	 */
+	EV_SET(&changeList[0], (uintptr_t)filePtr->fd, EVFILT_READ, op, 0, 0, NULL);
+	if ((kevent(tsdPtr->eventsFd, changeList, 1, NULL, 0, NULL) == -1)
+		&& (errno != ENOENT)) {
+	    Tcl_Panic("kevent: %s", strerror(errno));
+	}
+	EV_SET(&changeList[0], (uintptr_t)filePtr->fd, EVFILT_WRITE, op, 0, 0, NULL);
+	if ((kevent(tsdPtr->eventsFd, changeList, 1, NULL, 0, NULL) == -1)
+		&& (errno != ENOENT)) {
+	    Tcl_Panic("kevent: %s", strerror(errno));
+	}
+	break;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsFinalize --
+ *
+ *	This function closes the pipe and the kqueue file descriptors
+ *	and frees the kevent structs owned by the thread of the caller.
+ *	The above operations are protected by tsdPtr->notifierMutex, which
+ *	is destroyed thereafter.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ * 	While tsdPtr->notifierMutex is held:
+ *	The per-thread pipe(2) fds are closed, if non-zero, and set to -1.
+ *	The per-thread kqueue(2) fd is closed, if non-zero, and set to 0.
+ *	The per-thread kevent structs are freed, if any, and set to 0.
+ *
+ *	tsdPtr->notifierMutex is destroyed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+PlatformEventsFinalize(
+	void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    pthread_mutex_lock(&tsdPtr->notifierMutex);
+    if (tsdPtr->triggerPipe[0]) {
+	close(tsdPtr->triggerPipe[0]);
+	tsdPtr->triggerPipe[0] = -1;
+    }
+    if (tsdPtr->triggerPipe[1]) {
+	close(tsdPtr->triggerPipe[1]);
+	tsdPtr->triggerPipe[1] = -1;
+    }
+    if (tsdPtr->eventsFd > 0) {
+	close(tsdPtr->eventsFd);
+	tsdPtr->eventsFd = 0;
+    }
+    if (tsdPtr->readyEvents) {
+	ckfree(tsdPtr->readyEvents);
+	tsdPtr->maxReadyEvents = 0;
+    }
+    pthread_mutex_unlock(&tsdPtr->notifierMutex);
+    if ((errno = pthread_mutex_destroy(&tsdPtr->notifierMutex))) {
+	Tcl_Panic("pthread_mutex_destroy: %s", strerror(errno));
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsInit --
+ *
+ *	This function abstracts creating a kqueue fd via the kqueue
+ *	system call and allocating memory for the kevents structs in
+ *	tsdPtr for the thread of the caller.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The following per-thread entities are initialised:
+ *	notifierMutex is initialised.
+ *	The pipe(2) is created; fcntl(2) is called on both fds to set
+ *	FD_CLOEXEC and O_NONBLOCK.
+ *	The kqueue(2) fd is created; fcntl(2) is called on it to set
+ *	FD_CLOEXEC.
+ *	A FileHandler struct is allocated and initialised for the event-
+ *	fd(2), registering interest for TCL_READABLE on it via Platform-
+ *	EventsControl().
+ *	readyEvents and maxReadyEvents are initialised with 512 kevents.
+
+ *----------------------------------------------------------------------
+ */
+
+void
+PlatformEventsInit(
+	void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    int i, fdFl;
+    FileHandler *filePtr;
+
+    errno = pthread_mutex_init(&tsdPtr->notifierMutex, NULL);
+    if (errno) {
+	Tcl_Panic("Tcl_InitNotifier: %s", "could not create mutex");
+    }
+    if (pipe(tsdPtr->triggerPipe) != 0) {
+	Tcl_Panic("Tcl_InitNotifier: %s", "could not create trigger pipe");
+    } else for (i = 0; i < 2; i++) {
+	if (fcntl(tsdPtr->triggerPipe[i], F_SETFD, FD_CLOEXEC) == -1) {
+	    Tcl_Panic("fcntl: %s", strerror(errno));
+	} else {
+	    fdFl = fcntl(tsdPtr->triggerPipe[i], F_GETFL);
+	    fdFl |= O_NONBLOCK;
+	}
+	if (fcntl(tsdPtr->triggerPipe[i], F_SETFL, fdFl) == -1) {
+	    Tcl_Panic("fcntl: %s", strerror(errno));
+	}
+    }
+    if ((tsdPtr->eventsFd = kqueue()) == -1) {
+	Tcl_Panic("kqueue: %s", strerror(errno));
+    } else if (fcntl(tsdPtr->eventsFd, F_SETFD, FD_CLOEXEC) == -1) {
+	Tcl_Panic("fcntl: %s", strerror(errno));
+    }
+    filePtr = ckalloc(sizeof(*filePtr));
+    filePtr->fd = tsdPtr->triggerPipe[0];
+    filePtr->mask = TCL_READABLE;
+    PlatformEventsControl(filePtr, tsdPtr, EV_ADD, 1);
+    if (!tsdPtr->readyEvents) {
+        tsdPtr->maxReadyEvents = 512;
+	tsdPtr->readyEvents = ckalloc(tsdPtr->maxReadyEvents
+	    * sizeof(tsdPtr->readyEvents[0]));
+    }
+    LIST_INIT(&tsdPtr->firstReadyFileHandlerPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsTranslate --
+ *
+ *	This function translates the platform-specific mask of returned
+ *	events in eventPtr to a mask of TCL_* bits.
+ *
+ * Results:
+ *	Returns the translated mask.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+PlatformEventsTranslate(
+	struct kevent *eventPtr)
+{
+    int mask;
+
+    mask = 0;
+    if (eventPtr->filter == EVFILT_READ) {
+	mask |= TCL_READABLE;
+	if (eventPtr->flags & EV_ERROR) {
+	    mask |= TCL_EXCEPTION;
+	}
+    }
+    if (eventPtr->filter == EVFILT_WRITE) {
+	mask |= TCL_WRITABLE;
+	if (eventPtr->flags & EV_ERROR) {
+	    mask |= TCL_EXCEPTION;
+	}
+    }
+    return mask;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PlatformEventsWait --
+ *
+ *	This function abstracts waiting for I/O events via the kevent
+ *	system call.
+ *
+ * Results:
+ *	Returns -1 if kevent failed. Returns 0 if polling and if no events
+ *	became available whilst polling. Returns a pointer to and the count
+ *	of all returned events in all other cases.
+ *
+ * Side effects:
+ *	gettimeofday(2), kevent(2), and gettimeofday(2) are called,
+ *	in the specified order.
+ *	If timePtr specifies a positive value, it is updated to reflect
+ *	the amount of time that has passed; if its value would {under,
+ *	over}flow, it is set to zero.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+PlatformEventsWait(
+    struct kevent *events,
+    size_t numEvents,
+    struct timeval *timePtr)
+{
+    int numFound;
+    struct timeval tv0, tv1, tv_delta;
+    struct timespec timeout, *timeoutPtr;
+
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    /*
+     * If timePtr is NULL, kevent(2) will wait indefinitely. If it speci-
+     * fies a timeout of {0,0}, kevent(2) will poll. Otherwise, the time-
+     * out will simply be converted to a timespec.
+     */
+
+    if (!timePtr) {
+	timeoutPtr = NULL;
+    } else if (!timePtr->tv_sec && !timePtr->tv_usec) {
+	timeout.tv_sec = 0;
+	timeout.tv_nsec = 0;
+	timeoutPtr = &timeout;
+    } else {
+	timeout.tv_sec = timePtr->tv_sec;
+	timeout.tv_nsec = timePtr->tv_usec * 1000;
+	timeoutPtr = &timeout;
+    }
+
+    /*
+     * Call (and possibly block on) kevent(2) and substract the delta of
+     * gettimeofday(2) before and after the call from timePtr if the latter
+     * is not NULL. Return the number of events returned by kevent(2).
+     */
+
+    gettimeofday(&tv0, NULL);
+    numFound = kevent(tsdPtr->eventsFd, NULL, 0, events, (int)numEvents, timeoutPtr);
+    gettimeofday(&tv1, NULL);
+    if (timePtr && (timePtr->tv_sec && timePtr->tv_usec)) {
+	timersub(&tv1, &tv0, &tv_delta);
+	if (!timercmp(&tv_delta, timePtr, >)) {
+		timersub(timePtr, &tv_delta, timePtr);
+	} else {
+		timePtr->tv_sec = 0;
+		timePtr->tv_usec = 0;
+	}
+    }
+    return numFound;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateFileHandler --
+ *
+ *	This function registers a file handler with the kqueue notifier
+ *	of the thread of the caller.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Creates a new file handler structure.
+ *	PlatformEventsControl() is called for the new file handler structure.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_CreateFileHandler(
+    int fd,			/* Handle of stream to watch. */
+    int mask,			/* OR'ed combination of TCL_READABLE,
+				 * TCL_WRITABLE, and TCL_EXCEPTION: indicates
+				 * conditions under which proc should be
+				 * called. */
+    Tcl_FileProc *proc,		/* Function to call for each selected
+				 * event. */
+    ClientData clientData)	/* Arbitrary data to pass to proc. */
+{
+    int isNew;
+
+    if (tclNotifierHooks.createFileHandlerProc) {
+	tclNotifierHooks.createFileHandlerProc(fd, mask, proc, clientData);
+	return;
+    } else {
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+	FileHandler *filePtr;
+
+	for (filePtr = tsdPtr->firstFileHandlerPtr; filePtr != NULL;
+		filePtr = filePtr->nextPtr) {
+	    if (filePtr->fd == fd) {
+		break;
+	    }
+	}
+	if (filePtr == NULL) {
+	    filePtr = ckalloc(sizeof(FileHandler));
+	    filePtr->fd = fd;
+	    filePtr->readyMask = 0;
+	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
+	    tsdPtr->firstFileHandlerPtr = filePtr;
+	    isNew = 1;
+	} else {
+	    isNew = 0;
+	}
+	filePtr->proc = proc;
+	filePtr->clientData = clientData;
+	filePtr->mask = mask;
+
+	PlatformEventsControl(filePtr, tsdPtr, EV_ADD, isNew);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DeleteFileHandler --
+ *
+ *	Cancel a previously-arranged callback arrangement for a file on
+ *	the kqueue of the thread of the caller.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If a callback was previously registered on file, remove it.
+ *	PlatformEventsControl() is called for the file handler structure.
+ *	The PlatformEventData struct associated with the new file handler
+ *	structure is freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_DeleteFileHandler(
+    int fd)			/* Stream id for which to remove callback
+				 * function. */
+{
+    if (tclNotifierHooks.deleteFileHandlerProc) {
+	tclNotifierHooks.deleteFileHandlerProc(fd);
+	return;
+    } else {
+	FileHandler *filePtr, *prevPtr;
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+	/*
+	 * Find the entry for the given file (and return if there isn't one).
+	 */
+
+	for (prevPtr = NULL, filePtr = tsdPtr->firstFileHandlerPtr; ;
+		prevPtr = filePtr, filePtr = filePtr->nextPtr) {
+	    if (filePtr == NULL) {
+		return;
+	    }
+	    if (filePtr->fd == fd) {
+		break;
+	    }
+	}
+
+	/*
+	 * Update the check masks for this file.
+	 */
+
+	PlatformEventsControl(filePtr, tsdPtr, EV_DELETE, 0);
+	if (filePtr->pedPtr) {
+	    ckfree(filePtr->pedPtr);
+	}
+
+	/*
+	 * Clean up information in the callback record.
+	 */
+
+	if (prevPtr == NULL) {
+	    tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
+	} else {
+	    prevPtr->nextPtr = filePtr->nextPtr;
+	}
+	ckfree(filePtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_WaitForEvent --
+ *
+ *	This function is called by Tcl_DoOneEvent to wait for new events on
+ *	the message queue. If the block time is 0, then Tcl_WaitForEvent just
+ *	polls without blocking.
+ *	The waiting logic is implemented in PlatformEventsWait.
+ *
+ * Results:
+ *	Returns -1 if PlatformEventsWait() would block forever, otherwise
+ *	returns 0.
+ *
+ * Side effects:
+ *	Queues file events that are detected by PlatformEventsWait().
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_WaitForEvent(
+    const Tcl_Time *timePtr)		/* Maximum block time, or NULL. */
+{
+    if (tclNotifierHooks.waitForEventProc) {
+	return tclNotifierHooks.waitForEventProc(timePtr);
+    } else {
+	FileHandler *filePtr;
+	int mask;
+	Tcl_Time vTime;
+	/*
+	 * Impl. notes: timeout & timeoutPtr are used if, and only if threads
+	 * are not enabled. They are the arguments for the regular epoll_wait()
+	 * used when the core is not thread-enabled.
+	 */
+
+	struct timeval timeout, *timeoutPtr;
+	int numFound, numEvent;
+	struct PlatformEventData *pedPtr;
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+	int numQueued;
+	ssize_t i;
+	char buf[1];
+
+	/*
+	 * Set up the timeout structure. Note that if there are no events to
+	 * check for, we return with a negative result rather than blocking
+	 * forever.
+	 */
+
+	if (timePtr != NULL) {
+	    /*
+	     * TIP #233 (Virtualized Time). Is virtual time in effect? And do
+	     * we actually have something to scale? If yes to both then we
+	     * call the handler to do this scaling.
+	     */
+
+	    if (timePtr->sec != 0 || timePtr->usec != 0) {
+		vTime = *timePtr;
+		tclScaleTimeProcPtr(&vTime, tclTimeClientData);
+		timePtr = &vTime;
+	    }
+	    timeout.tv_sec = timePtr->sec;
+	    timeout.tv_usec = timePtr->usec;
+	    timeoutPtr = &timeout;
+	} else {
+	    timeoutPtr = NULL;
+	}
+
+	/*
+	 * Walk the list of FileHandlers associated with regular files
+	 * (S_IFREG) belonging to tsdPtr, queue Tcl events for them, and
+	 * update their mask of events of interest.
+	 * kqueue(2), unlike epoll(7), does support regular files, but
+	 * EVFILT_READ only `[r]eturns when the file pointer is not at
+	 * the end of file' as opposed to unconditionally. While FreeBSD
+	 * 11.0-RELEASE adds support for this mode (NOTE_FILE_POLL,) this
+	 * is not used for reasons of compatibility.
+	 * Therefore, the behaviour of {select,poll}(2) is simply simulated
+	 * here: fds associated with regular files are added to this list by
+	 * PlatformEventsControl() and processed here before calling (and
+	 * possibly blocking) on PlatformEventsWait().
+	 */
+
+	numQueued = 0;
+	LIST_FOREACH(filePtr, &tsdPtr->firstReadyFileHandlerPtr, readyNode) {
+	    mask = 0;
+	    if (filePtr->mask & TCL_READABLE) {
+		mask |= TCL_READABLE;
+	    }
+	    if (filePtr->mask & TCL_WRITABLE) {
+		mask |= TCL_WRITABLE;
+	    }
+
+	    /*
+	     * Don't bother to queue an event if the mask was previously
+	     * non-zero since an event must still be on the queue.
+	     */
+
+	    if (filePtr->readyMask == 0) {
+		FileHandlerEvent *fileEvPtr =
+		    ckalloc(sizeof(FileHandlerEvent));
+
+		fileEvPtr->header.proc = FileHandlerEventProc;
+		fileEvPtr->fd = filePtr->fd;
+		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
+		numQueued++;
+	    }
+	    filePtr->readyMask = mask;
+	}
+
+	/*
+	 * If any events were queued in the above loop, force PlatformEvents-
+	 * Wait() to poll as there already are events that need to be processed
+	 * at this point.
+	 */
+
+	if (numQueued) {
+	    timeout.tv_sec = 0;
+	    timeout.tv_usec = 0;
+	    timeoutPtr = &timeout;
+	}
+
+	/*
+	 * Wait or poll for new events, queue Tcl events for the FileHandlers
+	 * corresponding to them, and update the FileHandlers' mask of events
+	 * of interest registered by the last call to Tcl_CreateFileHandler().
+	 *
+	 * Events for the trigger pipe are processed here in order to facilitate
+	 * inter-thread IPC. If another thread intends to wake up this thread
+	 * whilst it's blocking on PlatformEventsWait(), it write(2)s to the
+	 * other end of the pipe (see Tcl_AlertNotifier(),) which in turn will
+	 * cause PlatformEventsWait() to return immediately.
+	 */
+
+	numFound = PlatformEventsWait(tsdPtr->readyEvents, tsdPtr->maxReadyEvents, timeoutPtr);
+	for (numEvent = 0; numEvent < numFound; numEvent++) {
+	    pedPtr = (struct PlatformEventData *)tsdPtr->readyEvents[numEvent].udata;
+	    filePtr = pedPtr->filePtr;
+	    mask = PlatformEventsTranslate(&tsdPtr->readyEvents[numEvent]);
+	    if (filePtr->fd == tsdPtr->triggerPipe[0]) {
+		do {
+		    i = read(tsdPtr->triggerPipe[0], buf, 1);
+		    if ((i == -1) && (errno != EAGAIN)) {
+			Tcl_Panic("Tcl_WaitForEvent: "
+				"read from %p->triggerPipe: %s",
+				(void *)tsdPtr, strerror(errno));
+		    } else {
+			break;
+		    }
+		} while (1);
+		continue;
+	    }
+	    if (!mask) {
+		continue;
+	    }
+
+	    /*
+	     * Don't bother to queue an event if the mask was previously
+	     * non-zero since an event must still be on the queue.
+	     */
+
+	    if (filePtr->readyMask == 0) {
+		FileHandlerEvent *fileEvPtr =
+			ckalloc(sizeof(FileHandlerEvent));
+
+		fileEvPtr->header.proc = FileHandlerEventProc;
+		fileEvPtr->fd = filePtr->fd;
+		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
+	    }
+	    filePtr->readyMask |= mask;
+	}
+	return 0;
+    }
+}
+
+#endif /* !HAVE_COREFOUNDATION */
+
+#endif /* NOTIFIER_KQUEUE */
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tclSelectNotfy.c b/unix/tclSelectNotfy.c
new file mode 100644
index 0000000..cf21b85
--- /dev/null
+++ b/unix/tclSelectNotfy.c
@@ -0,0 +1,1117 @@
+/*
+ * tclSelectNotfy.c --
+ *
+ *	This file contains the implementation of the select()-based
+ *	generic Unix notifier, which is the lowest-level part of the
+ *	Tcl event loop. This file works together with generic/tclNotify.c.
+ *
+ * Copyright (c) 1995-1997 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#if !defined(NOTIFIER_EPOLL) && !defined(NOTIFIER_KQUEUE)
+
+#include "tclInt.h"
+#ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
+				 * in tclMacOSXNotify.c */
+#include <signal.h>
+
+/*
+ * This structure is used to keep track of the notifier info for a registered
+ * file.
+ */
+
+typedef struct FileHandler {
+    int fd;
+    int mask;			/* Mask of desired events: TCL_READABLE,
+				 * etc. */
+    int readyMask;		/* Mask of events that have been seen since
+				 * the last time file handlers were invoked
+				 * for this file. */
+    Tcl_FileProc *proc;		/* Function to call, in the style of
+				 * Tcl_CreateFileHandler. */
+    ClientData clientData;	/* Argument to pass to proc. */
+    struct FileHandler *nextPtr;/* Next in list of all files we care about. */
+} FileHandler;
+
+/*
+ * The following structure contains a set of select() masks to track readable,
+ * writable, and exception conditions.
+ */
+
+typedef struct {
+    fd_set readable;
+    fd_set writable;
+    fd_set exception;
+} SelectMasks;
+
+/*
+ * The following structure is what is added to the Tcl event queue when file
+ * handlers are ready to fire.
+ */
+
+typedef struct {
+    Tcl_Event header;		/* Information that is standard for all
+				 * events. */
+    int fd;			/* File descriptor that is ready. Used to find
+				 * the FileHandler structure for the file
+				 * (can't point directly to the FileHandler
+				 * structure because it could go away while
+				 * the event is queued). */
+} FileHandlerEvent;
+
+/*
+ * The following static structure contains the state information for the
+ * select based implementation of the Tcl notifier. One of these structures is
+ * created for each thread that is using the notifier.
+ */
+
+typedef struct ThreadSpecificData {
+    FileHandler *firstFileHandlerPtr;
+				/* Pointer to head of file handler list. */
+    SelectMasks checkMasks;	/* This structure is used to build up the
+				 * masks to be used in the next call to
+				 * select. Bits are set in response to calls
+				 * to Tcl_CreateFileHandler. */
+    SelectMasks readyMasks;	/* This array reflects the readable/writable
+				 * conditions that were found to exist by the
+				 * last call to select. */
+    int numFdBits;		/* Number of valid bits in checkMasks (one
+				 * more than highest fd for which
+				 * Tcl_WatchFile has been called). */
+#ifdef TCL_THREADS
+    int onList;			/* True if it is in this list */
+    unsigned int pollState;	/* pollState is used to implement a polling
+				 * handshake between each thread and the
+				 * notifier thread. Bits defined below. */
+    struct ThreadSpecificData *nextPtr, *prevPtr;
+				/* All threads that are currently waiting on
+				 * an event have their ThreadSpecificData
+				 * structure on a doubly-linked listed formed
+				 * from these pointers. You must hold the
+				 * notifierMutex lock before accessing these
+				 * fields. */
+#ifdef __CYGWIN__
+    void *event;     /* Any other thread alerts a notifier
+	 * that an event is ready to be processed
+	 * by sending this event. */
+    void *hwnd;			/* Messaging window. */
+#else /* !__CYGWIN__ */
+    pthread_cond_t waitCV;	/* Any other thread alerts a notifier that an
+				 * event is ready to be processed by signaling
+				 * this condition variable. */
+#endif /* __CYGWIN__ */
+    int waitCVinitialized;	/* Variable to flag initialization of the structure */
+    int eventReady;		/* True if an event is ready to be processed.
+				 * Used as condition flag together with waitCV
+				 * above. */
+#endif /* TCL_THREADS */
+} ThreadSpecificData;
+
+static Tcl_ThreadDataKey dataKey;
+
+#ifdef TCL_THREADS
+/*
+ * The following static indicates the number of threads that have initialized
+ * notifiers.
+ *
+ * You must hold the notifierMutex lock before accessing this variable.
+ */
+
+static int notifierCount = 0;
+
+/*
+ * The following variable points to the head of a doubly-linked list of
+ * ThreadSpecificData structures for all threads that are currently waiting on
+ * an event.
+ *
+ * You must hold the notifierMutex lock before accessing this list.
+ */
+
+static ThreadSpecificData *waitingListPtr = NULL;
+
+/*
+ * The notifier thread spends all its time in select() waiting for a file
+ * descriptor associated with one of the threads on the waitingListPtr list to
+ * do something interesting. But if the contents of the waitingListPtr list
+ * ever changes, we need to wake up and restart the select() system call. You
+ * can wake up the notifier thread by writing a single byte to the file
+ * descriptor defined below. This file descriptor is the input-end of a pipe
+ * and the notifier thread is listening for data on the output-end of the same
+ * pipe. Hence writing to this file descriptor will cause the select() system
+ * call to return and wake up the notifier thread.
+ *
+ * You must hold the notifierMutex lock before writing to the pipe.
+ */
+
+static int triggerPipe = -1;
+
+/*
+ * The notifierMutex locks access to all of the global notifier state.
+ */
+
+static pthread_mutex_t notifierInitMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t notifierMutex     = PTHREAD_MUTEX_INITIALIZER;
+/*
+ * The following static indicates if the notifier thread is running.
+ *
+ * You must hold the notifierInitMutex before accessing this variable.
+ */
+
+static int notifierThreadRunning = 0;
+
+/*
+ * The notifier thread signals the notifierCV when it has finished
+ * initializing the triggerPipe and right before the notifier thread
+ * terminates.
+ */
+
+static pthread_cond_t notifierCV = PTHREAD_COND_INITIALIZER;
+
+/*
+ * The pollState bits
+ *	POLL_WANT is set by each thread before it waits on its condition
+ *		variable. It is checked by the notifier before it does select.
+ *	POLL_DONE is set by the notifier if it goes into select after seeing
+ *		POLL_WANT. The idea is to ensure it tries a select with the
+ *		same bits the initial thread had set.
+ */
+
+#define POLL_WANT	0x1
+#define POLL_DONE	0x2
+
+/*
+ * This is the thread ID of the notifier thread that does select.
+ */
+
+static Tcl_ThreadId notifierThread;
+#endif /* TCL_THREADS */
+
+/*
+ * Static routines defined in this file.
+ */
+
+#ifdef TCL_THREADS
+static TCL_NORETURN void NotifierThreadProc(ClientData clientData);
+#if defined(HAVE_PTHREAD_ATFORK)
+static int	atForkInit = 0;
+static void	AtForkChild(void);
+#endif /* HAVE_PTHREAD_ATFORK */
+#endif /* TCL_THREADS */
+static int	FileHandlerEventProc(Tcl_Event *evPtr, int flags);
+
+/*
+ * Import of Windows API when building threaded with Cygwin.
+ */
+
+#if defined(TCL_THREADS) && defined(__CYGWIN__)
+typedef struct {
+    void *hwnd;
+    unsigned int *message;
+    int wParam;
+    int lParam;
+    int time;
+    int x;
+    int y;
+} MSG;
+
+typedef struct {
+    unsigned int style;
+    void *lpfnWndProc;
+    int cbClsExtra;
+    int cbWndExtra;
+    void *hInstance;
+    void *hIcon;
+    void *hCursor;
+    void *hbrBackground;
+    void *lpszMenuName;
+    const void *lpszClassName;
+} WNDCLASS;
+
+extern void __stdcall	CloseHandle(void *);
+extern void *__stdcall	CreateEventW(void *, unsigned char, unsigned char,
+			    void *);
+extern void * __stdcall	CreateWindowExW(void *, const void *, const void *,
+			    DWORD, int, int, int, int, void *, void *, void *, void *);
+extern DWORD __stdcall	DefWindowProcW(void *, int, void *, void *);
+extern unsigned char __stdcall	DestroyWindow(void *);
+extern int __stdcall	DispatchMessageW(const MSG *);
+extern unsigned char __stdcall	GetMessageW(MSG *, void *, int, int);
+extern void __stdcall	MsgWaitForMultipleObjects(DWORD, void *,
+			    unsigned char, DWORD, DWORD);
+extern unsigned char __stdcall	PeekMessageW(MSG *, void *, int, int, int);
+extern unsigned char __stdcall	PostMessageW(void *, unsigned int, void *,
+				    void *);
+extern void __stdcall	PostQuitMessage(int);
+extern void *__stdcall	RegisterClassW(const WNDCLASS *);
+extern unsigned char __stdcall	ResetEvent(void *);
+extern unsigned char __stdcall	TranslateMessage(const MSG *);
+
+/*
+ * Threaded-cygwin specific constants and functions in this file:
+ */
+
+static const WCHAR className[] = L"TclNotifier";
+static DWORD __stdcall	NotifierProc(void *hwnd, unsigned int message,
+			    void *wParam, void *lParam);
+#endif /* TCL_THREADS && __CYGWIN__ */
+
+
+#include "tclUnixNotfy.c"
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_InitNotifier --
+ *
+ *	Initializes the platform specific notifier state.
+ *
+ * Results:
+ *	Returns a handle to the notifier state for this thread.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+ClientData
+Tcl_InitNotifier(void)
+{
+    if (tclNotifierHooks.initNotifierProc) {
+	return tclNotifierHooks.initNotifierProc();
+    } else {
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+#ifdef TCL_THREADS
+	tsdPtr->eventReady = 0;
+
+	/*
+	 * Initialize thread specific condition variable for this thread.
+	 */
+	if (tsdPtr->waitCVinitialized == 0) {
+#ifdef __CYGWIN__
+	    WNDCLASS class;
+
+	    class.style = 0;
+	    class.cbClsExtra = 0;
+	    class.cbWndExtra = 0;
+	    class.hInstance = TclWinGetTclInstance();
+	    class.hbrBackground = NULL;
+	    class.lpszMenuName = NULL;
+	    class.lpszClassName = className;
+	    class.lpfnWndProc = NotifierProc;
+	    class.hIcon = NULL;
+	    class.hCursor = NULL;
+
+	    RegisterClassW(&class);
+	    tsdPtr->hwnd = CreateWindowExW(NULL, class.lpszClassName,
+		    class.lpszClassName, 0, 0, 0, 0, 0, NULL, NULL,
+		    TclWinGetTclInstance(), NULL);
+	    tsdPtr->event = CreateEventW(NULL, 1 /* manual */,
+		    0 /* !signaled */, NULL);
+#else
+	    pthread_cond_init(&tsdPtr->waitCV, NULL);
+#endif /* __CYGWIN__ */
+	    tsdPtr->waitCVinitialized = 1;
+	}
+
+	pthread_mutex_lock(&notifierInitMutex);
+#if defined(HAVE_PTHREAD_ATFORK)
+	/*
+	 * Install pthread_atfork handlers to clean up the notifier in the
+	 * child of a fork.
+	 */
+
+	if (!atForkInit) {
+	    int result = pthread_atfork(NULL, NULL, AtForkChild);
+
+	    if (result) {
+		Tcl_Panic("Tcl_InitNotifier: pthread_atfork failed");
+	    }
+	    atForkInit = 1;
+	}
+#endif /* HAVE_PTHREAD_ATFORK */
+
+	notifierCount++;
+
+	pthread_mutex_unlock(&notifierInitMutex);
+
+#endif /* TCL_THREADS */
+	return tsdPtr;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_FinalizeNotifier --
+ *
+ *	This function is called to cleanup the notifier state before a thread
+ *	is terminated.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May terminate the background notifier thread if this is the last
+ *	notifier instance.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_FinalizeNotifier(
+    ClientData clientData)		/* Not used. */
+{
+    if (tclNotifierHooks.finalizeNotifierProc) {
+	tclNotifierHooks.finalizeNotifierProc(clientData);
+	return;
+    } else {
+#ifdef TCL_THREADS
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+	pthread_mutex_lock(&notifierInitMutex);
+	notifierCount--;
+
+	/*
+	 * If this is the last thread to use the notifier, close the notifier
+	 * pipe and wait for the background thread to terminate.
+	 */
+
+	if (notifierCount == 0) {
+
+	    if (triggerPipe != -1) {
+		if (write(triggerPipe, "q", 1) != 1) {
+		    Tcl_Panic("Tcl_FinalizeNotifier: %s",
+			    "unable to write q to triggerPipe");
+		}
+		close(triggerPipe);
+		pthread_mutex_lock(&notifierMutex);
+		while(triggerPipe != -1) {
+		    pthread_cond_wait(&notifierCV, &notifierMutex);
+		}
+		pthread_mutex_unlock(&notifierMutex);
+		if (notifierThreadRunning) {
+		    int result = pthread_join((pthread_t) notifierThread, NULL);
+
+		    if (result) {
+			Tcl_Panic("Tcl_FinalizeNotifier: unable to join notifier "
+				"thread");
+		    }
+		    notifierThreadRunning = 0;
+		}
+	    }
+	}
+
+	/*
+	 * Clean up any synchronization objects in the thread local storage.
+	 */
+
+#ifdef __CYGWIN__
+	DestroyWindow(tsdPtr->hwnd);
+	CloseHandle(tsdPtr->event);
+#else /* __CYGWIN__ */
+	pthread_cond_destroy(&tsdPtr->waitCV);
+#endif /* __CYGWIN__ */
+	tsdPtr->waitCVinitialized = 0;
+
+	pthread_mutex_unlock(&notifierInitMutex);
+#endif /* TCL_THREADS */
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateFileHandler --
+ *
+ *	This function registers a file handler with the select notifier.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Creates a new file handler structure.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_CreateFileHandler(
+    int fd,			/* Handle of stream to watch. */
+    int mask,			/* OR'ed combination of TCL_READABLE,
+				 * TCL_WRITABLE, and TCL_EXCEPTION: indicates
+				 * conditions under which proc should be
+				 * called. */
+    Tcl_FileProc *proc,		/* Function to call for each selected
+				 * event. */
+    ClientData clientData)	/* Arbitrary data to pass to proc. */
+{
+    if (tclNotifierHooks.createFileHandlerProc) {
+	tclNotifierHooks.createFileHandlerProc(fd, mask, proc, clientData);
+	return;
+    } else {
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+	FileHandler *filePtr;
+
+	for (filePtr = tsdPtr->firstFileHandlerPtr; filePtr != NULL;
+		filePtr = filePtr->nextPtr) {
+	    if (filePtr->fd == fd) {
+		break;
+	    }
+	}
+	if (filePtr == NULL) {
+	    filePtr = ckalloc(sizeof(FileHandler));
+	    filePtr->fd = fd;
+	    filePtr->readyMask = 0;
+	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
+	    tsdPtr->firstFileHandlerPtr = filePtr;
+	}
+	filePtr->proc = proc;
+	filePtr->clientData = clientData;
+	filePtr->mask = mask;
+
+	/*
+	 * Update the check masks for this file.
+	 */
+
+	if (mask & TCL_READABLE) {
+	    FD_SET(fd, &tsdPtr->checkMasks.readable);
+	} else {
+	    FD_CLR(fd, &tsdPtr->checkMasks.readable);
+	}
+	if (mask & TCL_WRITABLE) {
+	    FD_SET(fd, &tsdPtr->checkMasks.writable);
+	} else {
+	    FD_CLR(fd, &tsdPtr->checkMasks.writable);
+	}
+	if (mask & TCL_EXCEPTION) {
+	    FD_SET(fd, &tsdPtr->checkMasks.exception);
+	} else {
+	    FD_CLR(fd, &tsdPtr->checkMasks.exception);
+	}
+	if (tsdPtr->numFdBits <= fd) {
+	    tsdPtr->numFdBits = fd+1;
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DeleteFileHandler --
+ *
+ *	Cancel a previously-arranged callback arrangement for a file.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If a callback was previously registered on file, remove it.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_DeleteFileHandler(
+    int fd)			/* Stream id for which to remove callback
+				 * function. */
+{
+    if (tclNotifierHooks.deleteFileHandlerProc) {
+	tclNotifierHooks.deleteFileHandlerProc(fd);
+	return;
+    } else {
+	FileHandler *filePtr, *prevPtr;
+	int i;
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+	/*
+	 * Find the entry for the given file (and return if there isn't one).
+	 */
+
+	for (prevPtr = NULL, filePtr = tsdPtr->firstFileHandlerPtr; ;
+		prevPtr = filePtr, filePtr = filePtr->nextPtr) {
+	    if (filePtr == NULL) {
+		return;
+	    }
+	    if (filePtr->fd == fd) {
+		break;
+	    }
+	}
+
+	/*
+	 * Update the check masks for this file.
+	 */
+
+	if (filePtr->mask & TCL_READABLE) {
+	    FD_CLR(fd, &tsdPtr->checkMasks.readable);
+	}
+	if (filePtr->mask & TCL_WRITABLE) {
+	    FD_CLR(fd, &tsdPtr->checkMasks.writable);
+	}
+	if (filePtr->mask & TCL_EXCEPTION) {
+	    FD_CLR(fd, &tsdPtr->checkMasks.exception);
+	}
+
+	/*
+	 * Find current max fd.
+	 */
+
+	if (fd+1 == tsdPtr->numFdBits) {
+	    int numFdBits = 0;
+
+	    for (i = fd-1; i >= 0; i--) {
+		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)
+			|| FD_ISSET(i, &tsdPtr->checkMasks.writable)
+			|| FD_ISSET(i, &tsdPtr->checkMasks.exception)) {
+		    numFdBits = i+1;
+		    break;
+		}
+	    }
+	    tsdPtr->numFdBits = numFdBits;
+	}
+
+	/*
+	 * Clean up information in the callback record.
+	 */
+
+	if (prevPtr == NULL) {
+	    tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
+	} else {
+	    prevPtr->nextPtr = filePtr->nextPtr;
+	}
+	ckfree(filePtr);
+    }
+}
+
+#if defined(TCL_THREADS) && defined(__CYGWIN__)
+
+static DWORD __stdcall
+NotifierProc(
+    void *hwnd,
+    unsigned int message,
+    void *wParam,
+    void *lParam)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (message != 1024) {
+	return DefWindowProcW(hwnd, message, wParam, lParam);
+    }
+
+    /*
+     * Process all of the runnable events.
+     */
+
+    tsdPtr->eventReady = 1;
+    Tcl_ServiceAll();
+    return 0;
+}
+#endif /* TCL_THREADS && __CYGWIN__ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_WaitForEvent --
+ *
+ *	This function is called by Tcl_DoOneEvent to wait for new events on
+ *	the message queue. If the block time is 0, then Tcl_WaitForEvent just
+ *	polls without blocking.
+ *
+ * Results:
+ *	Returns -1 if the select would block forever, otherwise returns 0.
+ *
+ * Side effects:
+ *	Queues file events that are detected by the select.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_WaitForEvent(
+    const Tcl_Time *timePtr)		/* Maximum block time, or NULL. */
+{
+    if (tclNotifierHooks.waitForEventProc) {
+	return tclNotifierHooks.waitForEventProc(timePtr);
+    } else {
+	FileHandler *filePtr;
+	int mask;
+	Tcl_Time vTime;
+#ifdef TCL_THREADS
+	int waitForFiles;
+#   ifdef __CYGWIN__
+	MSG msg;
+#   endif /* __CYGWIN__ */
+#else
+	/*
+	 * Impl. notes: timeout & timeoutPtr are used if, and only if threads
+	 * are not enabled. They are the arguments for the regular select()
+	 * used when the core is not thread-enabled.
+	 */
+
+	struct timeval timeout, *timeoutPtr;
+	int numFound;
+#endif /* TCL_THREADS */
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+	/*
+	 * Set up the timeout structure. Note that if there are no events to
+	 * check for, we return with a negative result rather than blocking
+	 * forever.
+	 */
+
+	if (timePtr != NULL) {
+	    /*
+	     * TIP #233 (Virtualized Time). Is virtual time in effect? And do
+	     * we actually have something to scale? If yes to both then we
+	     * call the handler to do this scaling.
+	     */
+
+	    if (timePtr->sec != 0 || timePtr->usec != 0) {
+		vTime = *timePtr;
+		tclScaleTimeProcPtr(&vTime, tclTimeClientData);
+		timePtr = &vTime;
+	    }
+#ifndef TCL_THREADS
+	    timeout.tv_sec = timePtr->sec;
+	    timeout.tv_usec = timePtr->usec;
+	    timeoutPtr = &timeout;
+	} else if (tsdPtr->numFdBits == 0) {
+	    /*
+	     * If there are no threads, no timeout, and no fds registered,
+	     * then there are no events possible and we must avoid deadlock.
+	     * Note that this is not entirely correct because there might be a
+	     * signal that could interrupt the select call, but we don't
+	     * handle that case if we aren't using threads.
+	     */
+
+	    return -1;
+	} else {
+	    timeoutPtr = NULL;
+#endif /* !TCL_THREADS */
+	}
+
+#ifdef TCL_THREADS
+	/*
+	 * Start notifier thread and place this thread on the list of
+	 * interested threads, signal the notifier thread, and wait for a
+	 * response or a timeout.
+	 */
+	StartNotifierThread("Tcl_WaitForEvent");
+
+	pthread_mutex_lock(&notifierMutex);
+
+	if (timePtr != NULL && timePtr->sec == 0 && (timePtr->usec == 0
+#if defined(__APPLE__) && defined(__LP64__)
+		/*
+		 * On 64-bit Darwin, pthread_cond_timedwait() appears to have
+		 * a bug that causes it to wait forever when passed an
+		 * absolute time which has already been exceeded by the system
+		 * time; as a workaround, when given a very brief timeout,
+		 * just do a poll. [Bug 1457797]
+		 */
+		|| timePtr->usec < 10
+#endif /* __APPLE__ && __LP64__ */
+		)) {
+	    /*
+	     * Cannot emulate a polling select with a polling condition
+	     * variable. Instead, pretend to wait for files and tell the
+	     * notifier thread what we are doing. The notifier thread makes
+	     * sure it goes through select with its select mask in the same
+	     * state as ours currently is. We block until that happens.
+	     */
+
+	    waitForFiles = 1;
+	    tsdPtr->pollState = POLL_WANT;
+	    timePtr = NULL;
+	} else {
+	    waitForFiles = (tsdPtr->numFdBits > 0);
+	    tsdPtr->pollState = 0;
+	}
+
+	if (waitForFiles) {
+	    /*
+	     * Add the ThreadSpecificData structure of this thread to the list
+	     * of ThreadSpecificData structures of all threads that are
+	     * waiting on file events.
+	     */
+
+	    tsdPtr->nextPtr = waitingListPtr;
+	    if (waitingListPtr) {
+		waitingListPtr->prevPtr = tsdPtr;
+	    }
+	    tsdPtr->prevPtr = 0;
+	    waitingListPtr = tsdPtr;
+	    tsdPtr->onList = 1;
+
+	    if ((write(triggerPipe, "", 1) == -1) && (errno != EAGAIN)) {
+		Tcl_Panic("Tcl_WaitForEvent: %s",
+			"unable to write to triggerPipe");
+	    }
+	}
+
+	FD_ZERO(&tsdPtr->readyMasks.readable);
+	FD_ZERO(&tsdPtr->readyMasks.writable);
+	FD_ZERO(&tsdPtr->readyMasks.exception);
+
+	if (!tsdPtr->eventReady) {
+#ifdef __CYGWIN__
+	    if (!PeekMessageW(&msg, NULL, 0, 0, 0)) {
+		DWORD timeout;
+
+		if (timePtr) {
+		    timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
+		} else {
+		    timeout = 0xFFFFFFFF;
+		}
+		pthread_mutex_unlock(&notifierMutex);
+		MsgWaitForMultipleObjects(1, &tsdPtr->event, 0, timeout, 1279);
+		pthread_mutex_lock(&notifierMutex);
+	    }
+#else
+	    if (timePtr != NULL) {
+	       Tcl_Time now;
+	       struct timespec ptime;
+
+	       Tcl_GetTime(&now);
+	       ptime.tv_sec = timePtr->sec + now.sec + (timePtr->usec + now.usec) / 1000000;
+	       ptime.tv_nsec = 1000 * ((timePtr->usec + now.usec) % 1000000);
+
+	       pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex, &ptime);
+	    } else {
+	       pthread_cond_wait(&tsdPtr->waitCV, &notifierMutex);
+	    }
+#endif /* __CYGWIN__ */
+	}
+	tsdPtr->eventReady = 0;
+
+#ifdef __CYGWIN__
+	while (PeekMessageW(&msg, NULL, 0, 0, 0)) {
+	    /*
+	     * Retrieve and dispatch the message.
+	     */
+
+	    DWORD result = GetMessageW(&msg, NULL, 0, 0);
+
+	    if (result == 0) {
+		PostQuitMessage(msg.wParam);
+		/* What to do here? */
+	    } else if (result != (DWORD) -1) {
+		TranslateMessage(&msg);
+		DispatchMessageW(&msg);
+	    }
+	}
+	ResetEvent(tsdPtr->event);
+#endif /* __CYGWIN__ */
+
+	if (waitForFiles && tsdPtr->onList) {
+	    /*
+	     * Remove the ThreadSpecificData structure of this thread from the
+	     * waiting list. Alert the notifier thread to recompute its select
+	     * masks - skipping this caused a hang when trying to close a pipe
+	     * which the notifier thread was still doing a select on.
+	     */
+
+	    if (tsdPtr->prevPtr) {
+		tsdPtr->prevPtr->nextPtr = tsdPtr->nextPtr;
+	    } else {
+		waitingListPtr = tsdPtr->nextPtr;
+	    }
+	    if (tsdPtr->nextPtr) {
+		tsdPtr->nextPtr->prevPtr = tsdPtr->prevPtr;
+	    }
+	    tsdPtr->nextPtr = tsdPtr->prevPtr = NULL;
+	    tsdPtr->onList = 0;
+	    if ((write(triggerPipe, "", 1) == -1) && (errno != EAGAIN)) {
+		Tcl_Panic("Tcl_WaitForEvent: %s",
+			"unable to write to triggerPipe");
+	    }
+	}
+
+#else
+	tsdPtr->readyMasks = tsdPtr->checkMasks;
+	numFound = select(tsdPtr->numFdBits, &tsdPtr->readyMasks.readable,
+		&tsdPtr->readyMasks.writable, &tsdPtr->readyMasks.exception,
+		timeoutPtr);
+
+	/*
+	 * Some systems don't clear the masks after an error, so we have to do
+	 * it here.
+	 */
+
+	if (numFound == -1) {
+	    FD_ZERO(&tsdPtr->readyMasks.readable);
+	    FD_ZERO(&tsdPtr->readyMasks.writable);
+	    FD_ZERO(&tsdPtr->readyMasks.exception);
+	}
+#endif /* TCL_THREADS */
+
+	/*
+	 * Queue all detected file events before returning.
+	 */
+
+	for (filePtr = tsdPtr->firstFileHandlerPtr; (filePtr != NULL);
+		filePtr = filePtr->nextPtr) {
+	    mask = 0;
+	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.readable)) {
+		mask |= TCL_READABLE;
+	    }
+	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.writable)) {
+		mask |= TCL_WRITABLE;
+	    }
+	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.exception)) {
+		mask |= TCL_EXCEPTION;
+	    }
+
+	    if (!mask) {
+		continue;
+	    }
+
+	    /*
+	     * Don't bother to queue an event if the mask was previously
+	     * non-zero since an event must still be on the queue.
+	     */
+
+	    if (filePtr->readyMask == 0) {
+		FileHandlerEvent *fileEvPtr =
+			ckalloc(sizeof(FileHandlerEvent));
+
+		fileEvPtr->header.proc = FileHandlerEventProc;
+		fileEvPtr->fd = filePtr->fd;
+		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
+	    }
+	    filePtr->readyMask = mask;
+	}
+#ifdef TCL_THREADS
+	pthread_mutex_unlock(&notifierMutex);
+#endif /* TCL_THREADS */
+	return 0;
+    }
+}
+
+#ifdef TCL_THREADS
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * NotifierThreadProc --
+ *
+ *	This routine is the initial (and only) function executed by the
+ *	special notifier thread. Its job is to wait for file descriptors to
+ *	become readable or writable or to have an exception condition and then
+ *	to notify other threads who are interested in this information by
+ *	signalling a condition variable. Other threads can signal this
+ *	notifier thread of a change in their interests by writing a single
+ *	byte to a special pipe that the notifier thread is monitoring.
+ *
+ * Result:
+ *	None. Once started, this routine never exits. It dies with the overall
+ *	process.
+ *
+ * Side effects:
+ *	The trigger pipe used to signal the notifier thread is created when
+ *	the notifier thread first starts.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static TCL_NORETURN void
+NotifierThreadProc(
+    ClientData clientData)	/* Not used. */
+{
+    ThreadSpecificData *tsdPtr;
+    fd_set readableMask;
+    fd_set writableMask;
+    fd_set exceptionMask;
+    int i;
+    int fds[2], receivePipe;
+    long found;
+    struct timeval poll = {0., 0.}, *timePtr;
+    char buf[2];
+    int numFdBits = 0;
+
+    if (pipe(fds) != 0) {
+	Tcl_Panic("NotifierThreadProc: %s", "could not create trigger pipe");
+    }
+
+    receivePipe = fds[0];
+
+    if (TclUnixSetBlockingMode(receivePipe, TCL_MODE_NONBLOCKING) < 0) {
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make receive pipe non blocking");
+    }
+    if (TclUnixSetBlockingMode(fds[1], TCL_MODE_NONBLOCKING) < 0) {
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make trigger pipe non blocking");
+    }
+    if (fcntl(receivePipe, F_SETFD, FD_CLOEXEC) < 0) {
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make receive pipe close-on-exec");
+    }
+    if (fcntl(fds[1], F_SETFD, FD_CLOEXEC) < 0) {
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make trigger pipe close-on-exec");
+    }
+
+    /*
+     * Install the write end of the pipe into the global variable.
+     */
+
+    pthread_mutex_lock(&notifierMutex);
+    triggerPipe = fds[1];
+
+    /*
+     * Signal any threads that are waiting.
+     */
+
+    pthread_cond_broadcast(&notifierCV);
+    pthread_mutex_unlock(&notifierMutex);
+
+    /*
+     * Look for file events and report them to interested threads.
+     */
+
+    while (1) {
+	FD_ZERO(&readableMask);
+	FD_ZERO(&writableMask);
+	FD_ZERO(&exceptionMask);
+
+	/*
+	 * Compute the logical OR of the masks from all the waiting
+	 * notifiers.
+	 */
+
+	pthread_mutex_lock(&notifierMutex);
+	timePtr = NULL;
+	for (tsdPtr = waitingListPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {
+	    for (i = tsdPtr->numFdBits-1; i >= 0; --i) {
+		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)) {
+		    FD_SET(i, &readableMask);
+		}
+		if (FD_ISSET(i, &tsdPtr->checkMasks.writable)) {
+		    FD_SET(i, &writableMask);
+		}
+		if (FD_ISSET(i, &tsdPtr->checkMasks.exception)) {
+		    FD_SET(i, &exceptionMask);
+		}
+	    }
+	    if (tsdPtr->numFdBits > numFdBits) {
+		numFdBits = tsdPtr->numFdBits;
+	    }
+	    if (tsdPtr->pollState & POLL_WANT) {
+		/*
+		 * Here we make sure we go through select() with the same mask
+		 * bits that were present when the thread tried to poll.
+		 */
+
+		tsdPtr->pollState |= POLL_DONE;
+		timePtr = &poll;
+	    }
+	}
+	pthread_mutex_unlock(&notifierMutex);
+
+	/*
+	 * Set up the mask to include the receive pipe.
+	 */
+
+	if (receivePipe >= numFdBits) {
+	    numFdBits = receivePipe + 1;
+	}
+	FD_SET(receivePipe, &readableMask);
+
+	if (select(numFdBits, &readableMask, &writableMask, &exceptionMask,
+		timePtr) == -1) {
+	    /*
+	     * Try again immediately on an error.
+	     */
+
+	    continue;
+	}
+
+	/*
+	 * Alert any threads that are waiting on a ready file descriptor.
+	 */
+
+	pthread_mutex_lock(&notifierMutex);
+	for (tsdPtr = waitingListPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {
+	    found = 0;
+
+	    for (i = tsdPtr->numFdBits-1; i >= 0; --i) {
+		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)
+			&& FD_ISSET(i, &readableMask)) {
+		    FD_SET(i, &tsdPtr->readyMasks.readable);
+		    found = 1;
+		}
+		if (FD_ISSET(i, &tsdPtr->checkMasks.writable)
+			&& FD_ISSET(i, &writableMask)) {
+		    FD_SET(i, &tsdPtr->readyMasks.writable);
+		    found = 1;
+		}
+		if (FD_ISSET(i, &tsdPtr->checkMasks.exception)
+			&& FD_ISSET(i, &exceptionMask)) {
+		    FD_SET(i, &tsdPtr->readyMasks.exception);
+		    found = 1;
+		}
+	    }
+
+	    if (found || (tsdPtr->pollState & POLL_DONE)) {
+		AlertSingleThread(tsdPtr);
+	    }
+	}
+	pthread_mutex_unlock(&notifierMutex);
+
+	/*
+	 * Consume the next byte from the notifier pipe if the pipe was
+	 * readable. Note that there may be multiple bytes pending, but to
+	 * avoid a race condition we only read one at a time.
+	 */
+
+	do {
+	    i = read(receivePipe, buf, 1);
+	    if (i <= 0) {
+		break;
+	    } else if ((i == 0) || ((i == 1) && (buf[0] == 'q'))) {
+		/*
+		 * Someone closed the write end of the pipe or sent us a Quit
+		 * message [Bug: 4139] and then closed the write end of the
+		 * pipe so we need to shut down the notifier thread.
+		 */
+
+		break;
+	    }
+	} while (1);
+	if ((i == 0) || (buf[0] == 'q')) {
+	    break;
+	}
+    }
+
+    /*
+     * Clean up the read end of the pipe and signal any threads waiting on
+     * termination of the notifier thread.
+     */
+
+    close(receivePipe);
+    pthread_mutex_lock(&notifierMutex);
+    triggerPipe = -1;
+    pthread_cond_broadcast(&notifierCV);
+    pthread_mutex_unlock(&notifierMutex);
+
+    TclpThreadExit(0);
+}
+
+#endif /* TCL_THREADS */
+
+#endif /* !HAVE_COREFOUNDATION */
+
+#endif /* !NOTIFIER_EPOLL && !NOTIFIER_KQUEUE */
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tclUnixChan.c b/unix/tclUnixChan.c
index 6418f48..ced684a 100644
--- a/unix/tclUnixChan.c
+++ b/unix/tclUnixChan.c
@@ -605,7 +605,6 @@ TtySetOptionProc(
 	return TCL_OK;
     }
 
-
     /*
      * Option -handshake none|xonxoff|rtscts|dtrdsr
      */
@@ -706,6 +705,7 @@ TtySetOptionProc(
     /*
      * Option -ttycontrol {DTR 1 RTS 0 BREAK 0}
      */
+
     if ((len > 4) && (strncmp(optionName, "-ttycontrol", len) == 0)) {
 #if defined(TIOCMGET) && defined(TIOCMSET)
 	int i, control, flag;
@@ -882,6 +882,7 @@ TtyGetOptionProc(
      * Option is readonly and returned by [fconfigure chan -ttystatus] but not
      * returned by unnamed [fconfigure chan].
      */
+
     if ((len > 4) && (strncmp(optionName, "-ttystatus", len) == 0)) {
 	int status;
 
@@ -894,12 +895,10 @@ TtyGetOptionProc(
     if (valid) {
 	return TCL_OK;
     }
-    return Tcl_BadChannelOption(interp, optionName, "mode"
-	    " queue ttystatus xchar"
-	    );
+    return Tcl_BadChannelOption(interp, optionName,
+		"mode queue ttystatus xchar");
 }
 
-
 static const struct {int baud; speed_t speed;} speeds[] = {
 #ifdef B0
     {0, B0},
@@ -1023,7 +1022,7 @@ static const struct {int baud; speed_t speed;} speeds[] = {
 #endif
     {-1, 0}
 };
-
+
 /*
  *---------------------------------------------------------------------------
  *
@@ -1315,7 +1314,8 @@ TtyParseMode(
 
 static void
 TtyInit(
-    int fd)	/* Open file descriptor for serial port to be initialized. */
+    int fd)			/* Open file descriptor for serial port to be
+				 * initialized. */
 {
     struct termios iostate;
     tcgetattr(fd, &iostate);
@@ -1325,8 +1325,7 @@ TtyInit(
 	    || iostate.c_lflag != 0
 	    || iostate.c_cflag & CREAD
 	    || iostate.c_cc[VMIN] != 1
-	    || iostate.c_cc[VTIME] != 0)
-    {
+	    || iostate.c_cc[VTIME] != 0) {
 	iostate.c_iflag = IGNBRK;
 	iostate.c_oflag = 0;
 	iostate.c_lflag = 0;
@@ -1726,166 +1725,6 @@ Tcl_GetOpenFile(
     return TCL_ERROR;
 }
 
-#ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
-				 * in tclMacOSXNotify.c */
-/*
- *----------------------------------------------------------------------
- *
- * TclUnixWaitForFile --
- *
- *	This function waits synchronously for a file to become readable or
- *	writable, with an optional timeout.
- *
- * Results:
- *	The return value is an OR'ed combination of TCL_READABLE,
- *	TCL_WRITABLE, and TCL_EXCEPTION, indicating the conditions that are
- *	present on file at the time of the return. This function will not
- *	return until either "timeout" milliseconds have elapsed or at least
- *	one of the conditions given by mask has occurred for file (a return
- *	value of 0 means that a timeout occurred). No normal events will be
- *	serviced during the execution of this function.
- *
- * Side effects:
- *	Time passes.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TclUnixWaitForFile(
-    int fd,			/* Handle for file on which to wait. */
-    int mask,			/* What to wait for: OR'ed combination of
-				 * TCL_READABLE, TCL_WRITABLE, and
-				 * TCL_EXCEPTION. */
-    int timeout)		/* Maximum amount of time to wait for one of
-				 * the conditions in mask to occur, in
-				 * milliseconds. A value of 0 means don't wait
-				 * at all, and a value of -1 means wait
-				 * forever. */
-{
-    Tcl_Time abortTime = {0, 0}, now; /* silence gcc 4 warning */
-    struct timeval blockTime, *timeoutPtr;
-    int numFound, result = 0;
-    fd_set readableMask;
-    fd_set writableMask;
-    fd_set exceptionMask;
-
-#ifndef _DARWIN_C_SOURCE
-    /*
-     * Sanity check fd.
-     */
-
-    if (fd >= FD_SETSIZE) {
-	Tcl_Panic("TclUnixWaitForFile can't handle file id %d", fd);
-	/* must never get here, or select masks overrun will occur below */
-    }
-#endif
-
-    /*
-     * If there is a non-zero finite timeout, compute the time when we give
-     * up.
-     */
-
-    if (timeout > 0) {
-	Tcl_GetTime(&now);
-	abortTime.sec = now.sec + timeout/1000;
-	abortTime.usec = now.usec + (timeout%1000)*1000;
-	if (abortTime.usec >= 1000000) {
-	    abortTime.usec -= 1000000;
-	    abortTime.sec += 1;
-	}
-	timeoutPtr = &blockTime;
-    } else if (timeout == 0) {
-	timeoutPtr = &blockTime;
-	blockTime.tv_sec = 0;
-	blockTime.tv_usec = 0;
-    } else {
-	timeoutPtr = NULL;
-    }
-
-    /*
-     * Initialize the select masks.
-     */
-
-    FD_ZERO(&readableMask);
-    FD_ZERO(&writableMask);
-    FD_ZERO(&exceptionMask);
-
-    /*
-     * Loop in a mini-event loop of our own, waiting for either the file to
-     * become ready or a timeout to occur.
-     */
-
-    while (1) {
-	if (timeout > 0) {
-	    blockTime.tv_sec = abortTime.sec - now.sec;
-	    blockTime.tv_usec = abortTime.usec - now.usec;
-	    if (blockTime.tv_usec < 0) {
-		blockTime.tv_sec -= 1;
-		blockTime.tv_usec += 1000000;
-	    }
-	    if (blockTime.tv_sec < 0) {
-		blockTime.tv_sec = 0;
-		blockTime.tv_usec = 0;
-	    }
-	}
-
-	/*
-	 * Setup the select masks for the fd.
-	 */
-
-	if (mask & TCL_READABLE) {
-	    FD_SET(fd, &readableMask);
-	}
-	if (mask & TCL_WRITABLE) {
-	    FD_SET(fd, &writableMask);
-	}
-	if (mask & TCL_EXCEPTION) {
-	    FD_SET(fd, &exceptionMask);
-	}
-
-	/*
-	 * Wait for the event or a timeout.
-	 */
-
-	numFound = select(fd + 1, &readableMask, &writableMask,
-		&exceptionMask, timeoutPtr);
-	if (numFound == 1) {
-	    if (FD_ISSET(fd, &readableMask)) {
-		SET_BITS(result, TCL_READABLE);
-	    }
-	    if (FD_ISSET(fd, &writableMask)) {
-		SET_BITS(result, TCL_WRITABLE);
-	    }
-	    if (FD_ISSET(fd, &exceptionMask)) {
-		SET_BITS(result, TCL_EXCEPTION);
-	    }
-	    result &= mask;
-	    if (result) {
-		break;
-	    }
-	}
-	if (timeout == 0) {
-	    break;
-	}
-	if (timeout < 0) {
-	    continue;
-	}
-
-	/*
-	 * The select returned early, so we need to recompute the timeout.
-	 */
-
-	Tcl_GetTime(&now);
-	if ((abortTime.sec < now.sec)
-		|| (abortTime.sec==now.sec && abortTime.usec<=now.usec)) {
-	    break;
-	}
-    }
-    return result;
-}
-#endif /* HAVE_COREFOUNDATION */
-
 /*
  *----------------------------------------------------------------------
  *
diff --git a/unix/tclUnixInit.c b/unix/tclUnixInit.c
index 1e35b92..feeffa6 100644
--- a/unix/tclUnixInit.c
+++ b/unix/tclUnixInit.c
@@ -14,11 +14,11 @@
 #ifdef HAVE_LANGINFO
 #   include <langinfo.h>
 #   ifdef __APPLE__
-#       if defined(HAVE_WEAK_IMPORT) && MAC_OS_X_VERSION_MIN_REQUIRED < 1030
+#	if defined(HAVE_WEAK_IMPORT) && MAC_OS_X_VERSION_MIN_REQUIRED < 1030
 	    /* Support for weakly importing nl_langinfo on Darwin. */
 #	    define WEAK_IMPORT_NL_LANGINFO
 	    extern char *nl_langinfo(nl_item) WEAK_IMPORT_ATTRIBUTE;
-#       endif
+#	endif
 #    endif
 #endif
 #include <sys/resource.h>
@@ -34,7 +34,7 @@
 
 #ifdef __CYGWIN__
 DLLIMPORT extern __stdcall unsigned char GetVersionExW(void *);
-DLLIMPORT extern __stdcall void *LoadLibraryW(const void *);
+DLLIMPORT extern __stdcall void *GetModuleHandleW(const void *);
 DLLIMPORT extern __stdcall void FreeLibrary(void *);
 DLLIMPORT extern __stdcall void *GetProcAddress(void *, const char *);
 DLLIMPORT extern __stdcall void GetSystemInfo(void *);
@@ -45,12 +45,12 @@ static const char *const platforms[NUMPLATFORMS] = {
 };
 
 #define NUMPROCESSORS 11
-static const char *const  processors[NUMPROCESSORS] = {
+static const char *const processors[NUMPROCESSORS] = {
     "intel", "mips", "alpha", "ppc", "shx", "arm", "ia64", "alpha64", "msil",
     "amd64", "ia32_on_win64"
 };
 
-typedef struct _SYSTEM_INFO {
+typedef struct {
   union {
     DWORD  dwOemId;
     struct {
@@ -69,7 +69,7 @@ typedef struct _SYSTEM_INFO {
   int      wProcessorRevision;
 } SYSTEM_INFO;
 
-typedef struct _OSVERSIONINFOW {
+typedef struct {
   DWORD dwOSVersionInfoSize;
   DWORD dwMajorVersion;
   DWORD dwMinorVersion;
@@ -737,6 +737,43 @@ Tcl_GetEncodingNameFromEnvironment(
  *----------------------------------------------------------------------
  */
 
+#if defined(HAVE_COREFOUNDATION) && MAC_OS_X_VERSION_MAX_ALLOWED > 1020
+/*
+ * Helper because whether CFLocaleCopyCurrent and CFLocaleGetIdentifier are
+ * strongly or weakly bound varies by version of OSX, triggering warnings.
+ */
+
+static inline void
+InitMacLocaleInfoVar(
+    CFLocaleRef (*localeCopyCurrent)(void),
+    CFStringRef (*localeGetIdentifier)(CFLocaleRef),
+    Tcl_Interp *interp)
+{
+    CFLocaleRef localeRef;
+    CFStringRef locale;
+    char loc[256];
+
+    if (localeCopyCurrent == NULL || localeGetIdentifier == NULL) {
+	return;
+    }
+
+    localeRef = localeCopyCurrent();
+    if (!localeRef) {
+	return;
+    }
+
+    locale = localeGetIdentifier(localeRef);
+    if (locale && CFStringGetCString(locale, loc, 256,
+	    kCFStringEncodingUTF8)) {
+	if (!Tcl_CreateNamespace(interp, "::tcl::mac", NULL, NULL)) {
+	    Tcl_ResetResult(interp);
+	}
+	Tcl_SetVar2(interp, "::tcl::mac::locale", NULL, loc, TCL_GLOBAL_ONLY);
+    }
+    CFRelease(localeRef);
+}
+#endif /*defined(HAVE_COREFOUNDATION) && MAC_OS_X_VERSION_MAX_ALLOWED > 1020*/
+
 void
 TclpSetVariables(
     Tcl_Interp *interp)
@@ -755,29 +792,12 @@ TclpSetVariables(
 #ifdef HAVE_COREFOUNDATION
     char tclLibPath[MAXPATHLEN + 1];
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED > 1020
     /*
      * Set msgcat fallback locale to current CFLocale identifier.
      */
 
-    CFLocaleRef localeRef;
-
-    if (&CFLocaleCopyCurrent != NULL && &CFLocaleGetIdentifier != NULL &&
-	    (localeRef = CFLocaleCopyCurrent())) {
-	CFStringRef locale = CFLocaleGetIdentifier(localeRef);
-
-	if (locale) {
-	    char loc[256];
-
-	    if (CFStringGetCString(locale, loc, 256, kCFStringEncodingUTF8)) {
-		if (!Tcl_CreateNamespace(interp, "::tcl::mac", NULL, NULL)) {
-		    Tcl_ResetResult(interp);
-		}
-		Tcl_SetVar2(interp, "::tcl::mac::locale", NULL, loc, TCL_GLOBAL_ONLY);
-	    }
-	}
-	CFRelease(localeRef);
-    }
+#if MAC_OS_X_VERSION_MAX_ALLOWED > 1020
+    InitMacLocaleInfoVar(CFLocaleCopyCurrent, CFLocaleGetIdentifier, interp);
 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED > 1020 */
 
     if (MacOSXGetLibraryPath(interp, MAXPATHLEN, tclLibPath) == TCL_OK) {
@@ -858,16 +878,13 @@ TclpSetVariables(
 #ifdef __CYGWIN__
 	unameOK = 1;
     if (!osInfoInitialized) {
-	HANDLE handle = LoadLibraryW(L"NTDLL");
+	HANDLE handle = GetModuleHandleW(L"NTDLL");
 	int(__stdcall *getversion)(void *) =
 		(int(__stdcall *)(void *))GetProcAddress(handle, "RtlGetVersion");
 	osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
 	if (!getversion || getversion(&osInfo)) {
 	    GetVersionExW(&osInfo);
 	}
-	if (handle) {
-	    FreeLibrary(handle);
-	}
 	osInfoInitialized = 1;
     }
 
@@ -1025,7 +1042,6 @@ TclpFindVariable(
     return result;
 }
 
-
 /*
  *----------------------------------------------------------------------
  *
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index e37962d..5bc753a 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -1,262 +1,33 @@
 /*
  * tclUnixNotfy.c --
  *
- *	This file contains the implementation of the select()-based
- *	Unix-specific notifier, which is the lowest-level part of the Tcl
- *	event loop. This file works together with generic/tclNotify.c.
+ *	This file contains subroutines shared by all notifier backend
+ *	implementations on *nix platforms.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
+ * Copyright (c) 2016 Lucio Andrés Illanes Albornoz <l.illanes@gmx.de>
  *
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
-#include "tclInt.h"
-#ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
-				 * in tclMacOSXNotify.c */
-#include <signal.h>
-
-/*
- * This structure is used to keep track of the notifier info for a registered
- * file.
- */
-
-typedef struct FileHandler {
-    int fd;
-    int mask;			/* Mask of desired events: TCL_READABLE,
-				 * etc. */
-    int readyMask;		/* Mask of events that have been seen since
-				 * the last time file handlers were invoked
-				 * for this file. */
-    Tcl_FileProc *proc;		/* Function to call, in the style of
-				 * Tcl_CreateFileHandler. */
-    ClientData clientData;	/* Argument to pass to proc. */
-    struct FileHandler *nextPtr;/* Next in list of all files we care about. */
-} FileHandler;
-
-/*
- * The following structure is what is added to the Tcl event queue when file
- * handlers are ready to fire.
- */
-
-typedef struct {
-    Tcl_Event header;		/* Information that is standard for all
-				 * events. */
-    int fd;			/* File descriptor that is ready. Used to find
-				 * the FileHandler structure for the file
-				 * (can't point directly to the FileHandler
-				 * structure because it could go away while
-				 * the event is queued). */
-} FileHandlerEvent;
-
-/*
- * The following structure contains a set of select() masks to track readable,
- * writable, and exception conditions.
- */
-
-typedef struct {
-    fd_set readable;
-    fd_set writable;
-    fd_set exception;
-} SelectMasks;
-
-/*
- * The following static structure contains the state information for the
- * select based implementation of the Tcl notifier. One of these structures is
- * created for each thread that is using the notifier.
- */
-
-typedef struct ThreadSpecificData {
-    FileHandler *firstFileHandlerPtr;
-				/* Pointer to head of file handler list. */
-    SelectMasks checkMasks;	/* This structure is used to build up the
-				 * masks to be used in the next call to
-				 * select. Bits are set in response to calls
-				 * to Tcl_CreateFileHandler. */
-    SelectMasks readyMasks;	/* This array reflects the readable/writable
-				 * conditions that were found to exist by the
-				 * last call to select. */
-    int numFdBits;		/* Number of valid bits in checkMasks (one
-				 * more than highest fd for which
-				 * Tcl_WatchFile has been called). */
-#ifdef TCL_THREADS
-    int onList;			/* True if it is in this list */
-    unsigned int pollState;	/* pollState is used to implement a polling
-				 * handshake between each thread and the
-				 * notifier thread. Bits defined below. */
-    struct ThreadSpecificData *nextPtr, *prevPtr;
-				/* All threads that are currently waiting on
-				 * an event have their ThreadSpecificData
-				 * structure on a doubly-linked listed formed
-				 * from these pointers. You must hold the
-				 * notifierMutex lock before accessing these
-				 * fields. */
-#ifdef __CYGWIN__
-    void *event;     /* Any other thread alerts a notifier
-	 * that an event is ready to be processed
-	 * by sending this event. */
-    void *hwnd;			/* Messaging window. */
-#else /* !__CYGWIN__ */
-    pthread_cond_t waitCV;	/* Any other thread alerts a notifier that an
-				 * event is ready to be processed by signaling
-				 * this condition variable. */
-#endif /* __CYGWIN__ */
-    int waitCVinitialized;	/* Variable to flag initialization of the structure */
-    int eventReady;		/* True if an event is ready to be processed.
-				 * Used as condition flag together with waitCV
-				 * above. */
-#endif /* TCL_THREADS */
-} ThreadSpecificData;
-
-static Tcl_ThreadDataKey dataKey;
-
-#ifdef TCL_THREADS
-/*
- * The following static indicates the number of threads that have initialized
- * notifiers.
- *
- * You must hold the notifierMutex lock before accessing this variable.
- */
-
-static int notifierCount = 0;
-
-/*
- * The following variable points to the head of a doubly-linked list of
- * ThreadSpecificData structures for all threads that are currently waiting on
- * an event.
- *
- * You must hold the notifierMutex lock before accessing this list.
- */
-
-static ThreadSpecificData *waitingListPtr = NULL;
-
-/*
- * The notifier thread spends all its time in select() waiting for a file
- * descriptor associated with one of the threads on the waitingListPtr list to
- * do something interesting. But if the contents of the waitingListPtr list
- * ever changes, we need to wake up and restart the select() system call. You
- * can wake up the notifier thread by writing a single byte to the file
- * descriptor defined below. This file descriptor is the input-end of a pipe
- * and the notifier thread is listening for data on the output-end of the same
- * pipe. Hence writing to this file descriptor will cause the select() system
- * call to return and wake up the notifier thread.
- *
- * You must hold the notifierMutex lock before writing to the pipe.
- */
-
-static int triggerPipe = -1;
-
-/*
- * The notifierMutex locks access to all of the global notifier state.
- */
-
-static pthread_mutex_t notifierInitMutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t notifierMutex     = PTHREAD_MUTEX_INITIALIZER;
-/*
- * The following static indicates if the notifier thread is running.
- *
- * You must hold the notifierInitMutex before accessing this variable.
- */
-
-static int notifierThreadRunning = 0;
-
-/*
- * The notifier thread signals the notifierCV when it has finished
- * initializing the triggerPipe and right before the notifier thread
- * terminates.
- */
-
-static pthread_cond_t notifierCV = PTHREAD_COND_INITIALIZER;
-
-/*
- * The pollState bits
- *	POLL_WANT is set by each thread before it waits on its condition
- *		variable. It is checked by the notifier before it does select.
- *	POLL_DONE is set by the notifier if it goes into select after seeing
- *		POLL_WANT. The idea is to ensure it tries a select with the
- *		same bits the initial thread had set.
- */
-
-#define POLL_WANT	0x1
-#define POLL_DONE	0x2
-
-/*
- * This is the thread ID of the notifier thread that does select.
- */
-
-static Tcl_ThreadId notifierThread;
-
-#endif /* TCL_THREADS */
+#include <poll.h>
 
 /*
  * Static routines defined in this file.
  */
 
+#ifdef NOTIFIER_SELECT
 #ifdef TCL_THREADS
-static void	NotifierThreadProc(ClientData clientData);
+static TCL_NORETURN void NotifierThreadProc(ClientData clientData);
 #if defined(HAVE_PTHREAD_ATFORK)
-static int	atForkInit = 0;
 static void	AtForkChild(void);
 #endif /* HAVE_PTHREAD_ATFORK */
 #endif /* TCL_THREADS */
+#endif /* NOTIFIER_SELECT */
 static int	FileHandlerEventProc(Tcl_Event *evPtr, int flags);
 
-/*
- * Import of Windows API when building threaded with Cygwin.
- */
-
-#if defined(TCL_THREADS) && defined(__CYGWIN__)
-typedef struct {
-    void *hwnd;
-    unsigned int *message;
-    int wParam;
-    int lParam;
-    int time;
-    int x;
-    int y;
-} MSG;
-
-typedef struct {
-    unsigned int style;
-    void *lpfnWndProc;
-    int cbClsExtra;
-    int cbWndExtra;
-    void *hInstance;
-    void *hIcon;
-    void *hCursor;
-    void *hbrBackground;
-    void *lpszMenuName;
-    const void *lpszClassName;
-} WNDCLASS;
-
-extern void __stdcall	CloseHandle(void *);
-extern void *__stdcall	CreateEventW(void *, unsigned char, unsigned char,
-			    void *);
-extern void * __stdcall	CreateWindowExW(void *, const void *, const void *,
-			    DWORD, int, int, int, int, void *, void *, void *, void *);
-extern DWORD __stdcall	DefWindowProcW(void *, int, void *, void *);
-extern unsigned char __stdcall	DestroyWindow(void *);
-extern int __stdcall	DispatchMessageW(const MSG *);
-extern unsigned char __stdcall	GetMessageW(MSG *, void *, int, int);
-extern void __stdcall	MsgWaitForMultipleObjects(DWORD, void *,
-			    unsigned char, DWORD, DWORD);
-extern unsigned char __stdcall	PeekMessageW(MSG *, void *, int, int, int);
-extern unsigned char __stdcall	PostMessageW(void *, unsigned int, void *,
-				    void *);
-extern void __stdcall	PostQuitMessage(int);
-extern void *__stdcall	RegisterClassW(const WNDCLASS *);
-extern unsigned char __stdcall	ResetEvent(void *);
-extern unsigned char __stdcall	TranslateMessage(const MSG *);
-
-/*
- * Threaded-cygwin specific constants and functions in this file:
- */
-
-static const WCHAR className[] = L"TclNotifier";
-static DWORD __stdcall	NotifierProc(void *hwnd, unsigned int message,
-			    void *wParam, void *lParam);
-#endif /* TCL_THREADS && __CYGWIN__ */
-
+#ifdef NOTIFIER_SELECT
 #if TCL_THREADS
 /*
  *----------------------------------------------------------------------
@@ -300,168 +71,7 @@ StartNotifierThread(const char *proc)
     }
 }
 #endif /* TCL_THREADS */
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_InitNotifier --
- *
- *	Initializes the platform specific notifier state.
- *
- * Results:
- *	Returns a handle to the notifier state for this thread.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-ClientData
-Tcl_InitNotifier(void)
-{
-    if (tclNotifierHooks.initNotifierProc) {
-	return tclNotifierHooks.initNotifierProc();
-    } else {
-	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-
-#ifdef TCL_THREADS
-	tsdPtr->eventReady = 0;
-
-	/*
-	 * Initialize thread specific condition variable for this thread.
-	 */
-	if (tsdPtr->waitCVinitialized == 0) {
-#ifdef __CYGWIN__
-	    WNDCLASS class;
-
-	    class.style = 0;
-	    class.cbClsExtra = 0;
-	    class.cbWndExtra = 0;
-	    class.hInstance = TclWinGetTclInstance();
-	    class.hbrBackground = NULL;
-	    class.lpszMenuName = NULL;
-	    class.lpszClassName = className;
-	    class.lpfnWndProc = NotifierProc;
-	    class.hIcon = NULL;
-	    class.hCursor = NULL;
-
-	    RegisterClassW(&class);
-	    tsdPtr->hwnd = CreateWindowExW(NULL, class.lpszClassName,
-		    class.lpszClassName, 0, 0, 0, 0, 0, NULL, NULL,
-		    TclWinGetTclInstance(), NULL);
-	    tsdPtr->event = CreateEventW(NULL, 1 /* manual */,
-		    0 /* !signaled */, NULL);
-#else
-	    pthread_cond_init(&tsdPtr->waitCV, NULL);
-#endif /* __CYGWIN__ */
-	    tsdPtr->waitCVinitialized = 1;
-	}
-
-	pthread_mutex_lock(&notifierInitMutex);
-#if defined(HAVE_PTHREAD_ATFORK)
-	/*
-	 * Install pthread_atfork handlers to clean up the notifier in the
-	 * child of a fork.
-	 */
-
-	if (!atForkInit) {
-	    int result = pthread_atfork(NULL, NULL, AtForkChild);
-
-	    if (result) {
-		Tcl_Panic("Tcl_InitNotifier: pthread_atfork failed");
-	    }
-	    atForkInit = 1;
-	}
-#endif /* HAVE_PTHREAD_ATFORK */
-
-	notifierCount++;
-
-	pthread_mutex_unlock(&notifierInitMutex);
-
-#endif /* TCL_THREADS */
-	return tsdPtr;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_FinalizeNotifier --
- *
- *	This function is called to cleanup the notifier state before a thread
- *	is terminated.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	May terminate the background notifier thread if this is the last
- *	notifier instance.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_FinalizeNotifier(
-    ClientData clientData)		/* Not used. */
-{
-    if (tclNotifierHooks.finalizeNotifierProc) {
-	tclNotifierHooks.finalizeNotifierProc(clientData);
-	return;
-    } else {
-#ifdef TCL_THREADS
-	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-
-	pthread_mutex_lock(&notifierInitMutex);
-	notifierCount--;
-
-	/*
-	 * If this is the last thread to use the notifier, close the notifier
-	 * pipe and wait for the background thread to terminate.
-	 */
-
-	if (notifierCount == 0) {
-
-	    if (triggerPipe != -1) {
-		if (write(triggerPipe, "q", 1) != 1) {
-		    Tcl_Panic("Tcl_FinalizeNotifier: %s",
-			    "unable to write q to triggerPipe");
-		}
-		close(triggerPipe);
-		pthread_mutex_lock(&notifierMutex);
-		while(triggerPipe != -1) {
-		    pthread_cond_wait(&notifierCV, &notifierMutex);
-		}
-		pthread_mutex_unlock(&notifierMutex);
-		if (notifierThreadRunning) {
-		    int result = pthread_join((pthread_t) notifierThread, NULL);
-
-		    if (result) {
-			Tcl_Panic("Tcl_FinalizeNotifier: unable to join notifier "
-				"thread");
-		    }
-		    notifierThreadRunning = 0;
-		}
-	    }
-	}
-
-	/*
-	 * Clean up any synchronization objects in the thread local storage.
-	 */
-
-#ifdef __CYGWIN__
-	DestroyWindow(tsdPtr->hwnd);
-	CloseHandle(tsdPtr->event);
-#else /* __CYGWIN__ */
-	pthread_cond_destroy(&tsdPtr->waitCV);
-#endif /* __CYGWIN__ */
-	tsdPtr->waitCVinitialized = 0;
-
-	pthread_mutex_unlock(&notifierInitMutex);
-#endif /* TCL_THREADS */
-    }
-}
+#endif /* NOTIFIER_SELECT */
 
 /*
  *----------------------------------------------------------------------
@@ -477,7 +87,13 @@ Tcl_FinalizeNotifier(
  *	None.
  *
  * Side effects:
- *	Signals the notifier condition variable for the specified notifier.
+ *	select(2) notifier:
+ *		signals the notifier condition variable for the specified
+ *		notifier.
+ *	epoll(7) notifier:
+ *		write(2)s to the eventfd(2) of the specified thread.
+ *	kqueue(2) notifier:
+ *		write(2)s to the trigger pipe(2) of the specified thread.
  *
  *----------------------------------------------------------------------
  */
@@ -490,6 +106,7 @@ Tcl_AlertNotifier(
 	tclNotifierHooks.alertNotifierProc(clientData);
 	return;
     } else {
+#ifdef NOTIFIER_SELECT
 #ifdef TCL_THREADS
 	ThreadSpecificData *tsdPtr = clientData;
 
@@ -503,6 +120,21 @@ Tcl_AlertNotifier(
 #   endif /* __CYGWIN__ */
 	pthread_mutex_unlock(&notifierMutex);
 #endif /* TCL_THREADS */
+#else
+	ThreadSpecificData *tsdPtr = clientData;
+#if defined(NOTIFIER_EPOLL) && defined(HAVE_EVENTFD)
+	uint64_t eventFdVal = 1;
+	if (write(tsdPtr->triggerEventFd, &eventFdVal,
+		sizeof(eventFdVal)) != sizeof(eventFdVal)) {
+	    Tcl_Panic("Tcl_AlertNotifier: unable to write to %p->triggerEventFd",
+		(void *)tsdPtr);
+#else
+	if (write(tsdPtr->triggerPipe[1], "", 1) != 1) {
+	    Tcl_Panic("Tcl_AlertNotifier: unable to write to %p->triggerPipe",
+		(void *)tsdPtr);
+#endif /* NOTIFIER_EPOLL && HAVE_EVENTFD */
+	}
+#endif /* NOTIFIER_SELECT */
     }
 }
 
@@ -565,173 +197,11 @@ Tcl_ServiceModeHook(
 	tclNotifierHooks.serviceModeHookProc(mode);
 	return;
     } else if (mode == TCL_SERVICE_ALL) {
+#ifdef NOTIFIER_SELECT
 #if TCL_THREADS
 	StartNotifierThread("Tcl_ServiceModeHook");
 #endif
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_CreateFileHandler --
- *
- *	This function registers a file handler with the select notifier.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Creates a new file handler structure.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_CreateFileHandler(
-    int fd,			/* Handle of stream to watch. */
-    int mask,			/* OR'ed combination of TCL_READABLE,
-				 * TCL_WRITABLE, and TCL_EXCEPTION: indicates
-				 * conditions under which proc should be
-				 * called. */
-    Tcl_FileProc *proc,		/* Function to call for each selected
-				 * event. */
-    ClientData clientData)	/* Arbitrary data to pass to proc. */
-{
-    if (tclNotifierHooks.createFileHandlerProc) {
-	tclNotifierHooks.createFileHandlerProc(fd, mask, proc, clientData);
-	return;
-    } else {
-	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-	FileHandler *filePtr;
-
-	for (filePtr = tsdPtr->firstFileHandlerPtr; filePtr != NULL;
-		filePtr = filePtr->nextPtr) {
-	    if (filePtr->fd == fd) {
-		break;
-	    }
-	}
-	if (filePtr == NULL) {
-	    filePtr = ckalloc(sizeof(FileHandler));
-	    filePtr->fd = fd;
-	    filePtr->readyMask = 0;
-	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
-	    tsdPtr->firstFileHandlerPtr = filePtr;
-	}
-	filePtr->proc = proc;
-	filePtr->clientData = clientData;
-	filePtr->mask = mask;
-
-	/*
-	 * Update the check masks for this file.
-	 */
-
-	if (mask & TCL_READABLE) {
-	    FD_SET(fd, &tsdPtr->checkMasks.readable);
-	} else {
-	    FD_CLR(fd, &tsdPtr->checkMasks.readable);
-	}
-	if (mask & TCL_WRITABLE) {
-	    FD_SET(fd, &tsdPtr->checkMasks.writable);
-	} else {
-	    FD_CLR(fd, &tsdPtr->checkMasks.writable);
-	}
-	if (mask & TCL_EXCEPTION) {
-	    FD_SET(fd, &tsdPtr->checkMasks.exception);
-	} else {
-	    FD_CLR(fd, &tsdPtr->checkMasks.exception);
-	}
-	if (tsdPtr->numFdBits <= fd) {
-	    tsdPtr->numFdBits = fd+1;
-	}
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DeleteFileHandler --
- *
- *	Cancel a previously-arranged callback arrangement for a file.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	If a callback was previously registered on file, remove it.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_DeleteFileHandler(
-    int fd)			/* Stream id for which to remove callback
-				 * function. */
-{
-    if (tclNotifierHooks.deleteFileHandlerProc) {
-	tclNotifierHooks.deleteFileHandlerProc(fd);
-	return;
-    } else {
-	FileHandler *filePtr, *prevPtr;
-	int i;
-	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-
-	/*
-	 * Find the entry for the given file (and return if there isn't one).
-	 */
-
-	for (prevPtr = NULL, filePtr = tsdPtr->firstFileHandlerPtr; ;
-		prevPtr = filePtr, filePtr = filePtr->nextPtr) {
-	    if (filePtr == NULL) {
-		return;
-	    }
-	    if (filePtr->fd == fd) {
-		break;
-	    }
-	}
-
-	/*
-	 * Update the check masks for this file.
-	 */
-
-	if (filePtr->mask & TCL_READABLE) {
-	    FD_CLR(fd, &tsdPtr->checkMasks.readable);
-	}
-	if (filePtr->mask & TCL_WRITABLE) {
-	    FD_CLR(fd, &tsdPtr->checkMasks.writable);
-	}
-	if (filePtr->mask & TCL_EXCEPTION) {
-	    FD_CLR(fd, &tsdPtr->checkMasks.exception);
-	}
-
-	/*
-	 * Find current max fd.
-	 */
-
-	if (fd+1 == tsdPtr->numFdBits) {
-	    int numFdBits = 0;
-
-	    for (i = fd-1; i >= 0; i--) {
-		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)
-			|| FD_ISSET(i, &tsdPtr->checkMasks.writable)
-			|| FD_ISSET(i, &tsdPtr->checkMasks.exception)) {
-		    numFdBits = i+1;
-		    break;
-		}
-	    }
-	    tsdPtr->numFdBits = numFdBits;
-	}
-
-	/*
-	 * Clean up information in the callback record.
-	 */
-
-	if (prevPtr == NULL) {
-	    tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
-	} else {
-	    prevPtr->nextPtr = filePtr->nextPtr;
-	}
-	ckfree(filePtr);
+#endif /* NOTIFIER_SELECT */
     }
 }
 
@@ -809,538 +279,56 @@ FileHandlerEventProc(
     return 1;
 }
 
-#if defined(TCL_THREADS) && defined(__CYGWIN__)
-
-static DWORD __stdcall
-NotifierProc(
-    void *hwnd,
-    unsigned int message,
-    void *wParam,
-    void *lParam)
-{
-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-
-    if (message != 1024) {
-	return DefWindowProcW(hwnd, message, wParam, lParam);
-    }
-
-    /*
-     * Process all of the runnable events.
-     */
-
-    tsdPtr->eventReady = 1;
-    Tcl_ServiceAll();
-    return 0;
-}
-#endif /* TCL_THREADS && __CYGWIN__ */
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_WaitForEvent --
- *
- *	This function is called by Tcl_DoOneEvent to wait for new events on
- *	the message queue. If the block time is 0, then Tcl_WaitForEvent just
- *	polls without blocking.
- *
- * Results:
- *	Returns -1 if the select would block forever, otherwise returns 0.
- *
- * Side effects:
- *	Queues file events that are detected by the select.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_WaitForEvent(
-    const Tcl_Time *timePtr)		/* Maximum block time, or NULL. */
-{
-    if (tclNotifierHooks.waitForEventProc) {
-	return tclNotifierHooks.waitForEventProc(timePtr);
-    } else {
-	FileHandler *filePtr;
-	int mask;
-	Tcl_Time vTime;
-#ifdef TCL_THREADS
-	int waitForFiles;
-#   ifdef __CYGWIN__
-	MSG msg;
-#   endif /* __CYGWIN__ */
-#else
-	/*
-	 * Impl. notes: timeout & timeoutPtr are used if, and only if threads
-	 * are not enabled. They are the arguments for the regular select()
-	 * used when the core is not thread-enabled.
-	 */
-
-	struct timeval timeout, *timeoutPtr;
-	int numFound;
-#endif /* TCL_THREADS */
-	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-
-	/*
-	 * Set up the timeout structure. Note that if there are no events to
-	 * check for, we return with a negative result rather than blocking
-	 * forever.
-	 */
-
-	if (timePtr != NULL) {
-	    /*
-	     * TIP #233 (Virtualized Time). Is virtual time in effect? And do
-	     * we actually have something to scale? If yes to both then we
-	     * call the handler to do this scaling.
-	     */
-
-	    if (timePtr->sec != 0 || timePtr->usec != 0) {
-		vTime = *timePtr;
-		tclScaleTimeProcPtr(&vTime, tclTimeClientData);
-		timePtr = &vTime;
-	    }
-#ifndef TCL_THREADS
-	    timeout.tv_sec = timePtr->sec;
-	    timeout.tv_usec = timePtr->usec;
-	    timeoutPtr = &timeout;
-	} else if (tsdPtr->numFdBits == 0) {
-	    /*
-	     * If there are no threads, no timeout, and no fds registered,
-	     * then there are no events possible and we must avoid deadlock.
-	     * Note that this is not entirely correct because there might be a
-	     * signal that could interrupt the select call, but we don't
-	     * handle that case if we aren't using threads.
-	     */
-
-	    return -1;
-	} else {
-	    timeoutPtr = NULL;
-#endif /* !TCL_THREADS */
-	}
-
-#ifdef TCL_THREADS
-	/*
-	 * Start notifier thread and place this thread on the list of
-	 * interested threads, signal the notifier thread, and wait for a
-	 * response or a timeout.
-	 */
-	StartNotifierThread("Tcl_WaitForEvent");
-
-	pthread_mutex_lock(&notifierMutex);
-
-	if (timePtr != NULL && timePtr->sec == 0 && (timePtr->usec == 0
-#if defined(__APPLE__) && defined(__LP64__)
-		/*
-		 * On 64-bit Darwin, pthread_cond_timedwait() appears to have
-		 * a bug that causes it to wait forever when passed an
-		 * absolute time which has already been exceeded by the system
-		 * time; as a workaround, when given a very brief timeout,
-		 * just do a poll. [Bug 1457797]
-		 */
-		|| timePtr->usec < 10
-#endif /* __APPLE__ && __LP64__ */
-		)) {
-	    /*
-	     * Cannot emulate a polling select with a polling condition
-	     * variable. Instead, pretend to wait for files and tell the
-	     * notifier thread what we are doing. The notifier thread makes
-	     * sure it goes through select with its select mask in the same
-	     * state as ours currently is. We block until that happens.
-	     */
-
-	    waitForFiles = 1;
-	    tsdPtr->pollState = POLL_WANT;
-	    timePtr = NULL;
-	} else {
-	    waitForFiles = (tsdPtr->numFdBits > 0);
-	    tsdPtr->pollState = 0;
-	}
-
-	if (waitForFiles) {
-	    /*
-	     * Add the ThreadSpecificData structure of this thread to the list
-	     * of ThreadSpecificData structures of all threads that are
-	     * waiting on file events.
-	     */
-
-	    tsdPtr->nextPtr = waitingListPtr;
-	    if (waitingListPtr) {
-		waitingListPtr->prevPtr = tsdPtr;
-	    }
-	    tsdPtr->prevPtr = 0;
-	    waitingListPtr = tsdPtr;
-	    tsdPtr->onList = 1;
-
-	    if ((write(triggerPipe, "", 1) == -1) && (errno != EAGAIN)) {
-		Tcl_Panic("Tcl_WaitForEvent: %s",
-			"unable to write to triggerPipe");
-	    }
-	}
-
-	FD_ZERO(&tsdPtr->readyMasks.readable);
-	FD_ZERO(&tsdPtr->readyMasks.writable);
-	FD_ZERO(&tsdPtr->readyMasks.exception);
-
-	if (!tsdPtr->eventReady) {
-#ifdef __CYGWIN__
-	    if (!PeekMessageW(&msg, NULL, 0, 0, 0)) {
-		DWORD timeout;
-
-		if (timePtr) {
-		    timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
-		} else {
-		    timeout = 0xFFFFFFFF;
-		}
-		pthread_mutex_unlock(&notifierMutex);
-		MsgWaitForMultipleObjects(1, &tsdPtr->event, 0, timeout, 1279);
-		pthread_mutex_lock(&notifierMutex);
-	    }
-#else
-	    if (timePtr != NULL) {
-	       Tcl_Time now;
-	       struct timespec ptime;
-
-	       Tcl_GetTime(&now);
-	       ptime.tv_sec = timePtr->sec + now.sec + (timePtr->usec + now.usec) / 1000000;
-	       ptime.tv_nsec = 1000 * ((timePtr->usec + now.usec) % 1000000);
-
-	       pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex, &ptime);
-	    } else {
-	       pthread_cond_wait(&tsdPtr->waitCV, &notifierMutex);
-	    }
-#endif /* __CYGWIN__ */
-	}
-	tsdPtr->eventReady = 0;
-
-#ifdef __CYGWIN__
-	while (PeekMessageW(&msg, NULL, 0, 0, 0)) {
-	    /*
-	     * Retrieve and dispatch the message.
-	     */
-
-	    DWORD result = GetMessageW(&msg, NULL, 0, 0);
-
-	    if (result == 0) {
-		PostQuitMessage(msg.wParam);
-		/* What to do here? */
-	    } else if (result != (DWORD) -1) {
-		TranslateMessage(&msg);
-		DispatchMessageW(&msg);
-	    }
-	}
-	ResetEvent(tsdPtr->event);
-#endif /* __CYGWIN__ */
-
-	if (waitForFiles && tsdPtr->onList) {
-	    /*
-	     * Remove the ThreadSpecificData structure of this thread from the
-	     * waiting list. Alert the notifier thread to recompute its select
-	     * masks - skipping this caused a hang when trying to close a pipe
-	     * which the notifier thread was still doing a select on.
-	     */
-
-	    if (tsdPtr->prevPtr) {
-		tsdPtr->prevPtr->nextPtr = tsdPtr->nextPtr;
-	    } else {
-		waitingListPtr = tsdPtr->nextPtr;
-	    }
-	    if (tsdPtr->nextPtr) {
-		tsdPtr->nextPtr->prevPtr = tsdPtr->prevPtr;
-	    }
-	    tsdPtr->nextPtr = tsdPtr->prevPtr = NULL;
-	    tsdPtr->onList = 0;
-	    if ((write(triggerPipe, "", 1) == -1) && (errno != EAGAIN)) {
-		Tcl_Panic("Tcl_WaitForEvent: %s",
-			"unable to write to triggerPipe");
-	    }
-	}
-
-#else
-	tsdPtr->readyMasks = tsdPtr->checkMasks;
-	numFound = select(tsdPtr->numFdBits, &tsdPtr->readyMasks.readable,
-		&tsdPtr->readyMasks.writable, &tsdPtr->readyMasks.exception,
-		timeoutPtr);
-
-	/*
-	 * Some systems don't clear the masks after an error, so we have to do
-	 * it here.
-	 */
-
-	if (numFound == -1) {
-	    FD_ZERO(&tsdPtr->readyMasks.readable);
-	    FD_ZERO(&tsdPtr->readyMasks.writable);
-	    FD_ZERO(&tsdPtr->readyMasks.exception);
-	}
-#endif /* TCL_THREADS */
-
-	/*
-	 * Queue all detected file events before returning.
-	 */
-
-	for (filePtr = tsdPtr->firstFileHandlerPtr; (filePtr != NULL);
-		filePtr = filePtr->nextPtr) {
-	    mask = 0;
-	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.readable)) {
-		mask |= TCL_READABLE;
-	    }
-	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.writable)) {
-		mask |= TCL_WRITABLE;
-	    }
-	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.exception)) {
-		mask |= TCL_EXCEPTION;
-	    }
-
-	    if (!mask) {
-		continue;
-	    }
-
-	    /*
-	     * Don't bother to queue an event if the mask was previously
-	     * non-zero since an event must still be on the queue.
-	     */
-
-	    if (filePtr->readyMask == 0) {
-		FileHandlerEvent *fileEvPtr =
-			ckalloc(sizeof(FileHandlerEvent));
-
-		fileEvPtr->header.proc = FileHandlerEventProc;
-		fileEvPtr->fd = filePtr->fd;
-		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
-	    }
-	    filePtr->readyMask = mask;
-	}
-#ifdef TCL_THREADS
-	pthread_mutex_unlock(&notifierMutex);
-#endif /* TCL_THREADS */
-	return 0;
-    }
-}
-
+#ifdef NOTIFIER_SELECT
 #ifdef TCL_THREADS
 /*
  *----------------------------------------------------------------------
  *
- * NotifierThreadProc --
+ * AlertSingleThread --
  *
- *	This routine is the initial (and only) function executed by the
- *	special notifier thread. Its job is to wait for file descriptors to
- *	become readable or writable or to have an exception condition and then
- *	to notify other threads who are interested in this information by
- *	signalling a condition variable. Other threads can signal this
- *	notifier thread of a change in their interests by writing a single
- *	byte to a special pipe that the notifier thread is monitoring.
+ *	Notify a single thread that is waiting on a file descriptor to become
+ *	readable or writable or to have an exception condition.
+ *	notifierMutex must be held.
  *
  * Result:
- *	None. Once started, this routine never exits. It dies with the overall
- *	process.
+ *	None.
  *
  * Side effects:
- *	The trigger pipe used to signal the notifier thread is created when
- *	the notifier thread first starts.
+ *	The condition variable associated with the thread is broadcasted.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-NotifierThreadProc(
-    ClientData clientData)	/* Not used. */
+AlertSingleThread(
+	ThreadSpecificData *tsdPtr)
 {
-    ThreadSpecificData *tsdPtr;
-    fd_set readableMask;
-    fd_set writableMask;
-    fd_set exceptionMask;
-    int fds[2];
-    int i, numFdBits = 0, receivePipe;
-    long found;
-    struct timeval poll = {0., 0.}, *timePtr;
-    char buf[2];
-
-    if (pipe(fds) != 0) {
-	Tcl_Panic("NotifierThreadProc: %s", "could not create trigger pipe");
-    }
-
-    receivePipe = fds[0];
-
-    if (TclUnixSetBlockingMode(receivePipe, TCL_MODE_NONBLOCKING) < 0) {
-	Tcl_Panic("NotifierThreadProc: %s",
-		"could not make receive pipe non blocking");
-    }
-    if (TclUnixSetBlockingMode(fds[1], TCL_MODE_NONBLOCKING) < 0) {
-	Tcl_Panic("NotifierThreadProc: %s",
-		"could not make trigger pipe non blocking");
-    }
-    if (fcntl(receivePipe, F_SETFD, FD_CLOEXEC) < 0) {
-	Tcl_Panic("NotifierThreadProc: %s",
-		"could not make receive pipe close-on-exec");
-    }
-    if (fcntl(fds[1], F_SETFD, FD_CLOEXEC) < 0) {
-	Tcl_Panic("NotifierThreadProc: %s",
-		"could not make trigger pipe close-on-exec");
+    tsdPtr->eventReady = 1;
+    if (tsdPtr->onList) {
+        /*
+         * Remove the ThreadSpecificData structure of this thread
+         * from the waiting list. This prevents us from
+         * continuously spinning on epoll_wait until the other
+         * threads runs and services the file event.
+         */
+
+        if (tsdPtr->prevPtr) {
+    	    tsdPtr->prevPtr->nextPtr = tsdPtr->nextPtr;
+        } else {
+    	    waitingListPtr = tsdPtr->nextPtr;
+        }
+        if (tsdPtr->nextPtr) {
+    	    tsdPtr->nextPtr->prevPtr = tsdPtr->prevPtr;
+        }
+        tsdPtr->nextPtr = tsdPtr->prevPtr = NULL;
+        tsdPtr->onList = 0;
+        tsdPtr->pollState = 0;
     }
-
-    /*
-     * Install the write end of the pipe into the global variable.
-     */
-
-    pthread_mutex_lock(&notifierMutex);
-    triggerPipe = fds[1];
-
-    /*
-     * Signal any threads that are waiting.
-     */
-
-    pthread_cond_broadcast(&notifierCV);
-    pthread_mutex_unlock(&notifierMutex);
-
-    /*
-     * Look for file events and report them to interested threads.
-     */
-
-    while (1) {
-	FD_ZERO(&readableMask);
-	FD_ZERO(&writableMask);
-	FD_ZERO(&exceptionMask);
-
-	/*
-	 * Compute the logical OR of the select masks from all the waiting
-	 * notifiers.
-	 */
-
-	pthread_mutex_lock(&notifierMutex);
-	timePtr = NULL;
-	for (tsdPtr = waitingListPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {
-	    for (i = tsdPtr->numFdBits-1; i >= 0; --i) {
-		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)) {
-		    FD_SET(i, &readableMask);
-		}
-		if (FD_ISSET(i, &tsdPtr->checkMasks.writable)) {
-		    FD_SET(i, &writableMask);
-		}
-		if (FD_ISSET(i, &tsdPtr->checkMasks.exception)) {
-		    FD_SET(i, &exceptionMask);
-		}
-	    }
-	    if (tsdPtr->numFdBits > numFdBits) {
-		numFdBits = tsdPtr->numFdBits;
-	    }
-	    if (tsdPtr->pollState & POLL_WANT) {
-		/*
-		 * Here we make sure we go through select() with the same mask
-		 * bits that were present when the thread tried to poll.
-		 */
-
-		tsdPtr->pollState |= POLL_DONE;
-		timePtr = &poll;
-	    }
-	}
-	pthread_mutex_unlock(&notifierMutex);
-
-	/*
-	 * Set up the select mask to include the receive pipe.
-	 */
-
-	if (receivePipe >= numFdBits) {
-	    numFdBits = receivePipe + 1;
-	}
-	FD_SET(receivePipe, &readableMask);
-
-	if (select(numFdBits, &readableMask, &writableMask, &exceptionMask,
-		timePtr) == -1) {
-	    /*
-	     * Try again immediately on an error.
-	     */
-
-	    continue;
-	}
-
-	/*
-	 * Alert any threads that are waiting on a ready file descriptor.
-	 */
-
-	pthread_mutex_lock(&notifierMutex);
-	for (tsdPtr = waitingListPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {
-	    found = 0;
-
-	    for (i = tsdPtr->numFdBits-1; i >= 0; --i) {
-		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)
-			&& FD_ISSET(i, &readableMask)) {
-		    FD_SET(i, &tsdPtr->readyMasks.readable);
-		    found = 1;
-		}
-		if (FD_ISSET(i, &tsdPtr->checkMasks.writable)
-			&& FD_ISSET(i, &writableMask)) {
-		    FD_SET(i, &tsdPtr->readyMasks.writable);
-		    found = 1;
-		}
-		if (FD_ISSET(i, &tsdPtr->checkMasks.exception)
-			&& FD_ISSET(i, &exceptionMask)) {
-		    FD_SET(i, &tsdPtr->readyMasks.exception);
-		    found = 1;
-		}
-	    }
-
-	    if (found || (tsdPtr->pollState & POLL_DONE)) {
-		tsdPtr->eventReady = 1;
-		if (tsdPtr->onList) {
-		    /*
-		     * Remove the ThreadSpecificData structure of this thread
-		     * from the waiting list. This prevents us from
-		     * continuously spining on select until the other threads
-		     * runs and services the file event.
-		     */
-
-		    if (tsdPtr->prevPtr) {
-			tsdPtr->prevPtr->nextPtr = tsdPtr->nextPtr;
-		    } else {
-			waitingListPtr = tsdPtr->nextPtr;
-		    }
-		    if (tsdPtr->nextPtr) {
-			tsdPtr->nextPtr->prevPtr = tsdPtr->prevPtr;
-		    }
-		    tsdPtr->nextPtr = tsdPtr->prevPtr = NULL;
-		    tsdPtr->onList = 0;
-		    tsdPtr->pollState = 0;
-		}
 #ifdef __CYGWIN__
-		PostMessageW(tsdPtr->hwnd, 1024, 0, 0);
+    PostMessageW(tsdPtr->hwnd, 1024, 0, 0);
 #else /* __CYGWIN__ */
-		pthread_cond_broadcast(&tsdPtr->waitCV);
+    pthread_cond_broadcast(&tsdPtr->waitCV);
 #endif /* __CYGWIN__ */
-	    }
-	}
-	pthread_mutex_unlock(&notifierMutex);
-
-	/*
-	 * Consume the next byte from the notifier pipe if the pipe was
-	 * readable. Note that there may be multiple bytes pending, but to
-	 * avoid a race condition we only read one at a time.
-	 */
-
-	if (FD_ISSET(receivePipe, &readableMask)) {
-	    i = read(receivePipe, buf, 1);
-
-	    if ((i == 0) || ((i == 1) && (buf[0] == 'q'))) {
-		/*
-		 * Someone closed the write end of the pipe or sent us a Quit
-		 * message [Bug: 4139] and then closed the write end of the
-		 * pipe so we need to shut down the notifier thread.
-		 */
-
-		break;
-	    }
-	}
-    }
-
-    /*
-     * Clean up the read end of the pipe and signal any threads waiting on
-     * termination of the notifier thread.
-     */
-
-    close(receivePipe);
-    pthread_mutex_lock(&notifierMutex);
-    triggerPipe = -1;
-    pthread_cond_broadcast(&notifierCV);
-    pthread_mutex_unlock(&notifierMutex);
-
-    TclpThreadExit(0);
 }
 
 #if defined(HAVE_PTHREAD_ATFORK)
@@ -1407,6 +395,7 @@ AtForkChild(void)
 	    pthread_cond_destroy(&tsdPtr->waitCV);
 	    pthread_cond_init(&tsdPtr->waitCV, NULL);
 #endif
+
 	    /*
 	     * In case, we had multiple threads running before the fork,
 	     * make sure, we don't try to reach out to their thread local data.
@@ -1426,8 +415,157 @@ AtForkChild(void)
 
 #endif /* TCL_THREADS */
 
+#endif /* NOTIFIER_SELECT */
+#ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
+				 * in tclMacOSXNotify.c */
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclUnixWaitForFile --
+ *
+ *	This function waits synchronously for a file to become readable or
+ *	writable, with an optional timeout.
+ *
+ * Results:
+ *	The return value is an OR'ed combination of TCL_READABLE,
+ *	TCL_WRITABLE, and TCL_EXCEPTION, indicating the conditions that are
+ *	present on file at the time of the return. This function will not
+ *	return until either "timeout" milliseconds have elapsed or at least
+ *	one of the conditions given by mask has occurred for file (a return
+ *	value of 0 means that a timeout occurred). No normal events will be
+ *	serviced during the execution of this function.
+ *
+ * Side effects:
+ *	Time passes.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclUnixWaitForFile(
+    int fd,			/* Handle for file on which to wait. */
+    int mask,			/* What to wait for: OR'ed combination of
+				 * TCL_READABLE, TCL_WRITABLE, and
+				 * TCL_EXCEPTION. */
+    int timeout)		/* Maximum amount of time to wait for one of
+				 * the conditions in mask to occur, in
+				 * milliseconds. A value of 0 means don't wait
+				 * at all, and a value of -1 means wait
+				 * forever. */
+{
+    Tcl_Time abortTime = {0, 0}, now; /* silence gcc 4 warning */
+    struct timeval blockTime, *timeoutPtr;
+    struct pollfd pollFds[1];
+    int numFound, result = 0, pollTimeout;
+
+    /*
+     * If there is a non-zero finite timeout, compute the time when we give
+     * up.
+     */
+
+    if (timeout > 0) {
+	Tcl_GetTime(&now);
+	abortTime.sec = now.sec + timeout/1000;
+	abortTime.usec = now.usec + (timeout%1000)*1000;
+	if (abortTime.usec >= 1000000) {
+	    abortTime.usec -= 1000000;
+	    abortTime.sec += 1;
+	}
+	timeoutPtr = &blockTime;
+    } else if (timeout == 0) {
+	timeoutPtr = &blockTime;
+	blockTime.tv_sec = 0;
+	blockTime.tv_usec = 0;
+    } else {
+	timeoutPtr = NULL;
+    }
+
+    /*
+     * Setup the pollfd structure for the fd.
+     */
+
+    pollFds[0].fd = fd;
+    pollFds[0].events = pollFds[0].revents = 0;
+    if (mask & TCL_READABLE) {
+	pollFds[0].events |= (POLLIN | POLLHUP);
+    }
+    if (mask & TCL_WRITABLE) {
+	pollFds[0].events |= POLLOUT;
+    }
+    if (mask & TCL_EXCEPTION) {
+	pollFds[0].events |= POLLERR;
+    }
+
+    /*
+     * Loop in a mini-event loop of our own, waiting for either the file to
+     * become ready or a timeout to occur.
+     */
+
+    while (1) {
+	if (timeout > 0) {
+	    blockTime.tv_sec = abortTime.sec - now.sec;
+	    blockTime.tv_usec = abortTime.usec - now.usec;
+	    if (blockTime.tv_usec < 0) {
+		blockTime.tv_sec -= 1;
+		blockTime.tv_usec += 1000000;
+	    }
+	    if (blockTime.tv_sec < 0) {
+		blockTime.tv_sec = 0;
+		blockTime.tv_usec = 0;
+	    }
+	}
+
+	/*
+	 * Wait for the event or a timeout.
+	 */
+
+	if (!timeoutPtr) {
+	    pollTimeout = -1;
+	} else if (!timeoutPtr->tv_sec && !timeoutPtr->tv_usec) {
+	    pollTimeout = 0;
+	} else {
+	    pollTimeout = (int)timeoutPtr->tv_sec * 1000;
+	    if (timeoutPtr->tv_usec) {
+		pollTimeout += ((int)timeoutPtr->tv_usec / 1000);
+	    }
+	}
+	numFound = poll(pollFds, 1, pollTimeout);
+	if (numFound == 1) {
+	    result = 0;
+	    if (pollFds[0].events & (POLLIN | POLLHUP)) {
+		result |= TCL_READABLE;
+	    }
+	    if (pollFds[0].events & POLLOUT) {
+		result |= TCL_WRITABLE;
+	    }
+	    if (pollFds[0].events & POLLERR) {
+		result |= TCL_EXCEPTION;
+	    }
+	    if (result) {
+		break;
+	    }
+	}
+	if (timeout == 0) {
+	    break;
+	}
+	if (timeout < 0) {
+	    continue;
+	}
+
+	/*
+	 * The select returned early, so we need to recompute the timeout.
+	 */
+
+	Tcl_GetTime(&now);
+	if ((abortTime.sec < now.sec)
+		|| (abortTime.sec==now.sec && abortTime.usec<=now.usec)) {
+	    break;
+	}
+    }
+    return result;
+}
 #endif /* !HAVE_COREFOUNDATION */
-
+
 /*
  * Local Variables:
  * mode: c
diff --git a/unix/tclUnixSock.c b/unix/tclUnixSock.c
index 9387d05..c0df035 100644
--- a/unix/tclUnixSock.c
+++ b/unix/tclUnixSock.c
@@ -19,6 +19,7 @@
 
 #define SET_BITS(var, bits)	((var) |= (bits))
 #define CLEAR_BITS(var, bits)	((var) &= ~(bits))
+#define GOT_BITS(var, bits)     (((var) & (bits)) != 0)
 
 /* "sock" + a pointer in hex + \0 */
 #define SOCK_CHAN_LENGTH        (4 + sizeof(void *) * 2 + 1)
@@ -52,6 +53,8 @@ typedef struct TcpFdList {
 
 struct TcpState {
     Tcl_Channel channel;	/* Channel associated with this file. */
+    int testFlags;              /* bit field for tests. Is set by testsocket
+                                 * test procedure */
     TcpFdList fds;		/* The file descriptors of the sockets. */
     int flags;			/* ORed combination of the bitfields defined
 				 * below. */
@@ -93,6 +96,15 @@ struct TcpState {
 #define TCP_ASYNC_FAILED	(1<<5)	/* An async connect finally failed */
 
 /*
+ * These bits may be ORed together into the "testFlags" field of a TcpState
+ * structure.
+ */
+
+#define TCP_ASYNC_TEST_MODE	(1<<0)	/* Async testing activated.  Do not
+					 * automatically continue connection
+					 * process. */
+
+/*
  * The following defines the maximum length of the listen queue. This is the
  * number of outstanding yet-to-be-serviced requests for a connection on a
  * server socket, more than this number of outstanding requests and the
@@ -117,8 +129,7 @@ struct TcpState {
  * Static routines for this file:
  */
 
-static int		TcpConnect(Tcl_Interp *interp,
-                                           TcpState *state);
+static int		TcpConnect(Tcl_Interp *interp, TcpState *state);
 static void		TcpAccept(ClientData data, int mask);
 static int		TcpBlockModeProc(ClientData data, int mode);
 static int		TcpCloseProc(ClientData instanceData,
@@ -173,21 +184,24 @@ static ProcessGlobalValue hostName =
 
 #if 0
 /* printf debugging */
-void printaddrinfo(struct addrinfo *addrlist, char *prefix)
+void
+printaddrinfo(
+    struct addrinfo *addrlist,
+    char *prefix)
 {
     char host[NI_MAXHOST], port[NI_MAXSERV];
     struct addrinfo *ai;
+
     for (ai = addrlist; ai != NULL; ai = ai->ai_next) {
 	getnameinfo(ai->ai_addr, ai->ai_addrlen,
-		    host, sizeof(host),
-		    port, sizeof(port),
-		    NI_NUMERICHOST|NI_NUMERICSERV);
+		host, sizeof(host), port, sizeof(port),
+		NI_NUMERICHOST|NI_NUMERICSERV);
 	fprintf(stderr,"%s: %s:%s\n", prefix, host, port);
     }
 }
 #endif
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * InitializeHostName --
  *
@@ -197,7 +211,7 @@ void printaddrinfo(struct addrinfo *addrlist, char *prefix)
  * Results:
  *	None.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 static void
@@ -276,7 +290,7 @@ InitializeHostName(
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * Tcl_GetHostName --
  *
@@ -290,7 +304,7 @@ InitializeHostName(
  * Side effects:
  *	Caches the name to return for future calls.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 const char *
@@ -300,7 +314,7 @@ Tcl_GetHostName(void)
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * TclpHasSockets --
  *
@@ -312,7 +326,7 @@ Tcl_GetHostName(void)
  * Side effects:
  *	None.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 int
@@ -323,7 +337,7 @@ TclpHasSockets(
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * TclpFinalizeSockets --
  *
@@ -335,7 +349,7 @@ TclpHasSockets(
  * Side effects:
  *	None.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 void
@@ -345,7 +359,7 @@ TclpFinalizeSockets(void)
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * TcpBlockModeProc --
  *
@@ -358,7 +372,7 @@ TclpFinalizeSockets(void)
  * Side effects:
  *	Sets the device into blocking or nonblocking mode.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 	/* ARGSUSED */
@@ -376,7 +390,7 @@ TcpBlockModeProc(
     } else {
 	SET_BITS(statePtr->flags, TCP_NONBLOCKING);
     }
-    if (statePtr->flags & TCP_ASYNC_CONNECT) {
+    if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
         statePtr->cachedBlocking = mode;
         return 0;
     }
@@ -387,33 +401,32 @@ TcpBlockModeProc(
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * WaitForConnect --
  *
- *	Check the state of an async connect process. If a connection
- *	attempt terminated, process it, which may finalize it or may
- *	start the next attempt. If a connect error occures, it is saved
- *	in statePtr->connectError to be reported by 'fconfigure -error'.
+ *	Check the state of an async connect process. If a connection attempt
+ *	terminated, process it, which may finalize it or may start the next
+ *	attempt. If a connect error occures, it is saved in
+ *	statePtr->connectError to be reported by 'fconfigure -error'.
  *
  *	There are two modes of operation, defined by errorCodePtr:
- *	 *  non-NULL: Called by explicite read/write command. block if
+ *	 *  non-NULL: Called by explicite read/write command. Blocks if the
  *	    socket is blocking.
  *	    May return two error codes:
  *	     *	EWOULDBLOCK: if connect is still in progress
- *	     *	ENOTCONN: if connect failed. This would be the error
- *		message of a rect or sendto syscall so this is
- *		emulated here.
- *	 *  NULL: Called by a backround operation. Do not block and
- *	    don't return any error code.
+ *	     *	ENOTCONN: if connect failed. This would be the error message
+ *		of a rect or sendto syscall so this is emulated here.
+ *	 *  NULL: Called by a backround operation. Do not block and do not
+ *	    return any error code.
  *
  * Results:
- * 	0 if the connection has completed, -1 if still in progress
- * 	or there is an error.
+ * 	0 if the connection has completed, -1 if still in progress or there is
+ * 	an error.
  *
  * Side effects:
- *	Processes socket events off the system queue.
- *	May process asynchroneous connect.
+ *	Processes socket events off the system queue. May process
+ *	asynchroneous connects.
  *
  *----------------------------------------------------------------------
  */
@@ -426,11 +439,11 @@ WaitForConnect(
     int timeout;
 
     /*
-     * Check if an async connect failed already and error reporting is demanded,
-     * return the error ENOTCONN
+     * Check if an async connect failed already and error reporting is
+     * demanded, return the error ENOTCONN
      */
 
-    if (errorCodePtr != NULL && (statePtr->flags & TCP_ASYNC_FAILED)) {
+    if (errorCodePtr != NULL && GOT_BITS(statePtr->flags, TCP_ASYNC_FAILED)) {
 	*errorCodePtr = ENOTCONN;
 	return -1;
     }
@@ -439,26 +452,43 @@ WaitForConnect(
      * Check if an async connect is running. If not return ok
      */
 
-    if (!(statePtr->flags & TCP_ASYNC_PENDING)) {
+    if (!GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
 	return 0;
     }
 
-    if (errorCodePtr == NULL || (statePtr->flags & TCP_NONBLOCKING)) {
+    /*
+     * In socket test mode do not continue with the connect.
+     * Exceptions are:
+     * - Call by recv/send and blocking socket
+     *   (errorCodePtr != NULL && !GOT_BITS(flags, TCP_NONBLOCKING))
+     */
+
+    if (GOT_BITS(statePtr->testFlags, TCP_ASYNC_TEST_MODE)
+            && !(errorCodePtr != NULL
+                    && !GOT_BITS(statePtr->flags, TCP_NONBLOCKING))) {
+	*errorCodePtr = EWOULDBLOCK;
+	return -1;
+    }
+
+    if (errorCodePtr == NULL || GOT_BITS(statePtr->flags, TCP_NONBLOCKING)) {
         timeout = 0;
     } else {
         timeout = -1;
     }
     do {
         if (TclUnixWaitForFile(statePtr->fds.fd,
-                                TCL_WRITABLE | TCL_EXCEPTION, timeout) != 0) {
+                TCL_WRITABLE | TCL_EXCEPTION, timeout) != 0) {
             TcpConnect(NULL, statePtr);
         }
-        /* Do this only once in the nonblocking case and repeat it until the
-         * socket is final when blocking */
-    } while (timeout == -1 && statePtr->flags & TCP_ASYNC_CONNECT);
+
+        /*
+         * Do this only once in the nonblocking case and repeat it until the
+         * socket is final when blocking.
+         */
+    } while (timeout == -1 && GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT));
 
     if (errorCodePtr != NULL) {
-        if (statePtr->flags & TCP_ASYNC_PENDING) {
+        if (GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
             *errorCodePtr = EAGAIN;
             return -1;
         } else if (statePtr->connectError != 0) {
@@ -615,6 +645,7 @@ TcpCloseProc(
     fds = statePtr->fds.next;
     while (fds != NULL) {
 	TcpFdList *next = fds->next;
+
         ckfree(fds);
 	fds = next;
     }
@@ -685,10 +716,9 @@ TcpClose2Proc(
  *
  * TcpHostPortList --
  *
- *	This function is called by the -gethostname and -getpeername
- *	switches of TcpGetOptionProc() to add three list elements
- *	with the textual representation of the given address to the
- *	given DString.
+ *	This function is called by the -gethostname and -getpeername switches
+ *	of TcpGetOptionProc() to add three list elements with the textual
+ *	representation of the given address to the given DString.
  *
  * Results:
  *	None.
@@ -698,6 +728,33 @@ TcpClose2Proc(
  *
  *----------------------------------------------------------------------
  */
+
+#ifndef NEED_FAKE_RFC2553
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+static inline int
+IPv6AddressNeedsNumericRendering(
+    struct in6_addr addr)
+{
+    if (IN6_ARE_ADDR_EQUAL(&addr, &in6addr_any)) {
+        return 1;
+    }
+
+    /*
+     * The IN6_IS_ADDR_V4MAPPED macro has a problem with aliasing warnings on
+     * at least some versions of OSX.
+     */
+
+    if (!IN6_IS_ADDR_V4MAPPED(&addr)) {
+        return 0;
+    }
+
+    return (addr.s6_addr[12] == 0 && addr.s6_addr[13] == 0
+            && addr.s6_addr[14] == 0 && addr.s6_addr[15] == 0);
+}
+#pragma GCC diagnostic pop
+#endif /* NEED_FAKE_RFC2553 */
+
 static void
 TcpHostPortList(
     Tcl_Interp *interp,
@@ -709,40 +766,47 @@ TcpHostPortList(
     char host[NI_MAXHOST], nhost[NI_MAXHOST], nport[NI_MAXSERV];
     int flags = 0;
 
-    getnameinfo(&addr.sa, salen,
-                nhost, sizeof(nhost), nport, sizeof(nport),
-                NI_NUMERICHOST | NI_NUMERICSERV);
+    getnameinfo(&addr.sa, salen, nhost, sizeof(nhost), nport, sizeof(nport),
+            NI_NUMERICHOST | NI_NUMERICSERV);
     Tcl_DStringAppendElement(dsPtr, nhost);
+
     /*
-     * We don't want to resolve INADDR_ANY and sin6addr_any; they
-     * can sometimes cause problems (and never have a name).
+     * We don't want to resolve INADDR_ANY and sin6addr_any; they can
+     * sometimes cause problems (and never have a name).
      */
+
     if (addr.sa.sa_family == AF_INET) {
         if (addr.sa4.sin_addr.s_addr == INADDR_ANY) {
             flags |= NI_NUMERICHOST;
         }
 #ifndef NEED_FAKE_RFC2553
     } else if (addr.sa.sa_family == AF_INET6) {
-        if ((IN6_ARE_ADDR_EQUAL(&addr.sa6.sin6_addr,
-                                &in6addr_any))
-            || (IN6_IS_ADDR_V4MAPPED(&addr.sa6.sin6_addr) &&
-                addr.sa6.sin6_addr.s6_addr[12] == 0 &&
-                addr.sa6.sin6_addr.s6_addr[13] == 0 &&
-                addr.sa6.sin6_addr.s6_addr[14] == 0 &&
-                addr.sa6.sin6_addr.s6_addr[15] == 0)) {
+        if (IPv6AddressNeedsNumericRendering(addr.sa6.sin6_addr)) {
             flags |= NI_NUMERICHOST;
         }
 #endif /* NEED_FAKE_RFC2553 */
     }
-    /* Check if reverse DNS has been switched off globally */
-    if (interp != NULL && Tcl_GetVar2(interp, SUPPRESS_RDNS_VAR, NULL, 0) != NULL) {
+
+    /*
+     * Check if reverse DNS has been switched off globally.
+     */
+
+    if (interp != NULL &&
+            Tcl_GetVar2(interp, SUPPRESS_RDNS_VAR, NULL, 0) != NULL) {
         flags |= NI_NUMERICHOST;
     }
-    if (getnameinfo(&addr.sa, salen, host, sizeof(host), NULL, 0, flags) == 0) {
-        /* Reverse mapping worked */
+    if (getnameinfo(&addr.sa, salen, host, sizeof(host), NULL, 0,
+            flags) == 0) {
+        /*
+         * Reverse mapping worked.
+         */
+
         Tcl_DStringAppendElement(dsPtr, host);
     } else {
-        /* Reverse mappong failed - use the numeric rep once more */
+        /*
+         * Reverse mapping failed - use the numeric rep once more.
+         */
+
         Tcl_DStringAppendElement(dsPtr, nhost);
     }
     Tcl_DStringAppendElement(dsPtr, nport);
@@ -792,16 +856,20 @@ TcpGetOptionProc(
 	    (strncmp(optionName, "-error", len) == 0)) {
 	socklen_t optlen = sizeof(int);
 
-        if (statePtr->flags & TCP_ASYNC_CONNECT) {
-            /* Suppress errors as long as we are not done */
+        if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
+            /*
+             * Suppress errors as long as we are not done.
+             */
+
             errno = 0;
         } else if (statePtr->connectError != 0) {
             errno = statePtr->connectError;
             statePtr->connectError = 0;
         } else {
             int err;
-            getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR,
-                    (char *) &err, &optlen);
+
+            getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR, (char *) &err,
+                    &optlen);
             errno = err;
         }
         if (errno != 0) {
@@ -812,9 +880,8 @@ TcpGetOptionProc(
 
     if ((len > 1) && (optionName[1] == 'c') &&
 	    (strncmp(optionName, "-connecting", len) == 0)) {
-
         Tcl_DStringAppend(dsPtr,
-                        (statePtr->flags & TCP_ASYNC_CONNECT) ? "1" : "0", -1);
+                GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT) ? "1" : "0", -1);
         return TCL_OK;
     }
 
@@ -823,10 +890,11 @@ TcpGetOptionProc(
         address peername;
         socklen_t size = sizeof(peername);
 
-	if ( (statePtr->flags & TCP_ASYNC_CONNECT) ) {
+	if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 	    /*
 	     * In async connect output an empty string
 	     */
+
 	    if (len == 0) {
 		Tcl_DStringAppendElement(dsPtr, "-peername");
 		Tcl_DStringAppendElement(dsPtr, "");
@@ -837,6 +905,7 @@ TcpGetOptionProc(
 	    /*
 	     * Peername fetch succeeded - output list
 	     */
+
 	    if (len == 0) {
 		Tcl_DStringAppendElement(dsPtr, "-peername");
 		Tcl_DStringStartSublist(dsPtr);
@@ -876,11 +945,12 @@ TcpGetOptionProc(
 	    Tcl_DStringAppendElement(dsPtr, "-sockname");
 	    Tcl_DStringStartSublist(dsPtr);
 	}
-	if ( (statePtr->flags & TCP_ASYNC_CONNECT) ) {
+	if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 	    /*
 	     * In async connect output an empty string
 	     */
-	     found = 1;
+
+            found = 1;
 	} else {
 	    for (fds = &statePtr->fds; fds != NULL; fds = fds->next) {
 		size = sizeof(sockname);
@@ -905,14 +975,15 @@ TcpGetOptionProc(
     }
 
     if (len > 0) {
-	return Tcl_BadChannelOption(interp, optionName, "connecting peername sockname");
+	return Tcl_BadChannelOption(interp, optionName,
+                "connecting peername sockname");
     }
 
     return TCL_OK;
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * TcpWatchProc --
  *
@@ -925,7 +996,7 @@ TcpGetOptionProc(
  *	Sets up the notifier so that a future event on the channel will be
  *	seen by Tcl.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 static void
@@ -938,17 +1009,17 @@ WrapNotify(
 
     if (newmask == 0) {
 	/*
-	 * There was no overlap between the states the channel is
-	 * interested in notifications for, and the states that are
-	 * reported present on the file descriptor by select().  The
-	 * only way that can happen is when the channel is interested
-	 * in a writable condition, and only a readable state is reported
-	 * present (see TcpWatchProc() below).  In that case, signal back
-	 * to the caller the writable state, which is really an error
-	 * condition.  As an extra check on that assumption, check for
-	 * a non-zero value of errno before reporting an artificial
+	 * There was no overlap between the states the channel is interested
+	 * in notifications for, and the states that are reported present on
+	 * the file descriptor by select().  The only way that can happen is
+	 * when the channel is interested in a writable condition, and only a
+	 * readable state is reported present (see TcpWatchProc() below).  In
+	 * that case, signal back to the caller the writable state, which is
+	 * really an error condition.  As an extra check on that assumption,
+	 * check for a non-zero value of errno before reporting an artificial
 	 * writable state.
 	 */
+
 	if (errno == 0) {
 	    return;
 	}
@@ -972,33 +1043,36 @@ TcpWatchProc(
          * be readable or writable at the Tcl level. This keeps Tcl scripts
          * from interfering with the -accept behavior (bug #3394732).
          */
+
     	return;
     }
 
-    if (statePtr->flags & TCP_ASYNC_PENDING) {
-        /* Async sockets use a FileHandler internally while connecting, so we
-         * need to cache this request until the connection has succeeded. */
+    if (GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
+        /*
+         * Async sockets use a FileHandler internally while connecting, so we
+         * need to cache this request until the connection has succeeded.
+         */
+
         statePtr->filehandlers = mask;
     } else if (mask) {
 
 	/*
-	 * Whether it is a bug or feature or otherwise, it is a fact
-	 * of life that on at least some Linux kernels select() fails
-	 * to report that a socket file descriptor is writable when
-	 * the other end of the socket is closed.  This is in contrast
-	 * to the guarantees Tcl makes that its channels become
-	 * writable and fire writable events on an error conditon.
-	 * This has caused a leak of file descriptors in a state of
+	 * Whether it is a bug or feature or otherwise, it is a fact of life
+	 * that on at least some Linux kernels select() fails to report that a
+	 * socket file descriptor is writable when the other end of the socket
+	 * is closed.  This is in contrast to the guarantees Tcl makes that
+	 * its channels become writable and fire writable events on an error
+	 * conditon.  This has caused a leak of file descriptors in a state of
 	 * background flushing.  See Tcl ticket 1758a0b603.
 	 *
-	 * As a workaround, when our caller indicates an interest in
-	 * writable notifications, we must tell the notifier built
-	 * around select() that we are interested in the readable state
-	 * of the file descriptor as well, as that is the only reliable
-	 * means to get notified of error conditions.  Then it is the
-	 * task of WrapNotify() above to untangle the meaning of these
-	 * channel states and report the chan events as best it can.
-	 * We save a copy of the mask passed in to assist with that.
+	 * As a workaround, when our caller indicates an interest in writable
+	 * notifications, we must tell the notifier built around select() that
+	 * we are interested in the readable state of the file descriptor as
+	 * well, as that is the only reliable means to get notified of error
+	 * conditions.  Then it is the task of WrapNotify() above to untangle
+	 * the meaning of these channel states and report the chan events as
+	 * best it can.  We save a copy of the mask passed in to assist with
+	 * that.
 	 */
 
 	statePtr->interest = mask;
@@ -1010,7 +1084,7 @@ TcpWatchProc(
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * TcpGetHandleProc --
  *
@@ -1024,7 +1098,7 @@ TcpWatchProc(
  * Side effects:
  *	None.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 	/* ARGSUSED */
@@ -1041,16 +1115,17 @@ TcpGetHandleProc(
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * TcpAsyncCallback --
  *
- *	Called by the event handler that TcpConnect sets up
- *	internally for [socket -async] to get notified when the
- *	asyncronous connection attempt has succeeded or failed.
+ *	Called by the event handler that TcpConnect sets up internally for
+ *	[socket -async] to get notified when the asyncronous connection
+ *	attempt has succeeded or failed.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
+
 static void
 TcpAsyncCallback(
     ClientData clientData,	/* The socket state. */
@@ -1062,7 +1137,7 @@ TcpAsyncCallback(
 }
 
 /*
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  *
  * TcpConnect --
  *
@@ -1088,7 +1163,7 @@ TcpAsyncCallback(
  *	return and the loops resume as if they had never been interrupted.
  *	For syncronously connecting sockets, the loops work the usual way.
  *
- *----------------------------------------------------------------------
+ * ----------------------------------------------------------------------
  */
 
 static int
@@ -1097,9 +1172,9 @@ TcpConnect(
     TcpState *statePtr)
 {
     socklen_t optlen;
-    int async_callback = statePtr->flags & TCP_ASYNC_PENDING;
+    int async_callback = GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING);
     int ret = -1, error = EHOSTUNREACH;
-    int async = statePtr->flags & TCP_ASYNC_CONNECT;
+    int async = GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
 
     if (async_callback) {
         goto reenter;
@@ -1107,8 +1182,8 @@ TcpConnect(
 
     for (statePtr->addr = statePtr->addrlist; statePtr->addr != NULL;
             statePtr->addr = statePtr->addr->ai_next) {
-
-        for (statePtr->myaddr = statePtr->myaddrlist; statePtr->myaddr != NULL;
+        for (statePtr->myaddr = statePtr->myaddrlist;
+                statePtr->myaddr != NULL;
                 statePtr->myaddr = statePtr->myaddr->ai_next) {
             int reuseaddr = 1;
 
@@ -1132,7 +1207,8 @@ TcpConnect(
                 errno = 0;
 	    }
 
-	    statePtr->fds.fd = socket(statePtr->addr->ai_family, SOCK_STREAM, 0);
+	    statePtr->fds.fd = socket(statePtr->addr->ai_family, SOCK_STREAM,
+                    0);
 	    if (statePtr->fds.fd < 0) {
 		continue;
 	    }
@@ -1151,14 +1227,18 @@ TcpConnect(
 	    TclSockMinimumBuffers(INT2PTR(statePtr->fds.fd), SOCKET_BUFSIZE);
 
 	    if (async) {
-                ret = TclUnixSetBlockingMode(statePtr->fds.fd,TCL_MODE_NONBLOCKING);
+                ret = TclUnixSetBlockingMode(statePtr->fds.fd,
+                        TCL_MODE_NONBLOCKING);
                 if (ret < 0) {
                     continue;
                 }
             }
 
-            /* Gotta reset the error variable here, before we use it for the
-             * first time in this iteration. */
+            /*
+             * Must reset the error variable here, before we use it for the
+             * first time in this iteration.
+             */
+
             error = 0;
 
             (void) setsockopt(statePtr->fds.fd, SOL_SOCKET, SO_REUSEADDR,
@@ -1179,10 +1259,13 @@ TcpConnect(
 
 	    ret = connect(statePtr->fds.fd, statePtr->addr->ai_addr,
                         statePtr->addr->ai_addrlen);
-            if (ret < 0) error = errno;
+            if (ret < 0) {
+                error = errno;
+            }
 	    if (ret < 0 && errno == EINPROGRESS) {
                 Tcl_CreateFileHandler(statePtr->fds.fd,
-                        TCL_WRITABLE|TCL_EXCEPTION, TcpAsyncCallback, statePtr);
+                        TCL_WRITABLE | TCL_EXCEPTION, TcpAsyncCallback,
+                        statePtr);
                 errno = EWOULDBLOCK;
                 SET_BITS(statePtr->flags, TCP_ASYNC_PENDING);
                 return TCL_OK;
@@ -1210,7 +1293,7 @@ TcpConnect(
 	}
     }
 
-out:
+  out:
     statePtr->connectError = error;
     CLEAR_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
     if (async_callback) {
@@ -1308,6 +1391,7 @@ Tcl_OpenTcpClient(
     /*
      * Allocate a new TcpState for this socket.
      */
+
     statePtr = ckalloc(sizeof(TcpState));
     memset(statePtr, 0, sizeof(TcpState));
     statePtr->flags = async ? TCP_ASYNC_CONNECT : 0;
@@ -1319,6 +1403,7 @@ Tcl_OpenTcpClient(
     /*
      * Create a new client socket and wrap it in a channel.
      */
+
     if (TcpConnect(interp, statePtr) != TCL_OK) {
         TcpCloseProc(statePtr, NULL);
         return NULL;
@@ -1326,8 +1411,8 @@ Tcl_OpenTcpClient(
 
     sprintf(channelName, SOCK_TEMPLATE, (long) statePtr);
 
-    statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName, statePtr,
-            (TCL_READABLE | TCL_WRITABLE));
+    statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
+            statePtr, TCL_READABLE | TCL_WRITABLE);
     if (Tcl_SetChannelOption(interp, statePtr->channel, "-translation",
 	    "auto crlf") == TCL_ERROR) {
 	Tcl_Close(NULL, statePtr->channel);
@@ -1356,7 +1441,8 @@ Tcl_Channel
 Tcl_MakeTcpClientChannel(
     ClientData sock)		/* The socket to wrap up into a channel. */
 {
-    return (Tcl_Channel) TclpMakeTcpClientChannelMode(sock, (TCL_READABLE | TCL_WRITABLE));
+    return (Tcl_Channel) TclpMakeTcpClientChannelMode(sock,
+            TCL_READABLE | TCL_WRITABLE);
 }
 
 /*
@@ -1456,6 +1542,7 @@ Tcl_OpenTcpServerEx(
      * families. We try this at most MAXRETRY times to avoid an endless loop
      * if all ports are taken.
      */
+
     int retry = 0;
 #define MAXRETRY 10
 
@@ -1481,7 +1568,8 @@ Tcl_OpenTcpServerEx(
 	goto error;
     }
 
-    if (!TclCreateSocketAddress(interp, &addrlist, myHost, port, 1, &errorMsg)) {
+    if (!TclCreateSocketAddress(interp, &addrlist, myHost, port, 1,
+            &errorMsg)) {
 	my_errno = errno;
 	goto error;
     }
@@ -1514,24 +1602,25 @@ Tcl_OpenTcpServerEx(
 	 * Set up to reuse server addresses and/or ports if requested.
 	 */
 
-	if (flags & TCL_TCPSERVER_REUSEADDR) {
+	if (GOT_BITS(flags, TCL_TCPSERVER_REUSEADDR)) {
 	    optvalue = 1;
 	    (void) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
-			      (char *) &optvalue, sizeof(optvalue));
+		    (char *) &optvalue, sizeof(optvalue));
 	}
 
-	if (flags & TCL_TCPSERVER_REUSEPORT) {
+	if (GOT_BITS(flags, TCL_TCPSERVER_REUSEPORT)) {
 #ifndef SO_REUSEPORT
 	    /*
-	     * If the platform doesn't support the SO_REUSEPORT flag we can't do
-	     * much beside erroring out.
+	     * If the platform doesn't support the SO_REUSEPORT flag we can't
+	     * do much beside erroring out.
 	     */
+
 	    errorMsg = "SO_REUSEPORT isn't supported by this platform";
 	    goto error;
 #else
 	    optvalue = 1;
 	    (void) setsockopt(sock, SOL_SOCKET, SO_REUSEPORT,
-			      (char *) &optvalue, sizeof(optvalue));
+		    (char *) &optvalue, sizeof(optvalue));
 #endif
 	}
 
@@ -1549,7 +1638,10 @@ Tcl_OpenTcpServerEx(
 	}
 
 #ifdef IPV6_V6ONLY
-	/* Missing on: Solaris 2.8 */
+	/*
+         * Missing on: Solaris 2.8
+         */
+
         if (addrPtr->ai_family == AF_INET6) {
             int v6only = 1;
 
@@ -1701,7 +1793,7 @@ TcpAccept(
 
     sprintf(channelName, SOCK_TEMPLATE, (long) newSockState);
     newSockState->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
-	    newSockState, (TCL_READABLE | TCL_WRITABLE));
+	    newSockState, TCL_READABLE | TCL_WRITABLE);
 
     Tcl_SetChannelOption(NULL, newSockState->channel, "-translation",
 	    "auto crlf");
diff --git a/unix/tclUnixTest.c b/unix/tclUnixTest.c
index 86e0925..ceb64d9 100644
--- a/unix/tclUnixTest.c
+++ b/unix/tclUnixTest.c
@@ -68,10 +68,10 @@ static Tcl_CmdProc TestfilehandlerCmd;
 static Tcl_CmdProc TestfilewaitCmd;
 static Tcl_CmdProc TestfindexecutableCmd;
 static Tcl_ObjCmdProc TestforkObjCmd;
-static Tcl_CmdProc TestgetdefencdirCmd;
+static Tcl_ObjCmdProc TestgetencpathObjCmd;
 static Tcl_CmdProc TestgetopenfileCmd;
 static Tcl_CmdProc TestgotsigCmd;
-static Tcl_CmdProc TestsetdefencdirCmd;
+static Tcl_ObjCmdProc TestsetencpathObjCmd;
 static Tcl_FileProc TestFileHandlerProc;
 static void AlarmHandler(int signum);
 
@@ -108,9 +108,9 @@ TclplatformtestInit(
         NULL, NULL);
     Tcl_CreateCommand(interp, "testgetopenfile", TestgetopenfileCmd,
 	    NULL, NULL);
-    Tcl_CreateCommand(interp, "testgetdefenc", TestgetdefencdirCmd,
+    Tcl_CreateObjCommand(interp, "testgetencpath", TestgetencpathObjCmd,
 	    NULL, NULL);
-    Tcl_CreateCommand(interp, "testsetdefenc", TestsetdefencdirCmd,
+    Tcl_CreateObjCommand(interp, "testsetencpath", TestsetencpathObjCmd,
 	    NULL, NULL);
     Tcl_CreateCommand(interp, "testalarm", TestalarmCmd,
 	    NULL, NULL);
@@ -499,9 +499,9 @@ TestgetopenfileCmd(
 /*
  *----------------------------------------------------------------------
  *
- * TestsetdefencdirCmd --
+ * TestsetencpathCmd --
  *
- *	This function implements the "testsetdefenc" command. It is used to
+ *	This function implements the "testsetencpath" command. It is used to
  *	test Tcl_SetDefaultEncodingDir().
  *
  * Results:
@@ -514,19 +514,18 @@ TestgetopenfileCmd(
  */
 
 static int
-TestsetdefencdirCmd(
+TestsetencpathObjCmd(
     ClientData clientData,	/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
-    int argc,			/* Number of arguments. */
-    const char **argv)		/* Argument strings. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const *objv)	/* Argument strings. */
 {
-    if (argc != 2) {
-        Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-		" defaultDir\"", NULL);
+    if (objc != 2) {
+        Tcl_WrongNumArgs(interp, 1, objv, "defaultDir");
         return TCL_ERROR;
     }
 
-    Tcl_SetDefaultEncodingDir(argv[1]);
+    Tcl_SetEncodingSearchPath(objv[1]);
     return TCL_OK;
 }
 
@@ -552,7 +551,7 @@ TestforkObjCmd(
     ClientData clientData,	/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
-    Tcl_Obj *const *objv)		/* Argument strings. */
+    Tcl_Obj *const *objv)	/* Argument strings. */
 {
     pid_t pid;
 
@@ -578,10 +577,10 @@ TestforkObjCmd(
 /*
  *----------------------------------------------------------------------
  *
- * TestgetdefencdirCmd --
+ * TestgetencpathObjCmd --
  *
- *	This function implements the "testgetdefenc" command. It is used to
- *	test Tcl_GetDefaultEncodingDir().
+ *	This function implements the "testgetencpath" command. It is used to
+ *	test Tcl_GetEncodingSearchPath().
  *
  * Results:
  *	A standard Tcl result.
@@ -593,18 +592,18 @@ TestforkObjCmd(
  */
 
 static int
-TestgetdefencdirCmd(
+TestgetencpathObjCmd(
     ClientData clientData,	/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
-    int argc,			/* Number of arguments. */
-    const char **argv)		/* Argument strings. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const *objv)		/* Argument strings. */
 {
-    if (argc != 1) {
-        Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], NULL);
+    if (objc != 1) {
+        Tcl_WrongNumArgs(interp, 1, objv, "");
         return TCL_ERROR;
     }
 
-    Tcl_AppendResult(interp, Tcl_GetDefaultEncodingDir(), NULL);
+    Tcl_SetObjResult(interp, Tcl_GetEncodingSearchPath());
     return TCL_OK;
 }
 
diff --git a/unix/tclUnixThrd.c b/unix/tclUnixThrd.c
index 805599d..f475aed 100644
--- a/unix/tclUnixThrd.c
+++ b/unix/tclUnixThrd.c
@@ -644,6 +644,7 @@ TclpFinalizeCondition(
  *----------------------------------------------------------------------
  */
 
+#ifndef TCL_NO_DEPRECATED
 Tcl_DirEntry *
 TclpReaddir(
     DIR * dir)
@@ -666,6 +667,7 @@ TclpInetNtoa(
     return inet_ntoa(addr);
 #endif
 }
+#endif /* TCL_NO_DEPRECATED */
 
 #ifdef TCL_THREADS
 /*
diff --git a/unix/tclUnixTime.c b/unix/tclUnixTime.c
index d634449..6a73ac2 100644
--- a/unix/tclUnixTime.c
+++ b/unix/tclUnixTime.c
@@ -22,6 +22,7 @@
  * variable is the key to this buffer.
  */
 
+#ifndef TCL_NO_DEPRECATED
 static Tcl_ThreadDataKey tmKey;
 typedef struct {
     struct tm gmtime_buf;
@@ -45,6 +46,8 @@ static char *lastTZ = NULL;	/* Holds the last setting of the TZ
 
 static void		SetTZIfNecessary(void);
 static void		CleanupMemory(ClientData clientData);
+#endif /* TCL_NO_DEPRECATED */
+
 static void		NativeScaleTime(Tcl_Time *timebuf,
 			    ClientData clientData);
 static void		NativeGetTime(Tcl_Time *timebuf,
@@ -263,6 +266,7 @@ Tcl_GetTime(
  *----------------------------------------------------------------------
  */
 
+#ifndef TCL_NO_DEPRECATED
 struct tm *
 TclpGetDate(
     const time_t *time,
@@ -352,6 +356,7 @@ TclpLocaltime(
 
     return &tsdPtr->localtime_buf;
 }
+#endif /* TCL_NO_DEPRECATED */
 
 /*
  *----------------------------------------------------------------------
@@ -486,6 +491,7 @@ NativeGetTime(
  *----------------------------------------------------------------------
  */
 
+#ifndef TCL_NO_DEPRECATED
 static void
 SetTZIfNecessary(void)
 {
@@ -531,6 +537,7 @@ CleanupMemory(
 {
     ckfree(lastTZ);
 }
+#endif /* TCL_NO_DEPRECATED */
 
 /*
  * Local Variables: