Remove MODULE_SCOPE function TclpSetInterfaces(), which is just empty.

Increase size of MSG structure in Cygwin Notifier: Should conform with Win32 size. Some related code cleanup.

6 files changed, 212 insertions, 241 deletions

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 79985ed..e56c21b 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1059,7 +1059,6 @@ TclInitSubsystems(void)
 					 * mutexes. */
 	    TclInitIOSubsystem();	/* Inits a tsd key (noop). */
 	    TclInitEncodingSubsystem();	/* Process wide encoding init. */
-	    TclpSetInterfaces();
 	    TclInitNamespaceSubsystem();/* Register ns obj type (mutexed). */
 	    subsystemsInitialized = 1;
 	}
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 69cebe5..c30a257 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -3127,7 +3127,6 @@ MODULE_SCOPE Tcl_Obj *	TclPathPart(Tcl_Interp *interp, Tcl_Obj *pathPtr,
 			    Tcl_PathPart portion);
 MODULE_SCOPE char *	TclpReadlink(const char *fileName,
 			    Tcl_DString *linkPtr);
-MODULE_SCOPE void	TclpSetInterfaces(void);
 MODULE_SCOPE void	TclpSetVariables(Tcl_Interp *interp);
 MODULE_SCOPE void *	TclThreadStorageKeyGet(Tcl_ThreadDataKey *keyPtr);
 MODULE_SCOPE void	TclThreadStorageKeySet(Tcl_ThreadDataKey *keyPtr,
diff --git a/unix/tclUnixInit.c b/unix/tclUnixInit.c
index aac8a8d..406c2b0 100644
--- a/unix/tclUnixInit.c
+++ b/unix/tclUnixInit.c
@@ -52,29 +52,29 @@ static const char *const processors[NUMPROCESSORS] = {
 
 typedef struct {
   union {
-    DWORD  dwOemId;
+    unsigned int  dwOemId;
     struct {
       int wProcessorArchitecture;
       int wReserved;
     };
   };
-  DWORD     dwPageSize;
+  unsigned int     dwPageSize;
   void *lpMinimumApplicationAddress;
   void *lpMaximumApplicationAddress;
   void *dwActiveProcessorMask;
-  DWORD     dwNumberOfProcessors;
-  DWORD     dwProcessorType;
-  DWORD     dwAllocationGranularity;
+  unsigned int     dwNumberOfProcessors;
+  unsigned int     dwProcessorType;
+  unsigned int     dwAllocationGranularity;
   int      wProcessorLevel;
   int      wProcessorRevision;
 } SYSTEM_INFO;
 
 typedef struct {
-  DWORD dwOSVersionInfoSize;
-  DWORD dwMajorVersion;
-  DWORD dwMinorVersion;
-  DWORD dwBuildNumber;
-  DWORD dwPlatformId;
+  unsigned int dwOSVersionInfoSize;
+  unsigned int dwMajorVersion;
+  unsigned int dwMinorVersion;
+  unsigned int dwBuildNumber;
+  unsigned int dwPlatformId;
   wchar_t szCSDVersion[128];
 } OSVERSIONINFOW;
 #endif
@@ -131,9 +131,9 @@ typedef struct LocaleTable {
  */
 
 static const LocaleTable localeTable[] = {
-	    {"",		"iso8859-1"},
-		    {"ansi-1251",	"cp1251"},
-	    {"ansi_x3.4-1968",	"iso8859-1"},
+    {"",		"iso8859-1"},
+    {"ansi-1251",	"cp1251"},
+    {"ansi_x3.4-1968",	"iso8859-1"},
     {"ascii",		"ascii"},
     {"big5",		"big5"},
     {"cp1250",		"cp1250"},
@@ -170,61 +170,61 @@ static const LocaleTable localeTable[] = {
     {"euc-cn",		"euc-cn"},
     {"euc-jp",		"euc-jp"},
     {"euc-kr",		"euc-kr"},
-		    {"eucjp",		"euc-jp"},
-		    {"euckr",		"euc-kr"},
-		    {"euctw",		"euc-cn"},
+    {"eucjp",		"euc-jp"},
+    {"euckr",		"euc-kr"},
+    {"euctw",		"euc-cn"},
     {"gb12345",		"gb12345"},
     {"gb1988",		"gb1988"},
     {"gb2312",		"gb2312"},
-		    {"gb2312-1980",	"gb2312"},
+    {"gb2312-1980",	"gb2312"},
     {"gb2312-raw",	"gb2312-raw"},
-		    {"greek8",		"cp869"},
-	    {"ibm1250",		"cp1250"},
-	    {"ibm1251",		"cp1251"},
-	    {"ibm1252",		"cp1252"},
-	    {"ibm1253",		"cp1253"},
-	    {"ibm1254",		"cp1254"},
-	    {"ibm1255",		"cp1255"},
-	    {"ibm1256",		"cp1256"},
-	    {"ibm1257",		"cp1257"},
-	    {"ibm1258",		"cp1258"},
-	    {"ibm437",		"cp437"},
-	    {"ibm737",		"cp737"},
-	    {"ibm775",		"cp775"},
-	    {"ibm850",		"cp850"},
-	    {"ibm852",		"cp852"},
-	    {"ibm855",		"cp855"},
-	    {"ibm857",		"cp857"},
-	    {"ibm860",		"cp860"},
-	    {"ibm861",		"cp861"},
-	    {"ibm862",		"cp862"},
-	    {"ibm863",		"cp863"},
-	    {"ibm864",		"cp864"},
-	    {"ibm865",		"cp865"},
-	    {"ibm866",		"cp866"},
-	    {"ibm869",		"cp869"},
-	    {"ibm874",		"cp874"},
-	    {"ibm932",		"cp932"},
-	    {"ibm936",		"cp936"},
-	    {"ibm949",		"cp949"},
-	    {"ibm950",		"cp950"},
-	    {"iso-2022",	"iso2022"},
-	    {"iso-2022-jp",	"iso2022-jp"},
-	    {"iso-2022-kr",	"iso2022-kr"},
-	    {"iso-8859-1",	"iso8859-1"},
-	    {"iso-8859-10",	"iso8859-10"},
-	    {"iso-8859-13",	"iso8859-13"},
-	    {"iso-8859-14",	"iso8859-14"},
-	    {"iso-8859-15",	"iso8859-15"},
-	    {"iso-8859-16",	"iso8859-16"},
-	    {"iso-8859-2",	"iso8859-2"},
-	    {"iso-8859-3",	"iso8859-3"},
-	    {"iso-8859-4",	"iso8859-4"},
-	    {"iso-8859-5",	"iso8859-5"},
-	    {"iso-8859-6",	"iso8859-6"},
-	    {"iso-8859-7",	"iso8859-7"},
-	    {"iso-8859-8",	"iso8859-8"},
-	    {"iso-8859-9",	"iso8859-9"},
+    {"greek8",		"cp869"},
+    {"ibm1250",		"cp1250"},
+    {"ibm1251",		"cp1251"},
+    {"ibm1252",		"cp1252"},
+    {"ibm1253",		"cp1253"},
+    {"ibm1254",		"cp1254"},
+    {"ibm1255",		"cp1255"},
+    {"ibm1256",		"cp1256"},
+    {"ibm1257",		"cp1257"},
+    {"ibm1258",		"cp1258"},
+    {"ibm437",		"cp437"},
+    {"ibm737",		"cp737"},
+    {"ibm775",		"cp775"},
+    {"ibm850",		"cp850"},
+    {"ibm852",		"cp852"},
+    {"ibm855",		"cp855"},
+    {"ibm857",		"cp857"},
+    {"ibm860",		"cp860"},
+    {"ibm861",		"cp861"},
+    {"ibm862",		"cp862"},
+    {"ibm863",		"cp863"},
+    {"ibm864",		"cp864"},
+    {"ibm865",		"cp865"},
+    {"ibm866",		"cp866"},
+    {"ibm869",		"cp869"},
+    {"ibm874",		"cp874"},
+    {"ibm932",		"cp932"},
+    {"ibm936",		"cp936"},
+    {"ibm949",		"cp949"},
+    {"ibm950",		"cp950"},
+    {"iso-2022",	"iso2022"},
+    {"iso-2022-jp",	"iso2022-jp"},
+    {"iso-2022-kr",	"iso2022-kr"},
+    {"iso-8859-1",	"iso8859-1"},
+    {"iso-8859-10",	"iso8859-10"},
+    {"iso-8859-13",	"iso8859-13"},
+    {"iso-8859-14",	"iso8859-14"},
+    {"iso-8859-15",	"iso8859-15"},
+    {"iso-8859-16",	"iso8859-16"},
+    {"iso-8859-2",	"iso8859-2"},
+    {"iso-8859-3",	"iso8859-3"},
+    {"iso-8859-4",	"iso8859-4"},
+    {"iso-8859-5",	"iso8859-5"},
+    {"iso-8859-6",	"iso8859-6"},
+    {"iso-8859-7",	"iso8859-7"},
+    {"iso-8859-8",	"iso8859-8"},
+    {"iso-8859-9",	"iso8859-9"},
     {"iso2022",		"iso2022"},
     {"iso2022-jp",	"iso2022-jp"},
     {"iso2022-kr",	"iso2022-kr"},
@@ -242,47 +242,47 @@ static const LocaleTable localeTable[] = {
     {"iso8859-7",	"iso8859-7"},
     {"iso8859-8",	"iso8859-8"},
     {"iso8859-9",	"iso8859-9"},
-		    {"iso88591",	"iso8859-1"},
-		    {"iso885915",	"iso8859-15"},
-		    {"iso88592",	"iso8859-2"},
-		    {"iso88595",	"iso8859-5"},
-		    {"iso88596",	"iso8859-6"},
-		    {"iso88597",	"iso8859-7"},
-		    {"iso88598",	"iso8859-8"},
-		    {"iso88599",	"iso8859-9"},
+    {"iso88591",	"iso8859-1"},
+    {"iso885915",	"iso8859-15"},
+    {"iso88592",	"iso8859-2"},
+    {"iso88595",	"iso8859-5"},
+    {"iso88596",	"iso8859-6"},
+    {"iso88597",	"iso8859-7"},
+    {"iso88598",	"iso8859-8"},
+    {"iso88599",	"iso8859-9"},
 #ifdef hpux
-		    {"ja",		"shiftjis"},
+    {"ja",		"shiftjis"},
 #else
-		    {"ja",		"euc-jp"},
+    {"ja",		"euc-jp"},
 #endif
-		    {"ja_jp",		"euc-jp"},
-		    {"ja_jp.euc",	"euc-jp"},
-		    {"ja_jp.eucjp",	"euc-jp"},
-		    {"ja_jp.jis",	"iso2022-jp"},
-		    {"ja_jp.mscode",	"shiftjis"},
-		    {"ja_jp.sjis",	"shiftjis"},
-		    {"ja_jp.ujis",	"euc-jp"},
-		    {"japan",		"euc-jp"},
+    {"ja_jp",		"euc-jp"},
+	{"ja_jp.euc",	"euc-jp"},
+    {"ja_jp.eucjp",	"euc-jp"},
+    {"ja_jp.jis",	"iso2022-jp"},
+    {"ja_jp.mscode",	"shiftjis"},
+    {"ja_jp.sjis",	"shiftjis"},
+    {"ja_jp.ujis",	"euc-jp"},
+    {"japan",		"euc-jp"},
 #ifdef hpux
-		    {"japanese",	"shiftjis"},
+    {"japanese",	"shiftjis"},
 #else
-		    {"japanese",	"euc-jp"},
+    {"japanese",	"euc-jp"},
 #endif
-		    {"japanese-sjis",	"shiftjis"},
-		    {"japanese-ujis",	"euc-jp"},
-		    {"japanese.euc",	"euc-jp"},
-		    {"japanese.sjis",	"shiftjis"},
+    {"japanese-sjis",	"shiftjis"},
+    {"japanese-ujis",	"euc-jp"},
+    {"japanese.euc",	"euc-jp"},
+    {"japanese.sjis",	"shiftjis"},
     {"jis0201",		"jis0201"},
     {"jis0208",		"jis0208"},
     {"jis0212",		"jis0212"},
-		    {"jp_jp",		"shiftjis"},
-		    {"ko",		"euc-kr"},
-		    {"ko_kr",		"euc-kr"},
-		    {"ko_kr.euc",	"euc-kr"},
-		    {"ko_kw.euckw",	"euc-kr"},
+    {"jp_jp",		"shiftjis"},
+    {"ko",		"euc-kr"},
+    {"ko_kr",		"euc-kr"},
+    {"ko_kr.euc",	"euc-kr"},
+    {"ko_kw.euckw",	"euc-kr"},
     {"koi8-r",		"koi8-r"},
     {"koi8-u",		"koi8-u"},
-		    {"korean",		"euc-kr"},
+    {"korean",		"euc-kr"},
     {"ksc5601",		"ksc5601"},
     {"maccenteuro",	"macCentEuro"},
     {"maccroatian",	"macCroatian"},
@@ -296,23 +296,23 @@ static const LocaleTable localeTable[] = {
     {"macthai",		"macThai"},
     {"macturkish",	"macTurkish"},
     {"macukraine",	"macUkraine"},
-		    {"roman8",		"iso8859-1"},
-		    {"ru",		"iso8859-5"},
-		    {"ru_ru",		"iso8859-5"},
-		    {"ru_su",		"iso8859-5"},
+    {"roman8",		"iso8859-1"},
+    {"ru",		"iso8859-5"},
+    {"ru_ru",		"iso8859-5"},
+    {"ru_su",		"iso8859-5"},
     {"shiftjis",	"shiftjis"},
-		    {"sjis",		"shiftjis"},
+    {"sjis",		"shiftjis"},
     {"symbol",		"symbol"},
     {"tis-620",		"tis-620"},
-		    {"tis620",		"tis-620"},
-		    {"turkish8",	"cp857"},
-		    {"utf8",		"utf-8"},
-		    {"zh",		"cp936"},
-		    {"zh_cn.gb2312",	"euc-cn"},
-		    {"zh_cn.gbk",	"euc-cn"},
-		    {"zh_cz.gb2312",	"euc-cn"},
-		    {"zh_tw",		"euc-tw"},
-		    {"zh_tw.big5",	"big5"},
+    {"tis620",		"tis-620"},
+    {"turkish8",	"cp857"},
+    {"utf8",		"utf-8"},
+    {"zh",		"cp936"},
+    {"zh_cn.gb2312",	"euc-cn"},
+    {"zh_cn.gbk",	"euc-cn"},
+    {"zh_cz.gb2312",	"euc-cn"},
+    {"zh_tw",		"euc-tw"},
+    {"zh_tw.big5",	"big5"},
 };
 
 #ifdef HAVE_COREFOUNDATION
@@ -551,7 +551,7 @@ TclpInitLibraryPath(
 
     *encodingPtr = Tcl_GetEncoding(NULL, NULL);
     str = Tcl_GetStringFromObj(pathPtr, lengthPtr);
-    *valuePtr = ckalloc((*lengthPtr) + 1);
+    *valuePtr = (char *)ckalloc((*lengthPtr) + 1);
     memcpy(*valuePtr, str, (size_t)(*lengthPtr)+1);
     Tcl_DecrRefCount(pathPtr);
 }
@@ -589,12 +589,6 @@ TclpSetInitialEncodings(void)
     Tcl_DStringFree(&encodingName);
 }
 
-void
-TclpSetInterfaces(void)
-{
-    /* do nothing */
-}
-
 static const char *
 SearchKnownEncodings(
     const char *encoding)
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index aeadf49..0a5712a 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -32,7 +32,7 @@ typedef struct FileHandler {
 				 * for this file. */
     Tcl_FileProc *proc;		/* Function to call, in the style of
 				 * Tcl_CreateFileHandler. */
-    ClientData clientData;	/* Argument to pass to proc. */
+    void *clientData;	/* Argument to pass to proc. */
     struct FileHandler *nextPtr;/* Next in list of all files we care about. */
 } FileHandler;
 
@@ -94,16 +94,17 @@ typedef struct ThreadSpecificData {
 				 * 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 *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 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. */
@@ -171,12 +172,14 @@ static int notifierThreadRunning = 0;
 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.
+ * 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
@@ -187,7 +190,6 @@ static pthread_cond_t notifierCV = PTHREAD_COND_INITIALIZER;
  */
 
 static Tcl_ThreadId notifierThread;
-
 #endif /* TCL_THREADS */
 
 /*
@@ -195,9 +197,9 @@ static Tcl_ThreadId notifierThread;
  */
 
 #ifdef TCL_THREADS
-static void	NotifierThreadProc(ClientData clientData);
+static void	NotifierThreadProc(void *clientData);
 #if defined(HAVE_PTHREAD_ATFORK)
-static int	atForkInit = AT_FORK_INIT_VALUE;
+static int atForkInit = AT_FORK_INIT_VALUE;
 static void	AtForkPrepare(void);
 static void	AtForkParent(void);
 static void	AtForkChild(void);
@@ -211,13 +213,14 @@ static int	FileHandlerEventProc(Tcl_Event *evPtr, int flags);
 
 #if defined(TCL_THREADS) && defined(__CYGWIN__)
 typedef struct {
-    void *hwnd;
-    unsigned int *message;
-    int wParam;
-    int lParam;
-    int time;
-    int x;
+    void *hwnd;			/* Messaging window. */
+    unsigned int *message;	/* Message payload. */
+    size_t wParam;			/* Event-specific "word" parameter. */
+    size_t lParam;			/* Event-specific "long" parameter. */
+    int time;			/* Event timestamp. */
+    int x;			/* Event location (where meaningful). */
     int y;
+    int lPrivate;
 } MSG;
 
 typedef struct {
@@ -229,7 +232,7 @@ typedef struct {
     void *hIcon;
     void *hCursor;
     void *hbrBackground;
-    void *lpszMenuName;
+    const void *lpszMenuName;
     const void *lpszClassName;
 } WNDCLASSW;
 
@@ -237,13 +240,13 @@ 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 *);
+			    unsigned int, int, int, int, int, void *, void *, void *, void *);
+extern unsigned int __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 void __stdcall	MsgWaitForMultipleObjects(unsigned int, void *,
+			    unsigned char, unsigned int, unsigned int);
 extern unsigned char __stdcall	PeekMessageW(MSG *, void *, int, int, int);
 extern unsigned char __stdcall	PostMessageW(void *, unsigned int, void *,
 				    void *);
@@ -256,8 +259,8 @@ extern unsigned char __stdcall	TranslateMessage(const MSG *);
  * Threaded-cygwin specific constants and functions in this file:
  */
 
-static const WCHAR NotfyClassName[] = L"TclNotifier";
-static DWORD __stdcall	NotifierProc(void *hwnd, unsigned int message,
+static const wchar_t *NotfyClassName = L"TclNotifier";
+static unsigned int __stdcall	NotifierProc(void *hwnd, unsigned int message,
 			    void *wParam, void *lParam);
 #endif /* TCL_THREADS && __CYGWIN__ */
 
@@ -321,7 +324,7 @@ StartNotifierThread(const char *proc)
  *----------------------------------------------------------------------
  */
 
-ClientData
+void *
 Tcl_InitNotifier(void)
 {
     if (tclNotifierHooks.initNotifierProc) {
@@ -337,23 +340,23 @@ Tcl_InitNotifier(void)
 	 */
 	if (tsdPtr->waitCVinitialized == 0) {
 #ifdef __CYGWIN__
-	    WNDCLASSW class;
-
-	    class.style = 0;
-	    class.cbClsExtra = 0;
-	    class.cbWndExtra = 0;
-	    class.hInstance = TclWinGetTclInstance();
-	    class.hbrBackground = NULL;
-	    class.lpszMenuName = NULL;
-	    class.lpszClassName = NotfyClassName;
-	    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);
+	    WNDCLASSW clazz;
+
+	    clazz.style = 0;
+	    clazz.cbClsExtra = 0;
+	    clazz.cbWndExtra = 0;
+	    clazz.hInstance = TclWinGetTclInstance();
+	    clazz.hbrBackground = NULL;
+	    clazz.lpszMenuName = NULL;
+	    clazz.lpszClassName = NotfyClassName;
+	    clazz.lpfnWndProc = (void *)NotifierProc;
+	    clazz.hIcon = NULL;
+	    clazz.hCursor = NULL;
+
+	    RegisterClassW(&clazz);
+	    tsdPtr->hwnd = CreateWindowExW(NULL, clazz.lpszClassName,
+		    clazz.lpszClassName, 0, 0, 0, 0, 0, NULL, NULL,
+		    clazz.hInstance, NULL);
 	    tsdPtr->event = CreateEventW(NULL, 1 /* manual */,
 		    0 /* !signaled */, NULL);
 #else
@@ -380,7 +383,6 @@ Tcl_InitNotifier(void)
 #endif /* HAVE_PTHREAD_ATFORK */
 
 	notifierCount++;
-
 	pthread_mutex_unlock(&notifierInitMutex);
 
 #endif /* TCL_THREADS */
@@ -408,7 +410,7 @@ Tcl_InitNotifier(void)
 
 void
 Tcl_FinalizeNotifier(
-    ClientData clientData)		/* Not used. */
+    void *clientData)
 {
     if (tclNotifierHooks.finalizeNotifierProc) {
 	tclNotifierHooks.finalizeNotifierProc(clientData);
@@ -425,28 +427,25 @@ Tcl_FinalizeNotifier(
 	 * pipe and wait for the background thread to terminate.
 	 */
 
-	if (notifierCount == 0) {
+	if (notifierCount == 0 && 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 (triggerPipe != -1) {
-		if (write(triggerPipe, "q", 1) != 1) {
+		if (result) {
 		    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;
+			    "unable to join notifier thread");
 		}
+		notifierThreadRunning = 0;
 	    }
 	}
 
@@ -488,14 +487,14 @@ Tcl_FinalizeNotifier(
 
 void
 Tcl_AlertNotifier(
-    ClientData clientData)
+    void *clientData)
 {
     if (tclNotifierHooks.alertNotifierProc) {
 	tclNotifierHooks.alertNotifierProc(clientData);
 	return;
     } else {
 #ifdef TCL_THREADS
-	ThreadSpecificData *tsdPtr = clientData;
+	ThreadSpecificData *tsdPtr = (ThreadSpecificData *)clientData;
 
 	pthread_mutex_lock(&notifierMutex);
 	tsdPtr->eventReady = 1;
@@ -600,7 +599,7 @@ Tcl_CreateFileHandler(
 				 * called. */
     Tcl_FileProc *proc,		/* Function to call for each selected
 				 * event. */
-    ClientData clientData)	/* Arbitrary data to pass to proc. */
+    void *clientData)	/* Arbitrary data to pass to proc. */
 {
     if (tclNotifierHooks.createFileHandlerProc) {
 	tclNotifierHooks.createFileHandlerProc(fd, mask, proc, clientData);
@@ -616,7 +615,7 @@ Tcl_CreateFileHandler(
 	    }
 	}
 	if (filePtr == NULL) {
-	    filePtr = ckalloc(sizeof(FileHandler));
+	    filePtr = (FileHandler *)ckalloc(sizeof(FileHandler));
 	    filePtr->fd = fd;
 	    filePtr->readyMask = 0;
 	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
@@ -815,7 +814,7 @@ FileHandlerEventProc(
 
 #if defined(TCL_THREADS) && defined(__CYGWIN__)
 
-static DWORD __stdcall
+static unsigned int __stdcall
 NotifierProc(
     void *hwnd,
     unsigned int message,
@@ -866,12 +865,13 @@ Tcl_WaitForEvent(
 	FileHandler *filePtr;
 	int mask;
 	Tcl_Time vTime;
+	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 #ifdef TCL_THREADS
 	int waitForFiles;
 #   ifdef __CYGWIN__
 	MSG msg;
 #   endif /* __CYGWIN__ */
-#else
+#else /* !TCL_THREADS */
 	/*
 	 * Impl. notes: timeout & timeoutPtr are used if, and only if threads
 	 * are not enabled. They are the arguments for the regular select()
@@ -881,7 +881,6 @@ Tcl_WaitForEvent(
 	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
@@ -986,7 +985,7 @@ Tcl_WaitForEvent(
 	if (!tsdPtr->eventReady) {
 #ifdef __CYGWIN__
 	    if (!PeekMessageW(&msg, NULL, 0, 0, 0)) {
-		DWORD timeout;
+		unsigned int timeout;
 
 		if (timePtr) {
 		    timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
@@ -997,18 +996,19 @@ Tcl_WaitForEvent(
 		MsgWaitForMultipleObjects(1, &tsdPtr->event, 0, timeout, 1279);
 		pthread_mutex_lock(&notifierMutex);
 	    }
-#else
+#else /* !__CYGWIN__ */
 	    if (timePtr != NULL) {
-	       Tcl_Time now;
-	       struct timespec ptime;
+		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);
+		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);
+		pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex, &ptime);
 	    } else {
-	       pthread_cond_wait(&tsdPtr->waitCV, &notifierMutex);
+		pthread_cond_wait(&tsdPtr->waitCV, &notifierMutex);
 	    }
 #endif /* __CYGWIN__ */
 	}
@@ -1020,12 +1020,12 @@ Tcl_WaitForEvent(
 	     * Retrieve and dispatch the message.
 	     */
 
-	    DWORD result = GetMessageW(&msg, NULL, 0, 0);
+	    unsigned int result = GetMessageW(&msg, NULL, 0, 0);
 
 	    if (result == 0) {
 		PostQuitMessage(msg.wParam);
 		/* What to do here? */
-	    } else if (result != (DWORD) -1) {
+	    } else if (result != (unsigned int) -1) {
 		TranslateMessage(&msg);
 		DispatchMessageW(&msg);
 	    }
@@ -1056,8 +1056,7 @@ Tcl_WaitForEvent(
 			"unable to write to triggerPipe");
 	    }
 	}
-
-#else
+#else /* !TCL_THREADS */
 	tsdPtr->readyMasks = tsdPtr->checkMasks;
 	numFound = select(tsdPtr->numFdBits, &tsdPtr->readyMasks.readable,
 		&tsdPtr->readyMasks.writable, &tsdPtr->readyMasks.exception,
@@ -1103,7 +1102,7 @@ Tcl_WaitForEvent(
 
 	    if (filePtr->readyMask == 0) {
 		FileHandlerEvent *fileEvPtr =
-			ckalloc(sizeof(FileHandlerEvent));
+			(FileHandlerEvent *)ckalloc(sizeof(FileHandlerEvent));
 
 		fileEvPtr->header.proc = FileHandlerEventProc;
 		fileEvPtr->fd = filePtr->fd;
@@ -1145,17 +1144,19 @@ Tcl_WaitForEvent(
 
 static void
 NotifierThreadProc(
-    ClientData clientData)	/* Not used. */
+    void *dummy)	/* Not used. */
 {
     ThreadSpecificData *tsdPtr;
     fd_set readableMask;
     fd_set writableMask;
     fd_set exceptionMask;
-    int fds[2];
-    int i, numFdBits = 0, receivePipe;
+    int i;
+    int fds[2], receivePipe;
     long found;
-    struct timeval poll = {0., 0.}, *timePtr;
+    struct timeval poll = {0, 0}, *timePtr;
     char buf[2];
+    int numFdBits = 0;
+    (void)dummy;
 
     if (pipe(fds) != 0) {
 	Tcl_Panic("NotifierThreadProc: %s", "could not create trigger pipe");
@@ -1204,7 +1205,7 @@ NotifierThreadProc(
 	FD_ZERO(&exceptionMask);
 
 	/*
-	 * Compute the logical OR of the select masks from all the waiting
+	 * Compute the logical OR of the masks from all the waiting
 	 * notifiers.
 	 */
 
diff --git a/win/tclWin32Dll.c b/win/tclWin32Dll.c
index ccc1dae..c33787d 100644
--- a/win/tclWin32Dll.c
+++ b/win/tclWin32Dll.c
@@ -262,27 +262,6 @@ TclWinNoBackslash(
 /*
  *---------------------------------------------------------------------------
  *
- * TclpSetInterfaces --
- *
- *	A helper proc.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	None.
- *
- *---------------------------------------------------------------------------
- */
-
-void
-TclpSetInterfaces(void)
-{
-}
-
-/*
- *---------------------------------------------------------------------------
- *
  * TclWinEncodingsCleanup --
  *
  *	Called during finalization to free up any encodings we use.
@@ -463,8 +442,8 @@ TclWinDriveLetterForVolMountPoint(
 		}
 	    }
 	    if (!alreadyStored) {
-		dlPtr2 = ckalloc(sizeof(MountPointMap));
-		dlPtr2->volumeName = TclNativeDupInternalRep(Target);
+		dlPtr2 = (MountPointMap *)ckalloc(sizeof(MountPointMap));
+		dlPtr2->volumeName = (WCHAR *)TclNativeDupInternalRep(Target);
 		dlPtr2->driveLetter = (char) drive[0];
 		dlPtr2->nextPtr = driveLetterLookup;
 		driveLetterLookup = dlPtr2;
@@ -489,8 +468,8 @@ TclWinDriveLetterForVolMountPoint(
      * that fact and store '-1' so we don't have to look it up each time.
      */
 
-    dlPtr2 = ckalloc(sizeof(MountPointMap));
-    dlPtr2->volumeName = TclNativeDupInternalRep((ClientData) mountPoint);
+    dlPtr2 = (MountPointMap *)ckalloc(sizeof(MountPointMap));
+    dlPtr2->volumeName = (WCHAR *)TclNativeDupInternalRep((void *)mountPoint);
     dlPtr2->driveLetter = -1;
     dlPtr2->nextPtr = driveLetterLookup;
     driveLetterLookup = dlPtr2;
diff --git a/win/tclWinInit.c b/win/tclWinInit.c
index 558ffc4..2e4694a 100644
--- a/win/tclWinInit.c
+++ b/win/tclWinInit.c
@@ -235,7 +235,7 @@ TclpInitLibraryPath(
 
     *encodingPtr = NULL;
     bytes = Tcl_GetStringFromObj(pathPtr, lengthPtr);
-    *valuePtr = ckalloc((*lengthPtr) + 1);
+    *valuePtr = (char *)ckalloc((*lengthPtr) + 1);
     memcpy(*valuePtr, bytes, (size_t)(*lengthPtr)+1);
     Tcl_DecrRefCount(pathPtr);
 }
@@ -379,9 +379,9 @@ InitializeDefaultLibraryDir(
     TclWinNoBackslash(name);
     sprintf(end + 1, "lib/tcl%s", TCL_VERSION);
     *lengthPtr = strlen(name);
-    *valuePtr = ckalloc(*lengthPtr + 1);
+    *valuePtr = (char *)ckalloc(*lengthPtr + 1);
     *encodingPtr = NULL;
-    memcpy(*valuePtr, name, (size_t) *lengthPtr + 1);
+    memcpy(*valuePtr, name, *lengthPtr + 1);
 }
 
 /*
@@ -430,7 +430,7 @@ InitializeSourceLibraryDir(
     TclWinNoBackslash(name);
     sprintf(end + 1, "../library");
     *lengthPtr = strlen(name);
-    *valuePtr = ckalloc(*lengthPtr + 1);
+    *valuePtr = (char *)ckalloc(*lengthPtr + 1);
     *encodingPtr = NULL;
     memcpy(*valuePtr, name, (size_t) *lengthPtr + 1);
 }
@@ -494,7 +494,6 @@ TclpSetInitialEncodings(void)
 {
     Tcl_DString encodingName;
 
-    TclpSetInterfaces();
     Tcl_SetSystemEncoding(NULL,
 	    Tcl_GetEncodingNameFromEnvironment(&encodingName));
     Tcl_DStringFree(&encodingName);
@@ -503,7 +502,7 @@ TclpSetInitialEncodings(void)
 void TclWinSetInterfaces(
     int dummy)			/* Not used. */
 {
-    TclpSetInterfaces();
+    (void)dummy;
 }
 
 const char *
@@ -712,7 +711,7 @@ TclpFindVariable(
      */
 
     length = strlen(name);
-    nameUpper = ckalloc(length + 1);
+    nameUpper = (char *)ckalloc(length + 1);
     memcpy(nameUpper, name, (size_t) length+1);
     Tcl_UtfToUpper(nameUpper);