From b555fa4d44d0b13c0c4e61643e22f6c3479baf4e Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Tue, 28 Jan 2014 11:04:57 +0000
Subject: WIP

---
 generic/tclIO.c | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 13494ca..fdb0ddd 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -3779,6 +3779,74 @@ WriteChars(
     translate = (statePtr->flags & CHANNEL_LINEBUFFERED)
 	|| (statePtr->outputTranslation != TCL_TRANSLATE_LF);
 
+#if 0
+    consumedSomething = 1;
+    while (consumedSomething && (srcLen + saved + endEncoding > 0)) {
+	void *lastNewLine;
+	int srcLimit;
+	
+	/* Get space to write into */
+	bufPtr = statePtr->curOutPtr;
+	if (bufPtr == NULL) {
+	    bufPtr = AllocChannelBuffer(statePtr->bufSize);
+	    statePtr->curOutPtr = bufPtr;
+	    if (saved) {
+		/*
+		 * Here's some translated bytes left over from the last buffer
+		 * that we need to stick at the beginning of this buffer.
+		 */
+
+		memcpy(InsertPoint(bufPtr), safe, (size_t) saved);
+		bufPtr->nextAdded += saved;
+		saved = 0;
+	    }
+	}
+	dst = InsertPoint(bufPtr);
+	dstLen = SpaceLeft(bufPtr);
+
+	/*
+	 * We have dstLen bytes to write to.  The most source bytes
+	 * that could possibly fill that is TCL_UTF_MAX * dstLen.
+	 */
+
+	srcLimit = TCL_UTF_MAX * dstLen;
+	if (srcLen < srcLimit) {
+	    srcLimit = srcLen;
+	}
+	lastNewLine = memchr(src, '\n', srcLimit);
+
+	if (lastNewLine) {
+	    srcLimit = lastNewLine - src;
+	}
+	
+	result = Tcl_UtfToExternal(NULL, encoding, src, srcLimit,
+		statePtr->outputEncodingFlags,
+		&statePtr->outputEncodingState, dst,
+		dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
+
+	statePtr->outputEncodingFlags &= ~TCL_ENCODING_START;
+	
+	if ((result != 0) && (srcRead + dstWrote == 0)) {
+	    fprintf(stdout, "WDTH?\n"); fflush(stdout);
+	}
+	bufPtr->nextAdded += dstWrote;
+	if (IsBufferOverflowing(bufPtr)) {
+	    /*
+	     * When translating from UTF-8 to external encoding, we
+	     * allowed the translation to produce a character that crossed
+	     * the end of the output buffer, so that we would get a
+	     * completely full buffer before flushing it. The extra bytes
+	     * will be moved to the beginning of the next buffer.
+	     */
+
+	    saved = -SpaceLeft(bufPtr);
+	    memcpy(safe, dst + dstLen, (size_t) saved);
+	    bufPtr->nextAdded = bufPtr->bufLength;
+	}
+	
+    
+    }
+#else
     /*
      * Loop over all UTF-8 characters in src, storing them in staging buffer
      * with proper EOL translation.
@@ -3933,6 +4001,7 @@ WriteChars(
 	    }
 	}
     }
+#endif
 
     /*
      * If nothing was written and it happened because there was no progress in
-- 
cgit v0.12


From 15c8e0fd00cb9a49203a6de6cd05ec758daf519e Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Tue, 28 Jan 2014 18:51:59 +0000
Subject: Working code with no staging buffer use.

---
 generic/tclIO.c | 128 ++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 97 insertions(+), 31 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index fdb0ddd..7203739 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -3756,18 +3756,21 @@ WriteChars(
     char *dst, *stage;
     int saved, savedLF, sawLF, total, dstLen, stageMax, dstWrote;
     int stageLen, toWrite, stageRead, endEncoding, result;
-    int consumedSomething, translate;
+    int consumedSomething, translate, flushed, needNlFlush;
     Tcl_Encoding encoding;
     char safe[BUFFER_PADDING];
+    char *nextNewLine = NULL;
 
     if (srcLen) {
         WillWrite(chanPtr);
     }
 
+    flushed = 0;
     total = 0;
     sawLF = 0;
     savedLF = 0;
     saved = 0;
+    needNlFlush = 0;
     encoding = statePtr->encoding;
 
     /*
@@ -3779,46 +3782,39 @@ WriteChars(
     translate = (statePtr->flags & CHANNEL_LINEBUFFERED)
 	|| (statePtr->outputTranslation != TCL_TRANSLATE_LF);
 
-#if 0
+#if 1
+    if (translate) {
+	nextNewLine = memchr(src, '\n', srcLen);
+    }
     consumedSomething = 1;
     while (consumedSomething && (srcLen + saved + endEncoding > 0)) {
-	void *lastNewLine;
-	int srcLimit;
+	int srcRead;
+	int srcLimit = srcLen;
+
+	consumedSomething = 0;
+	if (nextNewLine) {
+	    srcLimit = nextNewLine - src;
+	}
 	
 	/* Get space to write into */
 	bufPtr = statePtr->curOutPtr;
 	if (bufPtr == NULL) {
 	    bufPtr = AllocChannelBuffer(statePtr->bufSize);
 	    statePtr->curOutPtr = bufPtr;
-	    if (saved) {
-		/*
-		 * Here's some translated bytes left over from the last buffer
-		 * that we need to stick at the beginning of this buffer.
-		 */
+	}
+	if (saved) {
+	    /*
+	     * Here's some translated bytes left over from the last buffer
+	     * that we need to stick at the beginning of this buffer.
+	     */
 
-		memcpy(InsertPoint(bufPtr), safe, (size_t) saved);
-		bufPtr->nextAdded += saved;
-		saved = 0;
-	    }
+	    memcpy(InsertPoint(bufPtr), safe, (size_t) saved);
+	    bufPtr->nextAdded += saved;
+	    saved = 0;
 	}
 	dst = InsertPoint(bufPtr);
 	dstLen = SpaceLeft(bufPtr);
 
-	/*
-	 * We have dstLen bytes to write to.  The most source bytes
-	 * that could possibly fill that is TCL_UTF_MAX * dstLen.
-	 */
-
-	srcLimit = TCL_UTF_MAX * dstLen;
-	if (srcLen < srcLimit) {
-	    srcLimit = srcLen;
-	}
-	lastNewLine = memchr(src, '\n', srcLimit);
-
-	if (lastNewLine) {
-	    srcLimit = lastNewLine - src;
-	}
-	
 	result = Tcl_UtfToExternal(NULL, encoding, src, srcLimit,
 		statePtr->outputEncodingFlags,
 		&statePtr->outputEncodingState, dst,
@@ -3827,9 +3823,59 @@ WriteChars(
 	statePtr->outputEncodingFlags &= ~TCL_ENCODING_START;
 	
 	if ((result != 0) && (srcRead + dstWrote == 0)) {
-	    fprintf(stdout, "WDTH?\n"); fflush(stdout);
+	    /* We're reading from invalid/incomplete UTF-8 */
+	    break;
 	}
+
+	consumedSomething = 1;
 	bufPtr->nextAdded += dstWrote;
+	src += srcRead;
+	srcLen -= srcRead;
+	total += dstWrote;
+	dst += dstWrote;
+	dstLen -= dstWrote;
+
+	if (src == nextNewLine && dstLen > 0) {
+	    static char crln[3] = "\r\n";
+	    char *nl = NULL;
+	    int nlLen = 0;
+
+	    switch (statePtr->outputTranslation) {
+	    case TCL_TRANSLATE_LF:
+		nl = crln + 1;
+		nlLen = 1;
+		break;
+	    case TCL_TRANSLATE_CR:
+		nl = crln;
+		nlLen = 1;
+		break;
+	    case TCL_TRANSLATE_CRLF:
+		nl = crln;
+		nlLen = 2;
+		break;
+	    default:
+		Tcl_Panic("unknown output translation requested");
+		break;
+	    }
+	
+	    result |= Tcl_UtfToExternal(NULL, encoding, nl, nlLen,
+		statePtr->outputEncodingFlags,
+		&statePtr->outputEncodingState, dst,
+		dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
+
+	    if (srcRead != nlLen) {
+		Tcl_Panic("Can This Happen?");
+	    }
+
+	    bufPtr->nextAdded += dstWrote;
+	    src++;
+	    srcLen--;
+	    total += dstWrote;
+	    dst += dstWrote;
+	    dstLen -= dstWrote;
+	    nextNewLine = memchr(src, '\n', srcLen);
+	    needNlFlush = 1;
+	}
 	if (IsBufferOverflowing(bufPtr)) {
 	    /*
 	     * When translating from UTF-8 to external encoding, we
@@ -3843,8 +3889,28 @@ WriteChars(
 	    memcpy(safe, dst + dstLen, (size_t) saved);
 	    bufPtr->nextAdded = bufPtr->bufLength;
 	}
-	
-    
+
+	if ((srcLen + saved == 0) && (result == 0)) {
+	    endEncoding = 0;
+	}
+
+	/* FLUSH ! */
+	if (IsBufferFull(bufPtr)) {
+	    if (FlushChannel(NULL, chanPtr, 0) != 0) {
+		return -1;
+	    }
+	    flushed += statePtr->bufSize;
+	    if (saved == 0 || src[-1] != '\n') {
+		needNlFlush = 0;
+	    }
+	}
+    }
+    if ((flushed < total) && (statePtr->flags & CHANNEL_UNBUFFERED ||
+	    (needNlFlush && statePtr->flags & CHANNEL_LINEBUFFERED))) {
+	SetFlag(statePtr, BUFFER_READY);
+	if (FlushChannel(NULL, chanPtr, 0) != 0) {
+	    return -1;
+	}
     }
 #else
     /*
-- 
cgit v0.12


From 589975911949b9661152610ca04cf5e8e233a109 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Tue, 28 Jan 2014 20:19:39 +0000
Subject: tidy things up

---
 generic/tclIO.c | 211 +++++---------------------------------------------------
 1 file changed, 17 insertions(+), 194 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 7203739..c7c11e7 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -3752,46 +3752,30 @@ WriteChars(
 {
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
-    ChannelBuffer *bufPtr;
-    char *dst, *stage;
-    int saved, savedLF, sawLF, total, dstLen, stageMax, dstWrote;
-    int stageLen, toWrite, stageRead, endEncoding, result;
-    int consumedSomething, translate, flushed, needNlFlush;
-    Tcl_Encoding encoding;
-    char safe[BUFFER_PADDING];
     char *nextNewLine = NULL;
+    int endEncoding, saved = 0, total = 0, flushed = 0, needNlFlush = 0;
+    Tcl_Encoding encoding = statePtr->encoding;
 
     if (srcLen) {
         WillWrite(chanPtr);
     }
 
-    flushed = 0;
-    total = 0;
-    sawLF = 0;
-    savedLF = 0;
-    saved = 0;
-    needNlFlush = 0;
-    encoding = statePtr->encoding;
-
     /*
      * Write the terminated escape sequence even if srcLen is 0.
      */
 
     endEncoding = ((statePtr->outputEncodingFlags & TCL_ENCODING_END) != 0);
 
-    translate = (statePtr->flags & CHANNEL_LINEBUFFERED)
-	|| (statePtr->outputTranslation != TCL_TRANSLATE_LF);
-
-#if 1
-    if (translate) {
+    if ((statePtr->flags & CHANNEL_LINEBUFFERED)
+	    || (statePtr->outputTranslation != TCL_TRANSLATE_LF)) {
 	nextNewLine = memchr(src, '\n', srcLen);
     }
-    consumedSomething = 1;
-    while (consumedSomething && (srcLen + saved + endEncoding > 0)) {
-	int srcRead;
-	int srcLimit = srcLen;
 
-	consumedSomething = 0;
+    while (srcLen + saved + endEncoding > 0) {
+	ChannelBuffer *bufPtr;
+	char *dst, safe[BUFFER_PADDING];
+	int result, srcRead, dstLen, dstWrote, srcLimit = srcLen;
+
 	if (nextNewLine) {
 	    srcLimit = nextNewLine - src;
 	}
@@ -3820,14 +3804,18 @@ WriteChars(
 		&statePtr->outputEncodingState, dst,
 		dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
 
+	/* See chan-io-1.[89]. Tcl Bug 506297. */
 	statePtr->outputEncodingFlags &= ~TCL_ENCODING_START;
 	
-	if ((result != 0) && (srcRead + dstWrote == 0)) {
+	if ((result != TCL_OK) && (srcRead + dstWrote == 0)) {
 	    /* We're reading from invalid/incomplete UTF-8 */
+	    if (total == 0) {
+		Tcl_SetErrno(EINVAL);
+		return -1;
+	    }
 	    break;
 	}
 
-	consumedSomething = 1;
 	bufPtr->nextAdded += dstWrote;
 	src += srcRead;
 	srcLen -= srcRead;
@@ -3876,6 +3864,7 @@ WriteChars(
 	    nextNewLine = memchr(src, '\n', srcLen);
 	    needNlFlush = 1;
 	}
+
 	if (IsBufferOverflowing(bufPtr)) {
 	    /*
 	     * When translating from UTF-8 to external encoding, we
@@ -3890,11 +3879,10 @@ WriteChars(
 	    bufPtr->nextAdded = bufPtr->bufLength;
 	}
 
-	if ((srcLen + saved == 0) && (result == 0)) {
+	if ((srcLen + saved == 0) && (result == TCL_OK)) {
 	    endEncoding = 0;
 	}
 
-	/* FLUSH ! */
 	if (IsBufferFull(bufPtr)) {
 	    if (FlushChannel(NULL, chanPtr, 0) != 0) {
 		return -1;
@@ -3912,172 +3900,7 @@ WriteChars(
 	    return -1;
 	}
     }
-#else
-    /*
-     * Loop over all UTF-8 characters in src, storing them in staging buffer
-     * with proper EOL translation.
-     */
-
-    consumedSomething = 1;
-    while (consumedSomething && (srcLen + savedLF + endEncoding > 0)) {
-	consumedSomething = 0;
-
-	if (translate) {
-	    stage = statePtr->outputStage;
-	    stageMax = statePtr->bufSize;
-	    stageLen = stageMax;
-
-	    toWrite = stageLen;
-	    if (toWrite > srcLen) {
-		toWrite = srcLen;
-	    }
-
-	    if (savedLF) {
-		/*
-		 * A '\n' was left over from last call to TranslateOutputEOL()
-		 * and we need to store it in the staging buffer. If the channel
-		 * is line-based, we will need to flush the output buffer (after
-		 * translating the staging buffer).
-		 */
-
-		*stage++ = '\n';
-		stageLen--;
-		sawLF++;
-	    }
-	    if (TranslateOutputEOL(statePtr, stage, src, &stageLen, &toWrite)) {
-		sawLF++;
-	    }
-
-	    stage -= savedLF;
-	    stageLen += savedLF;
-	    savedLF = 0;
-
-	    if (stageLen > stageMax) {
-		savedLF = 1;
-		stageLen = stageMax;
-	    }
-	} else {
-	    stage = (char *) src;
-	    stageLen = srcLen;
-	    toWrite = stageLen;
-	}
-	src += toWrite;
-	srcLen -= toWrite;
-
-	/*
-	 * Loop over all UTF-8 characters in staging buffer, converting them
-	 * to external encoding, storing them in output buffer.
-	 */
-
-	while (stageLen + saved + endEncoding > 0) {
-	    bufPtr = statePtr->curOutPtr;
-	    if (bufPtr == NULL) {
-		bufPtr = AllocChannelBuffer(statePtr->bufSize);
-		statePtr->curOutPtr = bufPtr;
-	    }
-	    dst = InsertPoint(bufPtr);
-	    dstLen = SpaceLeft(bufPtr);
 
-	    if (saved != 0) {
-		/*
-		 * Here's some translated bytes left over from the last buffer
-		 * that we need to stick at the beginning of this buffer.
-		 */
-
-		memcpy(dst, safe, (size_t) saved);
-		bufPtr->nextAdded += saved;
-		dst += saved;
-		dstLen -= saved;
-		saved = 0;
-	    }
-
-	    result = Tcl_UtfToExternal(NULL, encoding, stage, stageLen,
-		    statePtr->outputEncodingFlags,
-		    &statePtr->outputEncodingState, dst,
-		    dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL);
-
-	    /*
-	     * Fix for SF #506297, reported by Martin Forssen
-	     * <ruric@users.sourceforge.net>.
-	     *
-	     * The encoding chosen in the script exposing the bug writes out
-	     * three intro characters when TCL_ENCODING_START is set, but does
-	     * not consume any input as TCL_ENCODING_END is cleared. As some
-	     * output was generated the enclosing loop calls UtfToExternal
-	     * again, again with START set. Three more characters in the out
-	     * and still no use of input ... To break this infinite loop we
-	     * remove TCL_ENCODING_START from the set of flags after the first
-	     * call (no condition is required, the later calls remove an unset
-	     * flag, which is a no-op). This causes the subsequent calls to
-	     * UtfToExternal to consume and convert the actual input.
-	     */
-
-	    statePtr->outputEncodingFlags &= ~TCL_ENCODING_START;
-
-	    /*
-	     * The following code must be executed only when result is not 0.
-	     */
-
-	    if ((result != 0) && (stageRead + dstWrote == 0)) {
-		/*
-		 * We have an incomplete UTF-8 character at the end of the
-		 * staging buffer. It will get moved to the beginning of the
-		 * staging buffer followed by more bytes from src.
-		 */
-
-		src -= stageLen;
-		srcLen += stageLen;
-		stageLen = 0;
-		savedLF = 0;
-		break;
-	    }
-	    bufPtr->nextAdded += dstWrote;
-	    if (IsBufferOverflowing(bufPtr)) {
-		/*
-		 * When translating from UTF-8 to external encoding, we
-		 * allowed the translation to produce a character that crossed
-		 * the end of the output buffer, so that we would get a
-		 * completely full buffer before flushing it. The extra bytes
-		 * will be moved to the beginning of the next buffer.
-		 */
-
-		saved = -SpaceLeft(bufPtr);
-		memcpy(safe, dst + dstLen, (size_t) saved);
-		bufPtr->nextAdded = bufPtr->bufLength;
-	    }
-	    if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) {
-		return -1;
-	    }
-
-	    total += dstWrote;
-	    stage += stageRead;
-	    stageLen -= stageRead;
-	    sawLF = 0;
-
-	    consumedSomething = 1;
-
-	    /*
-	     * If all translated characters are written to the buffer,
-	     * endEncoding is set to 0 because the escape sequence may be
-	     * output.
-	     */
-
-	    if ((stageLen + saved == 0) && (result == 0)) {
-		endEncoding = 0;
-	    }
-	}
-    }
-#endif
-
-    /*
-     * If nothing was written and it happened because there was no progress in
-     * the UTF conversion, we throw an error.
-     */
-
-    if (!consumedSomething && (total == 0)) {
-	Tcl_SetErrno(EINVAL);
-	return -1;
-    }
     return total;
 }
 
-- 
cgit v0.12


From 9df81fccd3a1cfd90a732c1116cb3bf467bbe802 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Tue, 28 Jan 2014 20:23:26 +0000
Subject: The outputStage field is now unused, so never allocate it.

---
 generic/tclIO.c | 29 -----------------------------
 1 file changed, 29 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index c7c11e7..4ae9ec0 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -1489,12 +1489,7 @@ Tcl_CreateChannel(
     statePtr->timer		= NULL;
     statePtr->csPtrR		= NULL;
     statePtr->csPtrW		= NULL;
-
     statePtr->outputStage	= NULL;
-    if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
-	statePtr->outputStage = (char *)
-		ckalloc((unsigned) (statePtr->bufSize + 2));
-    }
 
     /*
      * As we are creating the channel, it is obviously the top for now.
@@ -2757,10 +2752,6 @@ CloseChannel(
 	}
 
 	Tcl_FreeEncoding(statePtr->encoding);
-	if (statePtr->outputStage != NULL) {
-	    ckfree((char *) statePtr->outputStage);
-	    statePtr->outputStage = NULL;
-	}
     }
 
     /*
@@ -7151,15 +7142,6 @@ Tcl_SetChannelBufferSize(
 
     statePtr = ((Channel *) chan)->state;
     statePtr->bufSize = sz;
-
-    if (statePtr->outputStage != NULL) {
-	ckfree((char *) statePtr->outputStage);
-	statePtr->outputStage = NULL;
-    }
-    if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
-	statePtr->outputStage = (char *)
-		ckalloc((unsigned) (statePtr->bufSize + 2));
-    }
 }
 
 /*
@@ -7800,17 +7782,6 @@ Tcl_SetChannelOption(
 	statePtr->inQueueTail = NULL;
     }
 
-    /*
-     * If encoding or bufsize changes, need to update output staging buffer.
-     */
-
-    if (statePtr->outputStage != NULL) {
-	ckfree(statePtr->outputStage);
-	statePtr->outputStage = NULL;
-    }
-    if ((statePtr->encoding != NULL) && (statePtr->flags & TCL_WRITABLE)) {
-	statePtr->outputStage = ckalloc((unsigned) (statePtr->bufSize + 2));
-    }
     return TCL_OK;
 }
 
-- 
cgit v0.12


From 9ac255b85b57fd192a8255ed8d8ca73bf5306748 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Thu, 30 Jan 2014 14:44:56 +0000
Subject: Fix [22c10c8e79]: core-8-5: msvc6 build: "Side by Side" error

---
 win/makefile.vc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/win/makefile.vc b/win/makefile.vc
index 4466439..152cc66 100644
--- a/win/makefile.vc
+++ b/win/makefile.vc
@@ -902,7 +902,7 @@ $(TMP_DIR)\tclStubLib.obj: $(GENERICDIR)\tclStubLib.c
 $(TMP_DIR)\tclsh.exe.manifest: $(WINDIR)\tclsh.exe.manifest.in
 	@nmakehlp -s << $** >$@
 @MACHINE@	  $(MACHINE:IX86=X86)
-@TCL_WIN_VERSION@  $(TCL_DOTVERSION).0.0
+@TCL_WIN_VERSION@  $(DOTVERSION).0.0
 <<
 
 #---------------------------------------------------------------------
-- 
cgit v0.12


From 4e8c59b5b86150cbf86bfcd5c501190b4e29c138 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Thu, 30 Jan 2014 18:31:39 +0000
Subject: Refactor WriteChars() and WriteBytes() into simple wrappers of a
 common routine Write().

---
 generic/tclEncoding.c |  2 ++
 generic/tclIO.c       | 48 +++++++++++++++++++++++++++++++++++-------------
 generic/tclInt.h      |  2 ++
 3 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index c2f1b4b..c303dd1 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -182,6 +182,7 @@ TCL_DECLARE_MUTEX(encodingMutex)
 
 static Tcl_Encoding defaultEncoding;
 static Tcl_Encoding systemEncoding;
+Tcl_Encoding tclIdentityEncoding;
 
 /*
  * The following variable is used in the sparse matrix code for a
@@ -566,6 +567,7 @@ TclInitEncodingSubsystem(void)
     type.clientData	= NULL;
 
     defaultEncoding	= Tcl_CreateEncoding(&type);
+    tclIdentityEncoding = Tcl_GetEncoding(NULL, type.encodingName);
     systemEncoding	= Tcl_GetEncoding(NULL, type.encodingName);
 
     type.encodingName	= "utf-8";
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 4ae9ec0..78ad629 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -200,6 +200,7 @@ static int		FilterInputBytes(Channel *chanPtr,
 static int		FlushChannel(Tcl_Interp *interp, Channel *chanPtr,
 			    int calledFromAsyncFlush);
 static int		TclGetsObjBinary(Tcl_Channel chan, Tcl_Obj *objPtr);
+static Tcl_Encoding	GetBinaryEncoding();
 static void		FreeBinaryEncoding(ClientData clientData);
 static Tcl_HashTable *	GetChannelTable(Tcl_Interp *interp);
 static int		GetInput(Channel *chanPtr);
@@ -222,6 +223,8 @@ static int		TranslateInputEOL(ChannelState *statePtr, char *dst,
 static int		TranslateOutputEOL(ChannelState *statePtr, char *dst,
 			    const char *src, int *dstLenPtr, int *srcLenPtr);
 static void		UpdateInterest(Channel *chanPtr);
+static int		Write(Channel *chanPtr, const char *src,
+			    int srcLen, Tcl_Encoding encoding);
 static int		WriteBytes(Channel *chanPtr, const char *src,
 			    int srcLen);
 static int		WriteChars(Channel *chanPtr, const char *src,
@@ -3640,6 +3643,9 @@ WriteBytes(
     const char *src,		/* Bytes to write. */
     int srcLen)			/* Number of bytes to write. */
 {
+#if 1
+    return Write(chanPtr, src, srcLen, tclIdentityEncoding);
+#else
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
     ChannelBuffer *bufPtr;
@@ -3712,6 +3718,7 @@ WriteBytes(
 	sawLF = 0;
     }
     return total;
+#endif
 }
 
 /*
@@ -3736,16 +3743,16 @@ WriteBytes(
  */
 
 static int
-WriteChars(
+Write(
     Channel *chanPtr,		/* The channel to buffer output for. */
     const char *src,		/* UTF-8 string to write. */
-    int srcLen)			/* Length of UTF-8 string in bytes. */
+    int srcLen,			/* Length of UTF-8 string in bytes. */
+    Tcl_Encoding encoding)
 {
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
     char *nextNewLine = NULL;
     int endEncoding, saved = 0, total = 0, flushed = 0, needNlFlush = 0;
-    Tcl_Encoding encoding = statePtr->encoding;
 
     if (srcLen) {
         WillWrite(chanPtr);
@@ -3894,6 +3901,15 @@ WriteChars(
 
     return total;
 }
+
+static int
+WriteChars(
+    Channel *chanPtr,		/* The channel to buffer output for. */
+    const char *src,		/* UTF-8 string to write. */
+    int srcLen)			/* Length of UTF-8 string in bytes. */
+{
+    return Write(chanPtr, src, srcLen, chanPtr->state->encoding);
+}
 
 /*
  *---------------------------------------------------------------------------
@@ -4197,16 +4213,7 @@ Tcl_GetsObj(
      */
 
     if (encoding == NULL) {
-	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-
-	if (tsdPtr->binaryEncoding == NULL) {
-	    tsdPtr->binaryEncoding = Tcl_GetEncoding(NULL, "iso8859-1");
-	    Tcl_CreateThreadExitHandler(FreeBinaryEncoding, NULL);
-	}
-	encoding = tsdPtr->binaryEncoding;
-	if (encoding == NULL) {
-	    Tcl_Panic("attempted gets on binary channel where no iso8859-1 encoding available");
-	}
+	encoding = GetBinaryEncoding();
     }
 
     /*
@@ -4747,6 +4754,21 @@ FreeBinaryEncoding(
 	tsdPtr->binaryEncoding = NULL;
     }
 }
+
+static Tcl_Encoding
+GetBinaryEncoding()
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (tsdPtr->binaryEncoding == NULL) {
+	tsdPtr->binaryEncoding = Tcl_GetEncoding(NULL, "iso8859-1");
+	Tcl_CreateThreadExitHandler(FreeBinaryEncoding, NULL);
+    }
+    if (tsdPtr->binaryEncoding == NULL) {
+	Tcl_Panic("binary encoding is not available");
+    }
+    return tsdPtr->binaryEncoding;
+}
 
 /*
  *---------------------------------------------------------------------------
diff --git a/generic/tclInt.h b/generic/tclInt.h
index dc28b97..b45f8e3 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2382,6 +2382,8 @@ MODULE_SCOPE char *tclMemDumpFileName;
 MODULE_SCOPE TclPlatformType tclPlatform;
 MODULE_SCOPE Tcl_NotifierProcs tclOriginalNotifier;
 
+MODULE_SCOPE Tcl_Encoding tclIdentityEncoding;
+
 /*
  * TIP #233 (Virtualized Time)
  * Data for the time hooks, if any.
-- 
cgit v0.12


From 7c73eea7d83b3f153f57782f4add442c09d03be0 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Thu, 30 Jan 2014 18:45:11 +0000
Subject: Simplification and cleanup enabled by last commit.

---
 generic/tclIO.c | 308 ++------------------------------------------------------
 1 file changed, 7 insertions(+), 301 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 78ad629..dd9f1dc 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -165,8 +165,6 @@ static ChannelBuffer *	AllocChannelBuffer(int length);
 static void		ChannelTimerProc(ClientData clientData);
 static int		CheckChannelErrors(ChannelState *statePtr,
 			    int direction);
-static int		CheckFlush(Channel *chanPtr, ChannelBuffer *bufPtr,
-			    int newlineFlag);
 static int		CheckForDeadChannel(Tcl_Interp *interp,
 			    ChannelState *statePtr);
 static void		CheckForStdChannelsBeingClosed(Tcl_Channel chan);
@@ -220,20 +218,19 @@ static int		SetBlockMode(Tcl_Interp *interp, Channel *chanPtr,
 static void		StopCopy(CopyState *csPtr);
 static int		TranslateInputEOL(ChannelState *statePtr, char *dst,
 			    const char *src, int *dstLenPtr, int *srcLenPtr);
-static int		TranslateOutputEOL(ChannelState *statePtr, char *dst,
-			    const char *src, int *dstLenPtr, int *srcLenPtr);
 static void		UpdateInterest(Channel *chanPtr);
 static int		Write(Channel *chanPtr, const char *src,
 			    int srcLen, Tcl_Encoding encoding);
-static int		WriteBytes(Channel *chanPtr, const char *src,
-			    int srcLen);
-static int		WriteChars(Channel *chanPtr, const char *src,
-			    int srcLen);
 static Tcl_Obj *	FixLevelCode(Tcl_Obj *msg);
 static void		SpliceChannel(Tcl_Channel chan);
 static void		CutChannel(Tcl_Channel chan);
 static int WillRead(Channel *chanPtr);
 
+#define WriteChars(chanPtr, src, srcLen) \
+			Write(chanPtr, src, srcLen, chanPtr->state->encoding)
+#define WriteBytes(chanPtr, src, srcLen) \
+			Write(chanPtr, src, srcLen, tclIdentityEncoding)
+
 /*
  * Simplifying helper macros. All may use their argument(s) multiple times.
  * The ANSI C "prototypes" for the macros are listed below, together with a
@@ -3619,114 +3616,9 @@ static int WillRead(Channel *chanPtr)
 /*
  *----------------------------------------------------------------------
  *
- * WriteBytes --
- *
- *	Write a sequence of bytes into an output buffer, may queue the buffer
- *	for output if it gets full, and also remembers whether the current
- *	buffer is ready e.g. if it contains a newline and we are in line
- *	buffering mode.
- *
- * Results:
- *	The number of bytes written or -1 in case of error. If -1,
- *	Tcl_GetErrno will return the error code.
- *
- * Side effects:
- *	May buffer up output and may cause output to be produced on the
- *	channel.
+ * Write --
  *
- *----------------------------------------------------------------------
- */
-
-static int
-WriteBytes(
-    Channel *chanPtr,		/* The channel to buffer output for. */
-    const char *src,		/* Bytes to write. */
-    int srcLen)			/* Number of bytes to write. */
-{
-#if 1
-    return Write(chanPtr, src, srcLen, tclIdentityEncoding);
-#else
-    ChannelState *statePtr = chanPtr->state;
-				/* State info for channel */
-    ChannelBuffer *bufPtr;
-    char *dst;
-    int dstMax, sawLF, savedLF, total, dstLen, toWrite, translate;
-
-    if (srcLen) {
-        WillWrite(chanPtr);
-    }
-
-    total = 0;
-    sawLF = 0;
-    savedLF = 0;
-    translate = (statePtr->flags & CHANNEL_LINEBUFFERED)
-	|| (statePtr->outputTranslation != TCL_TRANSLATE_LF);
-
-    /*
-     * Loop over all bytes in src, storing them in output buffer with proper
-     * EOL translation.
-     */
-
-    while (srcLen + savedLF > 0) {
-	bufPtr = statePtr->curOutPtr;
-	if (bufPtr == NULL) {
-	    bufPtr = AllocChannelBuffer(statePtr->bufSize);
-	    statePtr->curOutPtr = bufPtr;
-	}
-	dst = InsertPoint(bufPtr);
-	dstMax = SpaceLeft(bufPtr);
-	dstLen = dstMax;
-
-	toWrite = dstLen;
-	if (toWrite > srcLen) {
-	    toWrite = srcLen;
-	}
-
-	if (translate) {
-	    if (savedLF) {
-		/*
-		 * A '\n' was left over from last call to TranslateOutputEOL()
-		 * and we need to store it in this buffer. If the channel is
-		 * line-based, we will need to flush it.
-		 */
-
-		*dst++ = '\n';
-		dstLen--;
-		sawLF++;
-	    }
-	    if (TranslateOutputEOL(statePtr, dst, src, &dstLen, &toWrite)) {
-		sawLF++;
-	    }
-	    dstLen += savedLF;
-	    savedLF = 0;
-	    if (dstLen > dstMax) {
-		savedLF = 1;
-		dstLen = dstMax;
-	    }
-	} else {
-	    memcpy(dst, src, toWrite);
-	    dstLen = toWrite;
-	}
-
-	bufPtr->nextAdded += dstLen;
-	if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) {
-	    return -1;
-	}
-	total += dstLen;
-	src += toWrite;
-	srcLen -= toWrite;
-	sawLF = 0;
-    }
-    return total;
-#endif
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * WriteChars --
- *
- *	Convert UTF-8 bytes to the channel's external encoding and write the
+ *	Convert srcLen bytes starting at src according to encoding and write
  *	produced bytes into an output buffer, may queue the buffer for output
  *	if it gets full, and also remembers whether the current buffer is
  *	ready e.g. if it contains a newline and we are in line buffering mode.
@@ -3901,192 +3793,6 @@ Write(
 
     return total;
 }
-
-static int
-WriteChars(
-    Channel *chanPtr,		/* The channel to buffer output for. */
-    const char *src,		/* UTF-8 string to write. */
-    int srcLen)			/* Length of UTF-8 string in bytes. */
-{
-    return Write(chanPtr, src, srcLen, chanPtr->state->encoding);
-}
-
-/*
- *---------------------------------------------------------------------------
- *
- * TranslateOutputEOL --
- *
- *	Helper function for WriteBytes() and WriteChars(). Converts the '\n'
- *	characters in the source buffer into the appropriate EOL form
- *	specified by the output translation mode.
- *
- *	EOL translation stops either when the source buffer is empty or the
- *	output buffer is full.
- *
- *	When converting to CRLF mode and there is only 1 byte left in the
- *	output buffer, this routine stores the '\r' in the last byte and then
- *	stores the '\n' in the byte just past the end of the buffer. The
- *	caller is responsible for passing in a buffer that is large enough to
- *	hold the extra byte.
- *
- * Results:
- *	The return value is 1 if a '\n' was translated from the source buffer,
- *	or 0 otherwise -- this can be used by the caller to decide to flush a
- *	line-based channel even though the channel buffer is not full.
- *
- *	*dstLenPtr is filled with how many bytes of the output buffer were
- *	used. As mentioned above, this can be one more that the output
- *	buffer's specified length if a CRLF was stored.
- *
- *	*srcLenPtr is filled with how many bytes of the source buffer were
- *	consumed.
- *
- * Side effects:
- *	It may be obvious, but bears mentioning that when converting in CRLF
- *	mode (which requires two bytes of storage in the output buffer), the
- *	number of bytes consumed from the source buffer will be less than the
- *	number of bytes stored in the output buffer.
- *
- *---------------------------------------------------------------------------
- */
-
-static int
-TranslateOutputEOL(
-    ChannelState *statePtr,	/* Channel being read, for translation and
-				 * buffering modes. */
-    char *dst,			/* Output buffer filled with UTF-8 chars by
-				 * applying appropriate EOL translation to
-				 * source characters. */
-    const char *src,		/* Source UTF-8 characters. */
-    int *dstLenPtr,		/* On entry, the maximum length of output
-				 * buffer in bytes. On exit, the number of
-				 * bytes actually used in output buffer. */
-    int *srcLenPtr)		/* On entry, the length of source buffer. On
-				 * exit, the number of bytes read from the
-				 * source buffer. */
-{
-    char *dstEnd;
-    int srcLen, newlineFound;
-
-    newlineFound = 0;
-    srcLen = *srcLenPtr;
-
-    switch (statePtr->outputTranslation) {
-    case TCL_TRANSLATE_LF:
-	for (dstEnd = dst + srcLen; dst < dstEnd; ) {
-	    if (*src == '\n') {
-		newlineFound = 1;
-	    }
-	    *dst++ = *src++;
-	}
-	*dstLenPtr = srcLen;
-	break;
-    case TCL_TRANSLATE_CR:
-	for (dstEnd = dst + srcLen; dst < dstEnd;) {
-	    if (*src == '\n') {
-		*dst++ = '\r';
-		newlineFound = 1;
-		src++;
-	    } else {
-		*dst++ = *src++;
-	    }
-	}
-	*dstLenPtr = srcLen;
-	break;
-    case TCL_TRANSLATE_CRLF: {
-	/*
-	 * Since this causes the number of bytes to grow, we start off trying
-	 * to put 'srcLen' bytes into the output buffer, but allow it to store
-	 * more bytes, as long as there's still source bytes and room in the
-	 * output buffer.
-	 */
-
-	char *dstStart, *dstMax;
-	const char *srcStart;
-
-	dstStart = dst;
-	dstMax = dst + *dstLenPtr;
-
-	srcStart = src;
-
-	if (srcLen < *dstLenPtr) {
-	    dstEnd = dst + srcLen;
-	} else {
-	    dstEnd = dst + *dstLenPtr;
-	}
-	while (dst < dstEnd) {
-	    if (*src == '\n') {
-		if (dstEnd < dstMax) {
-		    dstEnd++;
-		}
-		*dst++ = '\r';
-		newlineFound = 1;
-	    }
-	    *dst++ = *src++;
-	}
-	*srcLenPtr = src - srcStart;
-	*dstLenPtr = dst - dstStart;
-	break;
-    }
-    default:
-	break;
-    }
-    return newlineFound;
-}
-
-/*
- *---------------------------------------------------------------------------
- *
- * CheckFlush --
- *
- *	Helper function for WriteBytes() and WriteChars(). If the channel
- *	buffer is ready to be flushed, flush it.
- *
- * Results:
- *	The return value is -1 if there was a problem flushing the channel
- *	buffer, or 0 otherwise.
- *
- * Side effects:
- *	The buffer will be recycled if it is flushed.
- *
- *---------------------------------------------------------------------------
- */
-
-static int
-CheckFlush(
-    Channel *chanPtr,		/* Channel being read, for buffering mode. */
-    ChannelBuffer *bufPtr,	/* Channel buffer to possibly flush. */
-    int newlineFlag)		/* Non-zero if a the channel buffer contains a
-				 * newline. */
-{
-    ChannelState *statePtr = chanPtr->state;
-				/* State info for channel */
-
-    /*
-     * The current buffer is ready for output:
-     * 1. if it is full.
-     * 2. if it contains a newline and this channel is line-buffered.
-     * 3. if it contains any output and this channel is unbuffered.
-     */
-
-    if ((statePtr->flags & BUFFER_READY) == 0) {
-	if (IsBufferFull(bufPtr)) {
-	    SetFlag(statePtr, BUFFER_READY);
-	} else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
-	    if (newlineFlag != 0) {
-		SetFlag(statePtr, BUFFER_READY);
-	    }
-	} else if (statePtr->flags & CHANNEL_UNBUFFERED) {
-	    SetFlag(statePtr, BUFFER_READY);
-	}
-    }
-    if (statePtr->flags & BUFFER_READY) {
-	if (FlushChannel(NULL, chanPtr, 0) != 0) {
-	    return -1;
-	}
-    }
-    return 0;
-}
 
 /*
  *---------------------------------------------------------------------------
-- 
cgit v0.12


From e264168978eae3270ed1c67ef1152c65347db8f0 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Thu, 30 Jan 2014 19:13:28 +0000
Subject: Trial: Implement DoWrite() as WriteBytes().

---
 generic/tclIO.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index dd9f1dc..1434d88 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -9213,6 +9213,9 @@ DoWrite(
     const char *src,		/* Data to write. */
     int srcLen)			/* Number of bytes to write. */
 {
+#if 1
+    return WriteBytes(chanPtr, src, srcLen);
+#else
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
     ChannelBuffer *outBufPtr;	/* Current output buffer. */
@@ -9340,6 +9343,7 @@ DoWrite(
     } /* Closes "while" */
 
     return totalDestCopied;
+#endif
 }
 
 /*
-- 
cgit v0.12


From 8079c3edb6ad6cac45822466639a9e2b9e9146e0 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Thu, 30 Jan 2014 19:30:34 +0000
Subject: Eliminate DoWrite().  It duplicates WriteBytes().

---
 generic/tclIO.c | 165 +-------------------------------------------------------
 1 file changed, 2 insertions(+), 163 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 1434d88..33bb98c 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -189,7 +189,6 @@ static void		DiscardInputQueued(ChannelState *statePtr,
 			    int discardSavedBuffers);
 static void		DiscardOutputQueued(ChannelState *chanPtr);
 static int		DoRead(Channel *chanPtr, char *srcPtr, int slen);
-static int		DoWrite(Channel *chanPtr, const char *src, int srcLen);
 static int		DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead,
 			    int appendFlag);
 static int		DoWriteChars(Channel *chan, const char *src, int len);
@@ -3362,7 +3361,7 @@ Tcl_Write(
     if (srcLen < 0) {
 	srcLen = strlen(src);
     }
-    return DoWrite(chanPtr, src, srcLen);
+    return WriteBytes(chanPtr, src, srcLen);
 }
 
 /*
@@ -8639,7 +8638,7 @@ CopyData(
 	}
 
 	if (outBinary || sameEncoding) {
-	    sizeb = DoWrite(outStatePtr->topChanPtr, buffer, sizeb);
+	    sizeb = WriteBytes(outStatePtr->topChanPtr, buffer, sizeb);
 	} else {
 	    sizeb = DoWriteChars(outStatePtr->topChanPtr, buffer, sizeb);
 	}
@@ -9189,166 +9188,6 @@ CopyBuffer(
 /*
  *----------------------------------------------------------------------
  *
- * DoWrite --
- *
- *	Puts a sequence of characters into an output buffer, may queue the
- *	buffer for output if it gets full, and also remembers whether the
- *	current buffer is ready e.g. if it contains a newline and we are in
- *	line buffering mode.
- *
- * Results:
- *	The number of bytes written or -1 in case of error. If -1,
- *	Tcl_GetErrno will return the error code.
- *
- * Side effects:
- *	May buffer up output and may cause output to be produced on the
- *	channel.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-DoWrite(
-    Channel *chanPtr,		/* The channel to buffer output for. */
-    const char *src,		/* Data to write. */
-    int srcLen)			/* Number of bytes to write. */
-{
-#if 1
-    return WriteBytes(chanPtr, src, srcLen);
-#else
-    ChannelState *statePtr = chanPtr->state;
-				/* State info for channel */
-    ChannelBuffer *outBufPtr;	/* Current output buffer. */
-    int foundNewline;		/* Did we find a newline in output? */
-    char *dPtr;
-    const char *sPtr;		/* Search variables for newline. */
-    int crsent;			/* In CRLF eol translation mode, remember the
-				 * fact that a CR was output to the channel
-				 * without its following NL. */
-    int i;			/* Loop index for newline search. */
-    int destCopied;		/* How many bytes were used in this
-				 * destination buffer to hold the output? */
-    int totalDestCopied;	/* How many bytes total were copied to the
-				 * channel buffer? */
-    int srcCopied;		/* How many bytes were copied from the source
-				 * string? */
-    char *destPtr;		/* Where in line to copy to? */
-
-    /*
-     * If we are in network (or windows) translation mode, record the fact
-     * that we have not yet sent a CR to the channel.
-     */
-
-    crsent = 0;
-
-    /*
-     * Loop filling buffers and flushing them until all output has been
-     * consumed.
-     */
-
-    srcCopied = 0;
-    totalDestCopied = 0;
-
-    while (srcLen > 0) {
-	/*
-	 * Make sure there is a current output buffer to accept output.
-	 */
-
-	if (statePtr->curOutPtr == NULL) {
-	    statePtr->curOutPtr = AllocChannelBuffer(statePtr->bufSize);
-	}
-
-	outBufPtr = statePtr->curOutPtr;
-
-	destCopied = SpaceLeft(outBufPtr);
-	if (destCopied > srcLen) {
-	    destCopied = srcLen;
-	}
-
-	destPtr = InsertPoint(outBufPtr);
-	switch (statePtr->outputTranslation) {
-	case TCL_TRANSLATE_LF:
-	    srcCopied = destCopied;
-	    memcpy(destPtr, src, (size_t) destCopied);
-	    break;
-	case TCL_TRANSLATE_CR:
-	    srcCopied = destCopied;
-	    memcpy(destPtr, src, (size_t) destCopied);
-	    for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
-		if (*dPtr == '\n') {
-		    *dPtr = '\r';
-		}
-	    }
-	    break;
-	case TCL_TRANSLATE_CRLF:
-	    for (srcCopied = 0, dPtr = destPtr, sPtr = src;
-		    dPtr < destPtr + destCopied;
-		    dPtr++, sPtr++, srcCopied++) {
-		if (*sPtr == '\n') {
-		    if (crsent) {
-			*dPtr = '\n';
-			crsent = 0;
-		    } else {
-			*dPtr = '\r';
-			crsent = 1;
-			sPtr--, srcCopied--;
-		    }
-		} else {
-		    *dPtr = *sPtr;
-		}
-	    }
-	    break;
-	case TCL_TRANSLATE_AUTO:
-	    Tcl_Panic("Tcl_Write: AUTO output translation mode not supported");
-	default:
-	    Tcl_Panic("Tcl_Write: unknown output translation mode");
-	}
-
-	/*
-	 * The current buffer is ready for output if it is full, or if it
-	 * contains a newline and this channel is line-buffered, or if it
-	 * contains any output and this channel is unbuffered.
-	 */
-
-	outBufPtr->nextAdded += destCopied;
-	if (!(statePtr->flags & BUFFER_READY)) {
-	    if (IsBufferFull(outBufPtr)) {
-		SetFlag(statePtr, BUFFER_READY);
-	    } else if (statePtr->flags & CHANNEL_LINEBUFFERED) {
-		for (sPtr = src, i = 0, foundNewline = 0;
-			(i < srcCopied) && (!foundNewline);
-			i++, sPtr++) {
-		    if (*sPtr == '\n') {
-			foundNewline = 1;
-			break;
-		    }
-		}
-		if (foundNewline) {
-		    SetFlag(statePtr, BUFFER_READY);
-		}
-	    } else if (statePtr->flags & CHANNEL_UNBUFFERED) {
-		SetFlag(statePtr, BUFFER_READY);
-	    }
-	}
-
-	totalDestCopied += srcCopied;
-	src += srcCopied;
-	srcLen -= srcCopied;
-
-	if (statePtr->flags & BUFFER_READY) {
-	    if (FlushChannel(NULL, chanPtr, 0) != 0) {
-		return -1;
-	    }
-	}
-    } /* Closes "while" */
-
-    return totalDestCopied;
-#endif
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * CopyEventProc --
  *
  *	This routine is invoked as a channel event handler for the background
-- 
cgit v0.12


From 4e9008ff1b243981772ef48e1e92f2a95301b0e3 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Thu, 30 Jan 2014 20:10:21 +0000
Subject: Refactor to eliminate the DoWriteChars() layer.

---
 generic/tclIO.c | 86 +++++++++++++++------------------------------------------
 1 file changed, 22 insertions(+), 64 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 33bb98c..542d97d 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -191,7 +191,6 @@ static void		DiscardOutputQueued(ChannelState *chanPtr);
 static int		DoRead(Channel *chanPtr, char *srcPtr, int slen);
 static int		DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead,
 			    int appendFlag);
-static int		DoWriteChars(Channel *chan, const char *src, int len);
 static int		FilterInputBytes(Channel *chanPtr,
 			    GetsState *statePtr);
 static int		FlushChannel(Tcl_Interp *interp, Channel *chanPtr,
@@ -3454,81 +3453,40 @@ Tcl_WriteChars(
     int len)			/* Length of string in bytes, or < 0 for
 				 * strlen(). */
 {
-    ChannelState *statePtr;	/* State info for channel */
-
-    statePtr = ((Channel *) chan)->state;
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;	/* State info for channel */
+    int result;
+    Tcl_Obj *objPtr;
 
     if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
 	return -1;
     }
 
-    return DoWriteChars((Channel *) chan, src, len);
-}
-
-/*
- *---------------------------------------------------------------------------
- *
- * DoWriteChars --
- *
- *	Takes a sequence of UTF-8 characters and converts them for output
- *	using the channel's current encoding, may queue the buffer for output
- *	if it gets full, and also remembers whether the current buffer is
- *	ready e.g. if it contains a newline and we are in line buffering mode.
- *	Compensates stacking, i.e. will redirect the data from the specified
- *	channel to the topmost channel in a stack.
- *
- * Results:
- *	The number of bytes written or -1 in case of error. If -1,
- *	Tcl_GetErrno will return the error code.
- *
- * Side effects:
- *	May buffer up output and may cause output to be produced on the
- *	channel.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-DoWriteChars(
-    Channel *chanPtr,		/* The channel to buffer output for. */
-    const char *src,		/* UTF-8 characters to queue in output
-				 * buffer. */
-    int len)			/* Length of string in bytes, or < 0 for
-				 * strlen(). */
-{
-    /*
-     * Always use the topmost channel of the stack
-     */
-
-    ChannelState *statePtr;	/* State info for channel */
-
-    statePtr = chanPtr->state;
     chanPtr = statePtr->topChanPtr;
 
     if (len < 0) {
 	len = strlen(src);
     }
-    if (statePtr->encoding == NULL) {
-	/*
-	 * Inefficient way to convert UTF-8 to byte-array, but the code
-	 * parallels the way it is done for objects.
-	 * Special case for 1-byte (used by eg [puts] for the \n) could
-	 * be extended to more efficient translation of the src string.
-	 */
+    if (statePtr->encoding) {
+	return WriteChars(chanPtr, src, len);
+    }
 
- 	int result;
+    /*
+     * Inefficient way to convert UTF-8 to byte-array, but the code
+     * parallels the way it is done for objects.  Special case for 1-byte
+     * (used by eg [puts] for the \n) could be extended to more efficient
+     * translation of the src string.
+     */
 
-	if ((len == 1) && (UCHAR(*src) < 0xC0)) {
-	    result = WriteBytes(chanPtr, src, len);
-	} else {
-	    Tcl_Obj *objPtr = Tcl_NewStringObj(src, len);
-	    src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len);
-	    result = WriteBytes(chanPtr, src, len);
-	    TclDecrRefCount(objPtr);
-	}
-	return result;
+    if ((len == 1) && (UCHAR(*src) < 0xC0)) {
+	return WriteBytes(chanPtr, src, len);
     }
-    return WriteChars(chanPtr, src, len);
+
+    objPtr = Tcl_NewStringObj(src, len);
+    src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len);
+    result = WriteBytes(chanPtr, src, len);
+    TclDecrRefCount(objPtr);
+    return result;
 }
 
 /*
@@ -8640,7 +8598,7 @@ CopyData(
 	if (outBinary || sameEncoding) {
 	    sizeb = WriteBytes(outStatePtr->topChanPtr, buffer, sizeb);
 	} else {
-	    sizeb = DoWriteChars(outStatePtr->topChanPtr, buffer, sizeb);
+	    sizeb = WriteChars(outStatePtr->topChanPtr, buffer, sizeb);
 	}
 
 	/*
-- 
cgit v0.12


From 81e405a16c6eff768e23d1c43c292e4875b86a16 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Fri, 31 Jan 2014 09:13:13 +0000
Subject: Fix [4b3b7a3082]: tcl8.5.15/generic/tclExecute.c:7713: array index
 before sanity check ?

---
 generic/tclExecute.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index e657828..2e396e8 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -73,7 +73,7 @@ int tclTraceExec = 0;
  * disjoint for backward-compatability reasons.
  */
 
-static const char *operatorStrings[] = {
+static const char *const operatorStrings[] = {
     "||", "&&", "|", "^", "&", "==", "!=", "<", ">", "<=", ">=", "<<", ">>",
     "+", "-", "*", "/", "%", "+", "-", "~", "!",
     "BUILTIN FUNCTION", "FUNCTION",
@@ -86,7 +86,7 @@ static const char *operatorStrings[] = {
  */
 
 #ifdef TCL_COMPILE_DEBUG
-static const char *resultStrings[] = {
+static const char *const resultStrings[] = {
     "TCL_OK", "TCL_ERROR", "TCL_RETURN", "TCL_BREAK", "TCL_CONTINUE"
 };
 #endif
@@ -7710,10 +7710,12 @@ IllegalExprOperandType(
     ClientData ptr;
     int type;
     unsigned char opcode = *pc;
-    const char *description, *operator = operatorStrings[opcode - INST_LOR];
+    const char *description, *operator = "unknown";
 
     if (opcode == INST_EXPON) {
 	operator = "**";
+    } else if (opcode <= INST_STR_NEQ) {
+	operator = operatorStrings[opcode - INST_LOR];
     }
 
     if (GetNumberFromObj(NULL, opndPtr, &ptr, &type) != TCL_OK) {
-- 
cgit v0.12


From 4c98b1f4cda633b5554ac990dfde7401bd0d67b1 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Fri, 31 Jan 2014 20:02:58 +0000
Subject: Do not call updateStringProc directly.  We have TclGetString() for
 that.

---
 generic/tclIO.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 542d97d..71f8f53 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -10429,17 +10429,8 @@ SetChannelFromAny(
 	}
     }
     if (objPtr->typePtr != &tclChannelType) {
-	Tcl_Channel chan;
+	Tcl_Channel chan = Tcl_GetChannel(interp, TclGetString(objPtr), NULL);
 
-	/*
-	 * We need a valid string with which to check for a valid channel, but
-	 * make sure not to free internal rep until validated. [Bug 1847044]
-	 */
-	if ((objPtr->typePtr != NULL) && (objPtr->bytes == NULL)) {
-	    objPtr->typePtr->updateStringProc(objPtr);
-	}
-
-	chan = Tcl_GetChannel(interp, objPtr->bytes, NULL);
 	if (chan == NULL) {
 	    return TCL_ERROR;
 	}
-- 
cgit v0.12


From 6f611b9b973068d5630b4a227aef5fc316686036 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Fri, 31 Jan 2014 20:42:21 +0000
Subject: The "channel" Tcl_ObjType is caching only.  It never needs an
 UpdateString routine. It's also static to the tclIO.c file.

---
 generic/tclIO.c | 52 ++++++----------------------------------------------
 1 file changed, 6 insertions(+), 46 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 71f8f53..7705d7b 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -316,14 +316,13 @@ static int WillRead(Channel *chanPtr);
 
 static void		DupChannelIntRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr);
 static int		SetChannelFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
-static void		UpdateStringOfChannel(Tcl_Obj *objPtr);
 static void		FreeChannelIntRep(Tcl_Obj *objPtr);
 
-static Tcl_ObjType tclChannelType = {
+static Tcl_ObjType chanObjType = {
     "channel",			/* name for this type */
     FreeChannelIntRep,		/* freeIntRepProc */
     DupChannelIntRep,		/* dupIntRepProc */
-    NULL,			/* updateStringProc UpdateStringOfChannel */
+    NULL,			/* updateStringProc */
     NULL			/* setFromAnyProc SetChannelFromAny */
 };
 
@@ -10379,7 +10378,7 @@ DupChannelIntRep(
     SET_CHANNELSTATE(copyPtr, statePtr);
     SET_CHANNELINTERP(copyPtr, interpPtr);
     Tcl_Preserve((ClientData) statePtr);
-    copyPtr->typePtr = &tclChannelType;
+    copyPtr->typePtr = srcPtr->typePtr;
 }
 
 /*
@@ -10410,7 +10409,7 @@ SetChannelFromAny(
     if (interp == NULL) {
 	return TCL_ERROR;
     }
-    if (objPtr->typePtr == &tclChannelType) {
+    if (objPtr->typePtr == &chanObjType) {
 	/*
 	 * The channel is valid until any call to DetachChannel occurs.
 	 * Ensure consistency checks are done.
@@ -10420,15 +10419,13 @@ SetChannelFromAny(
 	if (statePtr->flags & (CHANNEL_TAINTED|CHANNEL_CLOSED)) {
 	    ResetFlag(statePtr, CHANNEL_TAINTED);
 	    Tcl_Release((ClientData) statePtr);
-	    UpdateStringOfChannel(objPtr);
 	    objPtr->typePtr = NULL;
 	} else if (interpPtr != (Interp*) interp) {
 	    Tcl_Release((ClientData) statePtr);
-	    UpdateStringOfChannel(objPtr);
 	    objPtr->typePtr = NULL;
 	}
     }
-    if (objPtr->typePtr != &tclChannelType) {
+    if (objPtr->typePtr != &chanObjType) {
 	Tcl_Channel chan = Tcl_GetChannel(interp, TclGetString(objPtr), NULL);
 
 	if (chan == NULL) {
@@ -10440,7 +10437,7 @@ SetChannelFromAny(
 	Tcl_Preserve((ClientData) statePtr);
 	SET_CHANNELSTATE(objPtr, statePtr);
 	SET_CHANNELINTERP(objPtr, interp);
-	objPtr->typePtr = &tclChannelType;
+	objPtr->typePtr = &chanObjType;
     }
     return TCL_OK;
 }
@@ -10448,43 +10445,6 @@ SetChannelFromAny(
 /*
  *----------------------------------------------------------------------
  *
- * UpdateStringOfChannel --
- *
- *	Update the string representation for an object whose internal
- *	representation is "Channel".
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The object's string may be set by converting its Unicode represention
- *	to UTF format.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-UpdateStringOfChannel(
-    Tcl_Obj *objPtr)		/* Object with string rep to update. */
-{
-    if (objPtr->bytes == NULL) {
-	ChannelState *statePtr = GET_CHANNELSTATE(objPtr);
-	const char *name = statePtr->channelName;
-	if (name) {
-	    size_t len = strlen(name);
-	    objPtr->bytes = (char *) ckalloc(len + 1);
-	    objPtr->length = len;
-	    memcpy(objPtr->bytes, name, len);
-	} else {
-	    objPtr->bytes = tclEmptyStringRep;
-	    objPtr->length = 0;
-	}
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * FreeChannelIntRep --
  *
  *	Release statePtr storage.
-- 
cgit v0.12


From a85ebc21de9b4010d0733a56197fecbb6f3d3a3b Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Fri, 31 Jan 2014 22:07:10 +0000
Subject: Simplify macro typecasting.

---
 generic/tclIO.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 7705d7b..3636861 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -331,7 +331,7 @@ static Tcl_ObjType chanObjType = {
 #define SET_CHANNELSTATE(objPtr, storePtr) \
     ((objPtr)->internalRep.twoPtrValue.ptr1 = (void *) (storePtr))
 #define GET_CHANNELINTERP(objPtr) \
-    ((Interp *) (objPtr)->internalRep.twoPtrValue.ptr2)
+    ((Tcl_Interp *) (objPtr)->internalRep.twoPtrValue.ptr2)
 #define SET_CHANNELINTERP(objPtr, storePtr) \
     ((objPtr)->internalRep.twoPtrValue.ptr2 = (void *) (storePtr))
 
@@ -10373,10 +10373,9 @@ DupChannelIntRep(
 				 * currently have an internal rep.*/
 {
     ChannelState *statePtr  = GET_CHANNELSTATE(srcPtr);
-    Interp       *interpPtr = GET_CHANNELINTERP(srcPtr);
 
     SET_CHANNELSTATE(copyPtr, statePtr);
-    SET_CHANNELINTERP(copyPtr, interpPtr);
+    SET_CHANNELINTERP(copyPtr, GET_CHANNELINTERP(srcPtr));
     Tcl_Preserve((ClientData) statePtr);
     copyPtr->typePtr = srcPtr->typePtr;
 }
@@ -10404,7 +10403,6 @@ SetChannelFromAny(
     register Tcl_Obj *objPtr)	/* The object to convert. */
 {
     ChannelState *statePtr;
-    Interp       *interpPtr;
 
     if (interp == NULL) {
 	return TCL_ERROR;
@@ -10415,12 +10413,11 @@ SetChannelFromAny(
 	 * Ensure consistency checks are done.
 	 */
 	statePtr  = GET_CHANNELSTATE(objPtr);
-	interpPtr = GET_CHANNELINTERP(objPtr);
 	if (statePtr->flags & (CHANNEL_TAINTED|CHANNEL_CLOSED)) {
 	    ResetFlag(statePtr, CHANNEL_TAINTED);
 	    Tcl_Release((ClientData) statePtr);
 	    objPtr->typePtr = NULL;
-	} else if (interpPtr != (Interp*) interp) {
+	} else if (interp != GET_CHANNELINTERP(objPtr)) {
 	    Tcl_Release((ClientData) statePtr);
 	    objPtr->typePtr = NULL;
 	}
-- 
cgit v0.12


From 009a17d3a03061610a2c281f18937e78e995855f Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Mon, 3 Feb 2014 14:43:52 +0000
Subject: Fix [651e828a52]: Wrong Windows version reported for Windows 8.1

---
 unix/tclUnixInit.c | 29 ++++++++++++++++++++++-------
 win/tclWinInit.c   | 18 ++++++++++++++----
 2 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/unix/tclUnixInit.c b/unix/tclUnixInit.c
index 0b98cf9..423e97e 100644
--- a/unix/tclUnixInit.c
+++ b/unix/tclUnixInit.c
@@ -33,7 +33,10 @@
 #endif
 
 #ifdef __CYGWIN__
-DLLIMPORT extern __stdcall unsigned char GetVersionExA(void *);
+DLLIMPORT extern __stdcall unsigned char GetVersionExW(void *);
+DLLIMPORT extern __stdcall void *LoadLibraryW(const void *);
+DLLIMPORT extern __stdcall void FreeLibrary(void *);
+DLLIMPORT extern __stdcall void *GetProcAddress(void *, const char *);
 DLLIMPORT extern __stdcall void GetSystemInfo(void *);
 
 #define NUMPLATFORMS 4
@@ -66,14 +69,14 @@ typedef struct _SYSTEM_INFO {
   int      wProcessorRevision;
 } SYSTEM_INFO;
 
-typedef struct _OSVERSIONINFOA {
+typedef struct _OSVERSIONINFOW {
   DWORD dwOSVersionInfoSize;
   DWORD dwMajorVersion;
   DWORD dwMinorVersion;
   DWORD dwBuildNumber;
   DWORD dwPlatformId;
-  char szCSDVersion[128];
-} OSVERSIONINFOA;
+  wchar_t szCSDVersion[128];
+} OSVERSIONINFOW;
 #endif
 
 #ifdef HAVE_COREFOUNDATION
@@ -811,7 +814,8 @@ TclpSetVariables(
 {
 #ifdef __CYGWIN__
     SYSTEM_INFO sysInfo;
-    OSVERSIONINFOA osInfo;
+    static OSVERSIONINFOW osInfo;
+    static int osInfoInitialized = 0;
     char buffer[TCL_INTEGER_SPACE * 2];
 #elif !defined(NO_UNAME)
     struct utsname name;
@@ -924,8 +928,19 @@ TclpSetVariables(
     unameOK = 0;
 #ifdef __CYGWIN__
 	unameOK = 1;
-    osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
-    GetVersionExA(&osInfo);
+    if (!osInfoInitialized) {
+      HANDLE handle = LoadLibraryW(L"NTDLL");
+      int(*getversion)(void *) = (int(*)(void *))GetProcAddress(handle, "RtlGetVersion");
+      osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
+      if (!getversion || getversion(&osInfo)) {
+        GetVersionExW(&osInfo);
+      }
+      if (handle) {
+        FreeLibrary(handle);
+      }
+      osInfoInitialized = 1;
+    }
+
     GetSystemInfo(&sysInfo);
 
     if (osInfo.dwPlatformId < NUMPLATFORMS) {
diff --git a/win/tclWinInit.c b/win/tclWinInit.c
index 81d762f..08ef1ed 100644
--- a/win/tclWinInit.c
+++ b/win/tclWinInit.c
@@ -563,7 +563,8 @@ TclpSetVariables(
 	SYSTEM_INFO info;
 	OemId oemId;
     } sys;
-    OSVERSIONINFOW osInfo;
+    static OSVERSIONINFOW osInfo;
+    static int osInfoInitialized = 0;
     Tcl_DString ds;
     WCHAR szUserName[UNLEN+1];
     DWORD cchUserNameLen = UNLEN;
@@ -571,9 +572,18 @@ TclpSetVariables(
     Tcl_SetVar2Ex(interp, "tclDefaultLibrary", NULL,
 	    TclGetProcessGlobalValue(&defaultLibraryDir), TCL_GLOBAL_ONLY);
 
-    osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
-    GetVersionExW(&osInfo);
-
+    if (!osInfoInitialized) {
+      HANDLE handle = LoadLibraryW(L"NTDLL");
+      int(*getversion)(void *) = (int(*)(void *))GetProcAddress(handle, "RtlGetVersion");
+      osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
+      if (!getversion || getversion(&osInfo)) {
+        GetVersionExW(&osInfo);
+      }
+      if (handle) {
+        FreeLibrary(handle);
+      }
+      osInfoInitialized = 1;
+    }
     GetSystemInfo(&sys.info);
 
     /*
-- 
cgit v0.12


From ee8ba589547e1b44b7851f0524f854e9b58f8dfe Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Tue, 4 Feb 2014 14:30:55 +0000
Subject: Be sure to finalize the identity encoding.

---
 generic/tclEncoding.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index c303dd1..1842fb6 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -658,6 +658,7 @@ TclFinalizeEncodingSubsystem(void)
     Tcl_MutexLock(&encodingMutex);
     encodingsInitialized = 0;
     FreeEncoding(systemEncoding);
+    FreeEncoding(tclIdentityEncoding);
 
     hPtr = Tcl_FirstHashEntry(&encodingTable, &search);
     while (hPtr != NULL) {
-- 
cgit v0.12


From 9901c4812ae35bda160641378fab124f87238b96 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Tue, 4 Feb 2014 21:21:53 +0000
Subject: Add missing __stdcall (which crashes on win32), and clean-up
 indenting

---
 unix/tclUnixInit.c | 22 ++++++++++++----------
 win/tclWinInit.c   | 21 +++++++++++----------
 2 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/unix/tclUnixInit.c b/unix/tclUnixInit.c
index 423e97e..11a65707 100644
--- a/unix/tclUnixInit.c
+++ b/unix/tclUnixInit.c
@@ -38,6 +38,7 @@ DLLIMPORT extern __stdcall void *LoadLibraryW(const void *);
 DLLIMPORT extern __stdcall void FreeLibrary(void *);
 DLLIMPORT extern __stdcall void *GetProcAddress(void *, const char *);
 DLLIMPORT extern __stdcall void GetSystemInfo(void *);
+DLLIMPORT extern __stdcall void GetSystemInfo(void *);
 
 #define NUMPLATFORMS 4
 static const char *const platforms[NUMPLATFORMS] = {
@@ -929,16 +930,17 @@ TclpSetVariables(
 #ifdef __CYGWIN__
 	unameOK = 1;
     if (!osInfoInitialized) {
-      HANDLE handle = LoadLibraryW(L"NTDLL");
-      int(*getversion)(void *) = (int(*)(void *))GetProcAddress(handle, "RtlGetVersion");
-      osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
-      if (!getversion || getversion(&osInfo)) {
-        GetVersionExW(&osInfo);
-      }
-      if (handle) {
-        FreeLibrary(handle);
-      }
-      osInfoInitialized = 1;
+	HANDLE handle = LoadLibraryW(L"NTDLL");
+	__stdcall int(*getversion)(void *) =
+		(__stdcall int(*)(void *))GetProcAddress(handle, "RtlGetVersion");
+	osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
+	if (!getversion || getversion(&osInfo)) {
+	    GetVersionExW(&osInfo);
+	}
+	if (handle) {
+	    FreeLibrary(handle);
+	}
+	osInfoInitialized = 1;
     }
 
     GetSystemInfo(&sysInfo);
diff --git a/win/tclWinInit.c b/win/tclWinInit.c
index 08ef1ed..f49edf0 100644
--- a/win/tclWinInit.c
+++ b/win/tclWinInit.c
@@ -573,16 +573,17 @@ TclpSetVariables(
 	    TclGetProcessGlobalValue(&defaultLibraryDir), TCL_GLOBAL_ONLY);
 
     if (!osInfoInitialized) {
-      HANDLE handle = LoadLibraryW(L"NTDLL");
-      int(*getversion)(void *) = (int(*)(void *))GetProcAddress(handle, "RtlGetVersion");
-      osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
-      if (!getversion || getversion(&osInfo)) {
-        GetVersionExW(&osInfo);
-      }
-      if (handle) {
-        FreeLibrary(handle);
-      }
-      osInfoInitialized = 1;
+	HANDLE handle = LoadLibraryW(L"NTDLL");
+	__stdcall int(*getversion)(void *) =
+		(__stdcall int(*)(void *)) GetProcAddress(handle, "RtlGetVersion");
+	osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
+	if (!getversion || getversion(&osInfo)) {
+	    GetVersionExW(&osInfo);
+	}
+	if (handle) {
+		FreeLibrary(handle);
+	}
+	osInfoInitialized = 1;
     }
     GetSystemInfo(&sys.info);
 
-- 
cgit v0.12


From e11501e82c5daaf3f89f915d6df764823e9edb86 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Tue, 4 Feb 2014 21:29:44 +0000
Subject: remove duplicate declaration

---
 unix/tclUnixInit.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/unix/tclUnixInit.c b/unix/tclUnixInit.c
index 11a65707..7e0b19a 100644
--- a/unix/tclUnixInit.c
+++ b/unix/tclUnixInit.c
@@ -38,7 +38,6 @@ DLLIMPORT extern __stdcall void *LoadLibraryW(const void *);
 DLLIMPORT extern __stdcall void FreeLibrary(void *);
 DLLIMPORT extern __stdcall void *GetProcAddress(void *, const char *);
 DLLIMPORT extern __stdcall void GetSystemInfo(void *);
-DLLIMPORT extern __stdcall void GetSystemInfo(void *);
 
 #define NUMPLATFORMS 4
 static const char *const platforms[NUMPLATFORMS] = {
-- 
cgit v0.12


From 7986522df51e69499b127ab05a24f697b5ac0849 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Tue, 4 Feb 2014 21:51:32 +0000
Subject: Satisfy required position of __stdcall from VC++

---
 unix/tclUnixInit.c | 4 ++--
 win/tclWinInit.c   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/unix/tclUnixInit.c b/unix/tclUnixInit.c
index 7e0b19a..a8cd00d 100644
--- a/unix/tclUnixInit.c
+++ b/unix/tclUnixInit.c
@@ -930,8 +930,8 @@ TclpSetVariables(
 	unameOK = 1;
     if (!osInfoInitialized) {
 	HANDLE handle = LoadLibraryW(L"NTDLL");
-	__stdcall int(*getversion)(void *) =
-		(__stdcall int(*)(void *))GetProcAddress(handle, "RtlGetVersion");
+	int(__stdcall *getversion)(void *) =
+		(int(__stdcall *)(void *))GetProcAddress(handle, "RtlGetVersion");
 	osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
 	if (!getversion || getversion(&osInfo)) {
 	    GetVersionExW(&osInfo);
diff --git a/win/tclWinInit.c b/win/tclWinInit.c
index f49edf0..2f3c7e8 100644
--- a/win/tclWinInit.c
+++ b/win/tclWinInit.c
@@ -574,8 +574,8 @@ TclpSetVariables(
 
     if (!osInfoInitialized) {
 	HANDLE handle = LoadLibraryW(L"NTDLL");
-	__stdcall int(*getversion)(void *) =
-		(__stdcall int(*)(void *)) GetProcAddress(handle, "RtlGetVersion");
+	int(__stdcall *getversion)(void *) =
+		(int(__stdcall *)(void *)) GetProcAddress(handle, "RtlGetVersion");
 	osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
 	if (!getversion || getversion(&osInfo)) {
 	    GetVersionExW(&osInfo);
-- 
cgit v0.12