From 5cedce81d3ffdc7413339ab0e96fc79b3a67b8c0 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Tue, 23 May 2017 21:57:13 +0000
Subject: [win32] optimized calibration cycle (makes Tcl for windows "RTS"
 resp. NRT-capable): - the clock ticks never backwards (avoid it by negative
 drifts using comparison of times before and after calibration); - more
 precise, smooth/soft drifting (avoids too large drifts, already after 10
 iterations the drift gets fewer as 0.1 microseconds); - because of more
 accurate drifting (aspire to the smallest difference), we can prolong
 calibration interval (up to 10 seconds by small tdiff-value);

Closes ticket [b7b707a310ea42e9f1b29954ee8ca13ae91ccabe] "[win32] NRT-only - NativeGetTime backwards time-drifts bug"
---
 win/tclWinTime.c | 175 ++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 122 insertions(+), 53 deletions(-)

diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index 374c41c..93f62b8 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -51,6 +51,7 @@ typedef struct TimeInfo {
 				 * initialized. */
     int perfCounterAvailable;	/* Flag == 1 if the hardware has a performance
 				 * counter. */
+    DWORD calibrationInterv;	/* Calibration interval in seconds (start 1 sec) */
     HANDLE calibrationThread;	/* Handle to the thread that keeps the virtual
 				 * clock calibrated. */
     HANDLE readyEvent;		/* System event used to trigger the requesting
@@ -61,7 +62,6 @@ typedef struct TimeInfo {
     LARGE_INTEGER nominalFreq;	/* Nominal frequency of the system performance
 				 * counter, that is, the value returned from
 				 * QueryPerformanceFrequency. */
-
     /*
      * The following values are used for calculating virtual time. Virtual
      * time is always equal to:
@@ -74,6 +74,8 @@ typedef struct TimeInfo {
     ULARGE_INTEGER fileTimeLastCall;
     LARGE_INTEGER perfCounterLastCall;
     LARGE_INTEGER curCounterFreq;
+    LARGE_INTEGER posixEpoch;	/* Posix epoch expressed as 100-ns ticks since
+				 * the windows epoch. */
 
     /*
      * Data used in developing the estimate of performance counter frequency
@@ -87,9 +89,10 @@ typedef struct TimeInfo {
 } TimeInfo;
 
 static TimeInfo timeInfo = {
-    { NULL },
+    { NULL, 0, 0, NULL, NULL, 0 },
     0,
     0,
+    1,
     (HANDLE) NULL,
     (HANDLE) NULL,
     (HANDLE) NULL,
@@ -98,11 +101,13 @@ static TimeInfo timeInfo = {
     (ULARGE_INTEGER) (DWORDLONG) 0,
     (LARGE_INTEGER) (Tcl_WideInt) 0,
     (LARGE_INTEGER) (Tcl_WideInt) 0,
+    (LARGE_INTEGER) (Tcl_WideInt) 0,
 #else
-    0,
-    0,
-    0,
-    0,
+    {0, 0},
+    {0, 0},
+    {0, 0},
+    {0, 0},
+    {0, 0},
 #endif
     { 0 },
     { 0 },
@@ -464,12 +469,20 @@ NativeScaleTime(
  *----------------------------------------------------------------------
  */
 
+static inline Tcl_WideInt
+NativeCalc100NsTicks(
+    ULONGLONG fileTimeLastCall,
+    LONGLONG perfCounterLastCall,
+    LONGLONG curCounterFreq,
+    LONGLONG curCounter
+) {
+    return fileTimeLastCall + 
+	((curCounter - perfCounterLastCall) * 10000000 / curCounterFreq);
+}
+
 static Tcl_WideInt
 NativeGetMicroseconds(void)
 {
-    static LARGE_INTEGER posixEpoch;
-				/* Posix epoch expressed as 100-ns ticks since
-				 * the windows epoch. */
     /*
      * Initialize static storage on the first trip through.
      *
@@ -481,8 +494,8 @@ NativeGetMicroseconds(void)
 	TclpInitLock();
 	if (!timeInfo.initialized) {
 
-	    posixEpoch.LowPart = 0xD53E8000;
-	    posixEpoch.HighPart = 0x019DB1DE;
+	    timeInfo.posixEpoch.LowPart = 0xD53E8000;
+	    timeInfo.posixEpoch.HighPart = 0x019DB1DE;
 
 	    timeInfo.perfCounterAvailable =
 		    QueryPerformanceFrequency(&timeInfo.nominalFreq);
@@ -588,16 +601,12 @@ NativeGetMicroseconds(void)
 	 * time.
 	 */
 
-	ULARGE_INTEGER fileTimeLastCall;
-	LARGE_INTEGER perfCounterLastCall, curCounterFreq;
+	ULONGLONG fileTimeLastCall;
+	LONGLONG perfCounterLastCall, curCounterFreq;
 				/* Copy with current data of calibration cycle */
 
 	LARGE_INTEGER curCounter;
 				/* Current performance counter. */
-	Tcl_WideInt curFileTime;/* Current estimated time, expressed as 100-ns
-				 * ticks since the Windows epoch. */
-	Tcl_WideInt usecSincePosixEpoch;
-				/* Current microseconds since Posix epoch. */
 
 	QueryPerformanceCounter(&curCounter);
 
@@ -606,19 +615,18 @@ NativeGetMicroseconds(void)
 	 */
 	EnterCriticalSection(&timeInfo.cs);
 
-	fileTimeLastCall.QuadPart = timeInfo.fileTimeLastCall.QuadPart;
-	perfCounterLastCall.QuadPart = timeInfo.perfCounterLastCall.QuadPart;
-	curCounterFreq.QuadPart = timeInfo.curCounterFreq.QuadPart;
+	fileTimeLastCall = timeInfo.fileTimeLastCall.QuadPart;
+	perfCounterLastCall = timeInfo.perfCounterLastCall.QuadPart;
+	curCounterFreq = timeInfo.curCounterFreq.QuadPart;
 
 	LeaveCriticalSection(&timeInfo.cs);
 
 	/*
 	 * If calibration cycle occurred after we get curCounter
 	 */
-	if (curCounter.QuadPart <= perfCounterLastCall.QuadPart) {
-	    usecSincePosixEpoch =
-		(fileTimeLastCall.QuadPart - posixEpoch.QuadPart) / 10;
-	    return usecSincePosixEpoch;
+	if (curCounter.QuadPart <= perfCounterLastCall) {
+	    /* Calibrated file-time is saved from posix in 100-ns ticks */
+	    return fileTimeLastCall / 10;
 	}
 
 	/*
@@ -631,15 +639,12 @@ NativeGetMicroseconds(void)
 	 * loop should recover.
 	 */
 
-	if (curCounter.QuadPart - perfCounterLastCall.QuadPart <
-		11 * curCounterFreq.QuadPart / 10
+	if (curCounter.QuadPart - perfCounterLastCall <
+		11 * curCounterFreq * timeInfo.calibrationInterv / 10
 	) {
-	    curFileTime = fileTimeLastCall.QuadPart +
-		 ((curCounter.QuadPart - perfCounterLastCall.QuadPart)
-		    * 10000000 / curCounterFreq.QuadPart);
-
-	    usecSincePosixEpoch = (curFileTime - posixEpoch.QuadPart) / 10;
-	    return usecSincePosixEpoch;
+	    /* Calibrated file-time is saved from posix in 100-ns ticks */
+	    return NativeCalc100NsTicks(fileTimeLastCall,
+		perfCounterLastCall, curCounterFreq, curCounter.QuadPart) / 10;
 	}
     }
 
@@ -710,6 +715,8 @@ NativeGetTime(
  *----------------------------------------------------------------------
  */
 
+void TclWinResetTimerResolution(void);
+
 static void
 StopCalibration(
     ClientData unused)		/* Client data is unused */
@@ -1076,6 +1083,8 @@ CalibrationThread(
     QueryPerformanceFrequency(&timeInfo.curCounterFreq);
     timeInfo.fileTimeLastCall.LowPart = curFileTime.dwLowDateTime;
     timeInfo.fileTimeLastCall.HighPart = curFileTime.dwHighDateTime;
+    /* Calibrated file-time will be saved from posix in 100-ns ticks */
+    timeInfo.fileTimeLastCall.QuadPart -= timeInfo.posixEpoch.QuadPart;
 
     ResetCounterSamples(timeInfo.fileTimeLastCall.QuadPart,
 	    timeInfo.perfCounterLastCall.QuadPart,
@@ -1135,6 +1144,7 @@ UpdateTimeEachSecond(void)
 				/* Current value returned from
 				 * QueryPerformanceCounter. */
     FILETIME curSysTime;	/* Current system time. */
+    static LARGE_INTEGER lastFileTime; /* File time of the previous calibration */
     LARGE_INTEGER curFileTime;	/* File time at the time this callback was
 				 * scheduled. */
     Tcl_WideInt estFreq;	/* Estimated perf counter frequency. */
@@ -1146,15 +1156,24 @@ UpdateTimeEachSecond(void)
 				 * step over 1 second. */
 
     /*
-     * Sample performance counter and system time.
+     * Sample performance counter and system time (from posix epoch).
      */
 
-    QueryPerformanceCounter(&curPerfCounter);
     GetSystemTimeAsFileTime(&curSysTime);
     curFileTime.LowPart = curSysTime.dwLowDateTime;
     curFileTime.HighPart = curSysTime.dwHighDateTime;
-
-    EnterCriticalSection(&timeInfo.cs);
+    curFileTime.QuadPart -= timeInfo.posixEpoch.QuadPart;
+    /* If calibration still not needed (check for possible time switch) */
+    if ( curFileTime.QuadPart > lastFileTime.QuadPart
+      && curFileTime.QuadPart < lastFileTime.QuadPart +
+      				    (timeInfo.calibrationInterv * 10000000)
+    ) {
+    	/* again in next one second */
+	return;
+    }
+    QueryPerformanceCounter(&curPerfCounter);
+    
+    lastFileTime.QuadPart = curFileTime.QuadPart;
 
     /*
      * We devide by timeInfo.curCounterFreq.QuadPart in several places. That
@@ -1166,7 +1185,6 @@ UpdateTimeEachSecond(void)
      */
 
     if (timeInfo.curCounterFreq.QuadPart == 0){
-	LeaveCriticalSection(&timeInfo.cs);
 	timeInfo.perfCounterAvailable = 0;
 	return;
     }
@@ -1185,7 +1203,7 @@ UpdateTimeEachSecond(void)
      * estimate the performance counter frequency.
      */
 
-    estFreq = AccumulateSample(curPerfCounter.QuadPart,
+     estFreq = AccumulateSample(curPerfCounter.QuadPart,
 	    (Tcl_WideUInt) curFileTime.QuadPart);
 
     /*
@@ -1205,12 +1223,9 @@ UpdateTimeEachSecond(void)
      * is estFreq * 20000000 / (vt1 - vt0)
      */
 
-    vt0 = 10000000 * (curPerfCounter.QuadPart
-		- timeInfo.perfCounterLastCall.QuadPart)
-	    / timeInfo.curCounterFreq.QuadPart
-	    + timeInfo.fileTimeLastCall.QuadPart;
-    vt1 = 20000000 + curFileTime.QuadPart;
-
+    vt0 = NativeCalc100NsTicks(timeInfo.fileTimeLastCall.QuadPart,
+	    timeInfo.perfCounterLastCall.QuadPart, timeInfo.curCounterFreq.QuadPart,
+	    curPerfCounter.QuadPart);
     /*
      * If we've gotten more than a second away from system time, then drifting
      * the clock is going to be pretty hopeless. Just let it jump. Otherwise,
@@ -1219,21 +1234,75 @@ UpdateTimeEachSecond(void)
 
     tdiff = vt0 - curFileTime.QuadPart;
     if (tdiff > 10000000 || tdiff < -10000000) {
-	timeInfo.fileTimeLastCall.QuadPart = curFileTime.QuadPart;
-	timeInfo.curCounterFreq.QuadPart = estFreq;
+    	/* jump to current system time, use curent estimated frequency */
+    	vt0 = curFileTime.QuadPart;
     } else {
-	driftFreq = estFreq * 20000000 / (vt1 - vt0);
+    	/* calculate new frequency and estimate drift to the next second */
+	vt1 = 20000000 + curFileTime.QuadPart;
+	driftFreq = (estFreq * 20000000 / (vt1 - vt0));
+	/* 
+	 * Avoid too large drifts (only half of the current difference),
+	 * that allows also be more accurate (aspire to the smallest tdiff),
+	 * so then we can prolong calibration interval by tdiff < 100000
+	 */
+	driftFreq = timeInfo.curCounterFreq.QuadPart +
+		(driftFreq - timeInfo.curCounterFreq.QuadPart) / 2;
 
-	if (driftFreq > 1003*estFreq/1000) {
-	    driftFreq = 1003*estFreq/1000;
-	} else if (driftFreq < 997*estFreq/1000) {
-	    driftFreq = 997*estFreq/1000;
+	/* 
+	 * Average between estimated, 2 current and 5 drifted frequencies,
+	 * (do the soft drifting as possible)
+	 */
+	estFreq = (estFreq + 2 * timeInfo.curCounterFreq.QuadPart + 5 * driftFreq) / 8;
+    }
+    
+    /* Avoid too large discrepancy from nominal frequency */
+    if (estFreq > 1003*timeInfo.nominalFreq.QuadPart/1000) {
+	estFreq = 1003*timeInfo.nominalFreq.QuadPart/1000;
+	vt0 = curFileTime.QuadPart;
+    } else if (estFreq < 997*timeInfo.nominalFreq.QuadPart/1000) {
+	estFreq = 997*timeInfo.nominalFreq.QuadPart/1000;
+	vt0 = curFileTime.QuadPart;
+    } else if (vt0 != curFileTime.QuadPart) {
+	/* 
+	 * Be sure the clock ticks never backwards (avoid it by negative drifting)
+	 * just compare native time (in 100-ns) before and hereafter using 
+	 * new calibrated values) and do a small adjustment (short time freeze)
+	 */
+	LARGE_INTEGER newPerfCounter;
+	Tcl_WideInt nt0, nt1;
+
+	QueryPerformanceCounter(&newPerfCounter);
+	nt0 = NativeCalc100NsTicks(timeInfo.fileTimeLastCall.QuadPart,
+		timeInfo.perfCounterLastCall.QuadPart, timeInfo.curCounterFreq.QuadPart,
+		newPerfCounter.QuadPart);
+	nt1 = NativeCalc100NsTicks(vt0,
+		curPerfCounter.QuadPart, estFreq,
+		newPerfCounter.QuadPart);
+	if (nt0 > nt1) { /* drifted backwards, try to compensate with new base */
+	    /* first adjust with a micro jump (short frozen time is acceptable) */
+	    vt0 += nt0 - nt1;
+	    /* if drift unavoidable (e. g. we had a time switch), then reset it */
+	    vt1 = vt0 - curFileTime.QuadPart;
+	    if (vt1 > 10000000 || vt1 < -10000000) {
+	    	/* larger jump resp. shift relative new file-time */
+	    	vt0 = curFileTime.QuadPart;
+	    }
 	}
+    }
+
+    /* In lock commit new values to timeInfo (hold lock as short as possible) */
+    EnterCriticalSection(&timeInfo.cs);
 
-	timeInfo.fileTimeLastCall.QuadPart = vt0;
-	timeInfo.curCounterFreq.QuadPart = driftFreq;
+    /* grow calibration interval up to 10 seconds (if still precise enough) */
+    if (tdiff < -100000 || tdiff > 100000) {
+	/* too long drift - reset calibration interval to 1000 second */
+	timeInfo.calibrationInterv = 1;
+    } else if (timeInfo.calibrationInterv < 10) {
+	timeInfo.calibrationInterv++;
     }
 
+    timeInfo.fileTimeLastCall.QuadPart = vt0;
+    timeInfo.curCounterFreq.QuadPart = estFreq;
     timeInfo.perfCounterLastCall.QuadPart = curPerfCounter.QuadPart;
 
     LeaveCriticalSection(&timeInfo.cs);
-- 
cgit v0.12


From 5c5c34d0f377a01a93633a879290b3ecda260b9a Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:21:24 +0000
Subject: [performance] after-event list optimized (interp-assoc switched to
 doubly linked list, because requires handling from both ends of the list)

---
 generic/tclInt.h   | 30 ++++++++++++++++++++++++---
 generic/tclTimer.c | 59 ++++++++++++++++++++++++------------------------------
 2 files changed, 53 insertions(+), 36 deletions(-)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index a184950..7e70627 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -1946,18 +1946,37 @@ typedef struct Interp {
  * existence of struct items 'prevPtr' and 'nextPtr'.
  *
  * a = element to add or remove.
- * b = list head.
+ * b = list head (points to the first element).
+ * e = list tail (points to the last element).
  *
  * TclSpliceIn adds to the head of the list.
+ * TclSpliceTail adds to the tail of the list.
  */
 
 #define TclSpliceIn(a,b)			\
-    (a)->nextPtr = (b);				\
-    if ((b) != NULL) {				\
+    if (((a)->nextPtr = (b)) != NULL) {		\
 	(b)->prevPtr = (a);			\
     }						\
     (a)->prevPtr = NULL, (b) = (a);
 
+#define TclSpliceInEx(a,b,e)			\
+    TclSpliceIn(a,b);				\
+    if ((e) == NULL) {				\
+	(e) = (a);				\
+    }
+
+#define TclSpliceTail(a,e)			\
+    if (((a)->prevPtr = (e)) != NULL) {		\
+	(e)->nextPtr = (a);			\
+    }						\
+    (a)->nextPtr = NULL, (e) = (a);
+
+#define TclSpliceTailEx(a,b,e)			\
+    TclSpliceTail(a,e);				\
+    if ((b) == NULL) {				\
+	(b) = (a);				\
+    }
+
 #define TclSpliceOut(a,b)			\
     if ((a)->prevPtr != NULL) {			\
 	(a)->prevPtr->nextPtr = (a)->nextPtr;	\
@@ -1968,6 +1987,11 @@ typedef struct Interp {
 	(a)->nextPtr->prevPtr = (a)->prevPtr;	\
     }
 
+#define TclSpliceOutEx(a,b,e)			\
+    TclSpliceOut(a,b) else {			\
+	(e) = (e)->prevPtr;			\
+    }
+
 /*
  * EvalFlag bits for Interp structures:
  *
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 33838ec..d05320d 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -49,6 +49,8 @@ typedef struct AfterInfo {
 				 * rather than a timer handler. */
     struct AfterInfo *nextPtr;	/* Next in list of all "after" commands for
 				 * this interpreter. */
+    struct AfterInfo *prevPtr;	/* Prev in list of all "after" commands for
+				 * this interpreter. */
 } AfterInfo;
 
 /*
@@ -63,6 +65,7 @@ typedef struct AfterAssocData {
     AfterInfo *firstAfterPtr;	/* First in list of all "after" commands still
 				 * pending for this interpreter, or NULL if
 				 * none. */
+    AfterInfo *lastAfterPtr;	/* Last in list of all "after" commands. */
 } AfterAssocData;
 
 /*
@@ -797,6 +800,7 @@ Tcl_AfterObjCmd(
 	assocPtr = (AfterAssocData *) ckalloc(sizeof(AfterAssocData));
 	assocPtr->interp = interp;
 	assocPtr->firstAfterPtr = NULL;
+	assocPtr->lastAfterPtr = NULL;
 	Tcl_SetAssocData(interp, "tclAfter", AfterCleanupProc,
 		(ClientData) assocPtr);
     }
@@ -865,8 +869,9 @@ Tcl_AfterObjCmd(
 	}
 	afterPtr->token = TclCreateAbsoluteTimerHandler(&wakeup, AfterProc,
 							(ClientData) afterPtr);
-	afterPtr->nextPtr = assocPtr->firstAfterPtr;
-	assocPtr->firstAfterPtr = afterPtr;
+	/* attach to the list */
+	TclSpliceTailEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
+
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
 	return TCL_OK;
     }
@@ -885,8 +890,8 @@ Tcl_AfterObjCmd(
 	    commandPtr = Tcl_ConcatObj(objc-2, objv+2);;
 	}
 	command = Tcl_GetStringFromObj(commandPtr, &length);
-	for (afterPtr = assocPtr->firstAfterPtr;  afterPtr != NULL;
-		afterPtr = afterPtr->nextPtr) {
+	for (afterPtr = assocPtr->lastAfterPtr;  afterPtr != NULL;
+		afterPtr = afterPtr->prevPtr) {
 	    tempCommand = Tcl_GetStringFromObj(afterPtr->commandPtr,
 		    &tempLength);
 	    if ((length == tempLength)
@@ -927,8 +932,9 @@ Tcl_AfterObjCmd(
 	afterPtr->id = tsdPtr->afterId;
 	tsdPtr->afterId += 1;
 	afterPtr->token = NULL;
-	afterPtr->nextPtr = assocPtr->firstAfterPtr;
-	assocPtr->firstAfterPtr = afterPtr;
+	/* attach to the list */
+	TclSpliceTailEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
+
 	Tcl_DoWhenIdle(AfterProc, (ClientData) afterPtr);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
 	break;
@@ -936,8 +942,8 @@ Tcl_AfterObjCmd(
 	Tcl_Obj *resultListPtr;
 
 	if (objc == 2) {
-	    for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
-		    afterPtr = afterPtr->nextPtr) {
+	    for (afterPtr = assocPtr->lastAfterPtr; afterPtr != NULL;
+		    afterPtr = afterPtr->prevPtr) {
 		if (assocPtr->interp == interp) {
 		    sprintf(buf, "after#%d", afterPtr->id);
 		    Tcl_AppendElement(interp, buf);
@@ -1082,8 +1088,8 @@ GetAfterEvent(
     if ((end == cmdString) || (*end != 0)) {
 	return NULL;
     }
-    for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
-	    afterPtr = afterPtr->nextPtr) {
+    for (afterPtr = assocPtr->lastAfterPtr; afterPtr != NULL;
+	    afterPtr = afterPtr->prevPtr) {
 	if (afterPtr->id == id) {
 	    return afterPtr;
 	}
@@ -1116,7 +1122,6 @@ AfterProc(
 {
     AfterInfo *afterPtr = (AfterInfo *) clientData;
     AfterAssocData *assocPtr = afterPtr->assocPtr;
-    AfterInfo *prevPtr;
     int result;
     Tcl_Interp *interp;
 
@@ -1126,15 +1131,8 @@ AfterProc(
      * a core dump.
      */
 
-    if (assocPtr->firstAfterPtr == afterPtr) {
-	assocPtr->firstAfterPtr = afterPtr->nextPtr;
-    } else {
-	for (prevPtr = assocPtr->firstAfterPtr; prevPtr->nextPtr != afterPtr;
-		prevPtr = prevPtr->nextPtr) {
-	    /* Empty loop body. */
-	}
-	prevPtr->nextPtr = afterPtr->nextPtr;
-    }
+    /* detach entry from the owner's list */
+    TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 
     /*
      * Execute the callback.
@@ -1179,18 +1177,12 @@ static void
 FreeAfterPtr(
     AfterInfo *afterPtr)		/* Command to be deleted. */
 {
-    AfterInfo *prevPtr;
     AfterAssocData *assocPtr = afterPtr->assocPtr;
 
-    if (assocPtr->firstAfterPtr == afterPtr) {
-	assocPtr->firstAfterPtr = afterPtr->nextPtr;
-    } else {
-	for (prevPtr = assocPtr->firstAfterPtr; prevPtr->nextPtr != afterPtr;
-		prevPtr = prevPtr->nextPtr) {
-	    /* Empty loop body. */
-	}
-	prevPtr->nextPtr = afterPtr->nextPtr;
-    }
+    /* detach entry from the owner's list */
+    TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
+
+    /* free command and entry */
     Tcl_DecrRefCount(afterPtr->commandPtr);
     ckfree((char *) afterPtr);
 }
@@ -1222,9 +1214,10 @@ AfterCleanupProc(
     AfterAssocData *assocPtr = (AfterAssocData *) clientData;
     AfterInfo *afterPtr;
 
-    while (assocPtr->firstAfterPtr != NULL) {
-	afterPtr = assocPtr->firstAfterPtr;
-	assocPtr->firstAfterPtr = afterPtr->nextPtr;
+    while ( (afterPtr = assocPtr->lastAfterPtr) ) {
+	/* detach entry from the owner's list */
+	TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
+
 	if (afterPtr->token != NULL) {
 	    Tcl_DeleteTimerHandler(afterPtr->token);
 	} else {
-- 
cgit v0.12


From 04a1210ce8351b888d853d55e0eb0cade2dc0deb Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:21:34 +0000
Subject: timer resp. idle events optimized: better handling using doubly
 linked lists, prevents allocating memory twice for the "after" events (use
 memory inside timer/idle event for the "after" structure), etc.

---
 generic/tcl.h      |   2 +
 generic/tclInt.h   |  67 +++++++
 generic/tclTimer.c | 539 ++++++++++++++++++++++++++++++++++-------------------
 3 files changed, 418 insertions(+), 190 deletions(-)

diff --git a/generic/tcl.h b/generic/tcl.h
index 64c4683..e36f4d8 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -696,6 +696,7 @@ typedef void (Tcl_FileFreeProc) _ANSI_ARGS_((ClientData clientData));
 typedef void (Tcl_FreeInternalRepProc) _ANSI_ARGS_((struct Tcl_Obj *objPtr));
 typedef void (Tcl_FreeProc) _ANSI_ARGS_((char *blockPtr));
 typedef void (Tcl_IdleProc) _ANSI_ARGS_((ClientData clientData));
+typedef void (Tcl_IdleDeleteProc) _ANSI_ARGS_((ClientData clientData));
 typedef void (Tcl_InterpDeleteProc) _ANSI_ARGS_((ClientData clientData,
 	Tcl_Interp *interp));
 typedef int (Tcl_MathProc) _ANSI_ARGS_((ClientData clientData,
@@ -710,6 +711,7 @@ typedef void (Tcl_PanicProc) _ANSI_ARGS_((CONST char *format, ...));
 typedef void (Tcl_TcpAcceptProc) _ANSI_ARGS_((ClientData callbackData,
 	Tcl_Channel chan, char *address, int port));
 typedef void (Tcl_TimerProc) _ANSI_ARGS_((ClientData clientData));
+typedef void (Tcl_TimerDeleteProc) _ANSI_ARGS_((ClientData clientData));
 typedef int (Tcl_SetFromAnyProc) _ANSI_ARGS_((Tcl_Interp *interp,
 	struct Tcl_Obj *objPtr));
 typedef void (Tcl_UpdateStringProc) _ANSI_ARGS_((struct Tcl_Obj *objPtr));
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 7e70627..99f9346 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2499,6 +2499,65 @@ MODULE_SCOPE char	tclEmptyString;
 #define TCL_DD_SHORTEST0		0x0
 				/* 'Shortest possible' after masking */
 
+
+
+/*
+ *----------------------------------------------------------------
+ * Data structures related to timer / idle events.
+ *----------------------------------------------------------------
+ */
+
+/*
+ * For each timer callback that's pending there is one record of the following
+ * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
+ * together in a list sorted by time (earliest event first).
+ */
+
+				 
+typedef struct TimerHandler {
+    Tcl_TimerProc	*proc;	/* Function to call timer event */
+    Tcl_TimerDeleteProc *deleteProc; /* Function to cleanup timer event */
+    ClientData clientData;	/* Argument to pass to proc and deleteProc */
+    size_t generation;		/* Used to distinguish older handlers from
+				 * recently-created ones. */
+    Tcl_TimerToken token;	/* Identifies handler so it can be deleted. */
+    struct TimerHandler *nextPtr; /* Next and prev event in timer/idle queue, */
+    struct TimerHandler *prevPtr; /* or NULL for end/start of the queue. */
+    Tcl_Time	time;		/* When timer is to fire (if timer event). */
+/*  ExtraData	 */
+} TimerHandler;
+
+/*
+ * There is one of the following structures for each of the handlers declared
+ * in a call to Tcl_DoWhenIdle. All of the currently-active handlers are
+ * linked together into a list.
+ */
+
+typedef struct IdleHandler {
+    Tcl_IdleProc	*proc;	/* Function to call idle event */
+    Tcl_IdleDeleteProc  *deleteProc; /* Function to cleanup idle event */
+    ClientData clientData;	/* Argument to pass to proc and deleteProc */
+    size_t generation;		/* Used to distinguish older handlers from
+				 * recently-created ones. */
+    struct IdleHandler *nextPtr;/* Next and prev event in idle queue, */
+    struct IdleHandler *prevPtr;/* or NULL for end/start of the queue. */
+/*  ExtraData	 */
+} IdleHandler;
+
+
+/*
+ * Macros to wrap ExtraData and TimerHandler resp. IdleHandler (and vice versa)
+ */
+#define TimerHandler2ClientData(ptr)					\
+	    ( (ClientData)(((TimerHandler *)(ptr))+1) )
+#define ClientData2TimerHandler(ptr)					\
+	    ( ((TimerHandler *)(ptr))-1 )
+
+#define IdleHandler2ClientData(ptr)					\
+	    ( (ClientData)(((IdleHandler *)(ptr))+1) )
+#define ClientData2IdleHandler(ptr)					\
+	    ( ((IdleHandler *)(ptr))-1 )
+
 /*
  *----------------------------------------------------------------
  * Procedures shared among Tcl modules but not used by the outside world:
@@ -2867,6 +2926,14 @@ MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
 			    ClientData clientData);
+MODULE_SCOPE TimerHandler*  TclCreateAbsoluteTimerHandlerEx(
+			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
+			    Tcl_TimerDeleteProc *deleteProc, size_t extraSize);
+MODULE_SCOPE void	TclDeleteTimerHandler(TimerHandler *timerHandlerPtr);
+MODULE_SCOPE IdleHandler*   TclCreateIdleHandlerEx(
+			    Tcl_IdleProc *proc, Tcl_IdleDeleteProc *deleteProc,
+			    size_t extraDataSize);
+MODULE_SCOPE void	TclDeleteIdleHandler(IdleHandler *idlePtr);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index d05320d..40316ca 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -13,40 +13,21 @@
 #include "tclInt.h"
 
 /*
- * For each timer callback that's pending there is one record of the following
- * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
- * together in a list sorted by time (earliest event first).
- */
-
-typedef struct TimerHandler {
-    Tcl_Time time;		/* When timer is to fire. */
-    Tcl_TimerProc *proc;	/* Function to call. */
-    ClientData clientData;	/* Argument to pass to proc. */
-    Tcl_TimerToken token;	/* Identifies handler so it can be deleted. */
-    struct TimerHandler *nextPtr;
-				/* Next event in queue, or NULL for end of
-				 * queue. */
-} TimerHandler;
-
-/*
  * The data structure below is used by the "after" command to remember the
  * command to be executed later. All of the pending "after" commands for an
  * interpreter are linked together in a list.
  */
 
+#define IDLE_EVENT  (1 << 1)	/* Mark idle event */
+
 typedef struct AfterInfo {
     struct AfterAssocData *assocPtr;
 				/* Pointer to the "tclAfter" assocData for the
 				 * interp in which command will be
 				 * executed. */
     Tcl_Obj *commandPtr;	/* Command to execute. */
-    int id;			/* Integer identifier for command; used to
-				 * cancel it. */
-    Tcl_TimerToken token;	/* Used to cancel the "after" command. NULL
-				 * means that the command is run as an idle
-				 * handler rather than as a timer handler.
-				 * NULL means this is an "after idle" handler
-				 * rather than a timer handler. */
+    size_t id;			/* Integer identifier for command */
+    int			flags;	/* Flags (IDLE_EVENT) */
     struct AfterInfo *nextPtr;	/* Next in list of all "after" commands for
 				 * this interpreter. */
     struct AfterInfo *prevPtr;	/* Prev in list of all "after" commands for
@@ -69,20 +50,6 @@ typedef struct AfterAssocData {
 } AfterAssocData;
 
 /*
- * There is one of the following structures for each of the handlers declared
- * in a call to Tcl_DoWhenIdle. All of the currently-active handlers are
- * linked together into a list.
- */
-
-typedef struct IdleHandler {
-    Tcl_IdleProc (*proc);	/* Function to call. */
-    ClientData clientData;	/* Value to pass to proc. */
-    int generation;		/* Used to distinguish older handlers from
-				 * recently-created ones. */
-    struct IdleHandler *nextPtr;/* Next in list of active handlers. */
-} IdleHandler;
-
-/*
  * The timer and idle queues are per-thread because they are associated with
  * the notifier, which is also per-thread.
  *
@@ -94,25 +61,42 @@ typedef struct IdleHandler {
  * The structure defined below is used in this file only.
  */
 
-typedef struct ThreadSpecificData {
-    TimerHandler *firstTimerHandlerPtr;	/* First event in queue. */
+typedef struct {
+    TimerHandler *timerList;	/* First event in queue. */
+    TimerHandler *lastTimerPtr;	/* Last event in queue. */
+    size_t timerListEpoch;	/* Used for safe process of event queue (stop
+    				 * the cycle after modifying of event queue) */
     int lastTimerId;		/* Timer identifier of most recently created
 				 * timer. */
     int timerPending;		/* 1 if a timer event is in the queue. */
     IdleHandler *idleList;	/* First in list of all idle handlers. */
     IdleHandler *lastIdlePtr;	/* Last in list (or NULL for empty list). */
-    int idleGeneration;		/* Used to fill in the "generation" fields of
-				 * IdleHandler structures. Increments each
-				 * time Tcl_DoOneEvent starts calling idle
-				 * handlers, so that all old handlers can be
+    size_t timerGeneration;	/* Used to fill in the "generation" fields of */
+    size_t idleGeneration;	/* timer or idle structures. Increments each
+				 * time we place a new handler to queue inside,
+				 * a new loop, so that all old handlers can be
 				 * called without calling any of the new ones
 				 * created by old ones. */
-    int afterId;		/* For unique identifiers of after events. */
+    size_t afterId;		/* For unique identifiers of after events. */
 } ThreadSpecificData;
 
 static Tcl_ThreadDataKey dataKey;
 
 /*
+ * Helper macros to wrap AfterInfo and handlers (and vice versa)
+ */
+
+#define TimerHandler2AfterInfo(ptr)					\
+	    ( (AfterInfo*)TimerHandler2ClientData(ptr) )
+#define AfterInfo2TimerHandler(ptr)					\
+	    ClientData2TimerHandler(ptr)
+
+#define IdleHandler2AfterInfo(ptr)					\
+	    ( (AfterInfo*)IdleHandler2ClientData(ptr) )
+#define AfterInfo2IdleHandler(ptr)					\
+	    ClientData2IdleHandler(ptr)
+
+/*
  * Helper macros for working with times. TCL_TIME_BEFORE encodes how to write
  * the ordering relation on (normalized) times, and TCL_TIME_DIFF_MS computes
  * the number of milliseconds difference between two times. Both macros use
@@ -138,7 +122,7 @@ static void		AfterCleanupProc(ClientData clientData,
 			    Tcl_Interp *interp);
 static int		AfterDelay(Tcl_Interp *interp, Tcl_WideInt ms);
 static void		AfterProc(ClientData clientData);
-static void		FreeAfterPtr(AfterInfo *afterPtr);
+static void		FreeAfterPtr(ClientData clientData);
 static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr,
 			    Tcl_Obj *commandPtr);
 static ThreadSpecificData *InitTimer(void);
@@ -146,8 +130,8 @@ static void		TimerExitProc(ClientData clientData);
 static int		TimerHandlerEventProc(Tcl_Event *evPtr, int flags);
 static void		TimerCheckProc(ClientData clientData, int flags);
 static void		TimerSetupProc(ClientData clientData, int flags);
-
-/*
+
+/*
  *----------------------------------------------------------------------
  *
  * InitTimer --
@@ -205,12 +189,11 @@ TimerExitProc(
     if (tsdPtr != NULL) {
 	register TimerHandler *timerHandlerPtr;
 
-	timerHandlerPtr = tsdPtr->firstTimerHandlerPtr;
-	while (timerHandlerPtr != NULL) {
-	    tsdPtr->firstTimerHandlerPtr = timerHandlerPtr->nextPtr;
+	while ((timerHandlerPtr = tsdPtr->timerList) != NULL) {
+	    tsdPtr->timerList = timerHandlerPtr->nextPtr;
 	    ckfree((char *) timerHandlerPtr);
-	    timerHandlerPtr = tsdPtr->firstTimerHandlerPtr;
 	}
+	tsdPtr->lastTimerPtr = NULL;
     }
 }
 
@@ -239,6 +222,7 @@ Tcl_CreateTimerHandler(
     Tcl_TimerProc *proc,	/* Function to invoke. */
     ClientData clientData)	/* Arbitrary data to pass to proc. */
 {
+    register TimerHandler *timerHandlerPtr;
     Tcl_Time time;
 
     /*
@@ -252,20 +236,27 @@ Tcl_CreateTimerHandler(
 	time.usec -= 1000000;
 	time.sec += 1;
     }
-    return TclCreateAbsoluteTimerHandler(&time, proc, clientData);
+
+    timerHandlerPtr = TclCreateAbsoluteTimerHandlerEx(&time, proc, NULL, 0);
+    if (timerHandlerPtr == NULL) {
+    	return NULL;
+    }
+    timerHandlerPtr->clientData = clientData;
+
+    return timerHandlerPtr->token;
 }
 
 /*
  *--------------------------------------------------------------
  *
- * TclCreateAbsoluteTimerHandler --
+ * TclCreateAbsoluteTimerHandlerEx -- , TclCreateAbsoluteTimerHandler --
  *
  *	Arrange for a given function to be invoked at a particular time in the
  *	future.
  *
  * Results:
- *	The return value is a token for the timer event, which may be used to
- *	delete the event before it fires.
+ *	The return value is a handler or token of the timer event, which may
+ *	be used to delete the event before it fires.
  *
  * Side effects:
  *	When the time in timePtr has been reached, proc will be invoked
@@ -274,17 +265,21 @@ Tcl_CreateTimerHandler(
  *--------------------------------------------------------------
  */
 
-Tcl_TimerToken
-TclCreateAbsoluteTimerHandler(
-    Tcl_Time *timePtr,
-    Tcl_TimerProc *proc,
-    ClientData clientData)
+TimerHandler*
+TclCreateAbsoluteTimerHandlerEx(
+    Tcl_Time *timePtr,			/* Time to be invoked */
+    Tcl_TimerProc *proc,		/* Function to invoke */
+    Tcl_TimerDeleteProc *deleteProc,	/* Function to cleanup */
+    size_t extraDataSize)
 {
-    register TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr;
+    register TimerHandler *timerHandlerPtr, *thPtrPos;
     ThreadSpecificData *tsdPtr;
 
     tsdPtr = InitTimer();
-    timerHandlerPtr = (TimerHandler *) ckalloc(sizeof(TimerHandler));
+    timerHandlerPtr = (TimerHandler *) ckalloc(sizeof(TimerHandler) + extraDataSize);
+    if (timerHandlerPtr == NULL) {
+	return NULL;
+    }
 
     /*
      * Fill in fields for the event.
@@ -292,7 +287,10 @@ TclCreateAbsoluteTimerHandler(
 
     memcpy((void *)&timerHandlerPtr->time, (void *)timePtr, sizeof(Tcl_Time));
     timerHandlerPtr->proc = proc;
-    timerHandlerPtr->clientData = clientData;
+    timerHandlerPtr->deleteProc = deleteProc;
+    timerHandlerPtr->clientData = TimerHandler2ClientData(timerHandlerPtr);
+    timerHandlerPtr->generation = tsdPtr->timerGeneration;
+    tsdPtr->timerListEpoch++; /* signal-timer list was changed */
     tsdPtr->lastTimerId++;
     timerHandlerPtr->token = (Tcl_TimerToken) INT2PTR(tsdPtr->lastTimerId);
 
@@ -301,21 +299,57 @@ TclCreateAbsoluteTimerHandler(
      * (ordered by event firing time).
      */
 
-    for (tPtr2 = tsdPtr->firstTimerHandlerPtr, prevPtr = NULL; tPtr2 != NULL;
-	    prevPtr = tPtr2, tPtr2 = tPtr2->nextPtr) {
-	if (TCL_TIME_BEFORE(timerHandlerPtr->time, tPtr2->time)) {
-	    break;
-	}
-    }
-    timerHandlerPtr->nextPtr = tPtr2;
-    if (prevPtr == NULL) {
-	tsdPtr->firstTimerHandlerPtr = timerHandlerPtr;
+    /* if before current first (e. g. "after 0" before first "after 1000") */
+    if ( !(thPtrPos = tsdPtr->timerList)
+      || TCL_TIME_BEFORE(timerHandlerPtr->time, thPtrPos->time)
+    ) {
+    	/* splice to the head */
+	TclSpliceInEx(timerHandlerPtr, 
+		tsdPtr->timerList, tsdPtr->lastTimerPtr);
     } else {
-	prevPtr->nextPtr = timerHandlerPtr;
+    	/* search from end as long as one with time before not found */
+	for (thPtrPos = tsdPtr->lastTimerPtr; thPtrPos != NULL;
+	    thPtrPos = thPtrPos->prevPtr) {
+	    if (TCL_TIME_BEFORE(thPtrPos->time, timerHandlerPtr->time)) {
+		break;
+	    }
+	}
+	/* normally it should be always true, because checked above, but ... */
+	if (thPtrPos != NULL) {
+	    /* insert after found element (with time before new) */
+	    timerHandlerPtr->prevPtr = thPtrPos;
+	    if ((timerHandlerPtr->nextPtr = thPtrPos->nextPtr)) {
+		thPtrPos->nextPtr->prevPtr = timerHandlerPtr;
+	    } else {
+		tsdPtr->lastTimerPtr = timerHandlerPtr;
+	    }
+	    thPtrPos->nextPtr = timerHandlerPtr;
+	} else {
+	    /* unexpected case, but ... splice to the head */
+	    TclSpliceInEx(timerHandlerPtr, 
+		tsdPtr->timerList, tsdPtr->lastTimerPtr);
+	}
     }
 
     TimerSetupProc(NULL, TCL_ALL_EVENTS);
 
+    return timerHandlerPtr;
+}
+
+Tcl_TimerToken
+TclCreateAbsoluteTimerHandler(
+    Tcl_Time *timePtr,
+    Tcl_TimerProc *proc,
+    ClientData clientData)
+{
+    register TimerHandler *timerHandlerPtr;
+
+    timerHandlerPtr = TclCreateAbsoluteTimerHandlerEx(timePtr, proc, NULL, 0);
+    if (timerHandlerPtr == NULL) {
+    	return NULL;
+    }
+    timerHandlerPtr->clientData = clientData;
+
     return timerHandlerPtr->token;
 }
 
@@ -340,30 +374,51 @@ TclCreateAbsoluteTimerHandler(
 void
 Tcl_DeleteTimerHandler(
     Tcl_TimerToken token)	/* Result previously returned by
-				 * Tcl_DeleteTimerHandler. */
+				 * Tcl_CreateTimerHandler. */
 {
-    register TimerHandler *timerHandlerPtr, *prevPtr;
+    register TimerHandler *timerHandlerPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     if (token == NULL) {
 	return;
     }
 
-    for (timerHandlerPtr = tsdPtr->firstTimerHandlerPtr, prevPtr = NULL;
-	    timerHandlerPtr != NULL; prevPtr = timerHandlerPtr,
-	    timerHandlerPtr = timerHandlerPtr->nextPtr) {
+    for (timerHandlerPtr = tsdPtr->lastTimerPtr;
+	timerHandlerPtr != NULL;
+	timerHandlerPtr = timerHandlerPtr->prevPtr
+    ) {
 	if (timerHandlerPtr->token != token) {
 	    continue;
 	}
-	if (prevPtr == NULL) {
-	    tsdPtr->firstTimerHandlerPtr = timerHandlerPtr->nextPtr;
-	} else {
-	    prevPtr->nextPtr = timerHandlerPtr->nextPtr;
-	}
-	ckfree((char *) timerHandlerPtr);
+
+	TclDeleteTimerHandler(timerHandlerPtr);
 	return;
     }
 }
+
+void
+TclDeleteTimerHandler(
+    TimerHandler *timerHandlerPtr)	/* Result previously returned by */
+					/* TclCreateAbsoluteTimerHandlerEx. */
+{
+    ThreadSpecificData *tsdPtr;
+
+    if (timerHandlerPtr == NULL) {
+	return;
+    }
+
+    tsdPtr = InitTimer();
+
+    tsdPtr->timerListEpoch++; /* signal-timer list was changed */
+    TclSpliceOutEx(timerHandlerPtr, tsdPtr->timerList, tsdPtr->lastTimerPtr);
+
+    /* free it via deleteProc or ckfree */
+    if (timerHandlerPtr->deleteProc) {
+	(*timerHandlerPtr->deleteProc)(timerHandlerPtr->clientData);
+    }
+
+    ckfree((char *)timerHandlerPtr);
+}
 
 /*
  *----------------------------------------------------------------------
@@ -400,14 +455,14 @@ TimerSetupProc(
 	blockTime.sec = 0;
 	blockTime.usec = 0;
 
-    } else if ((flags & TCL_TIMER_EVENTS) && tsdPtr->firstTimerHandlerPtr) {
+    } else if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerList) {
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
 
 	Tcl_GetTime(&blockTime);
-	blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - blockTime.sec;
-	blockTime.usec = tsdPtr->firstTimerHandlerPtr->time.usec -
+	blockTime.sec = tsdPtr->timerList->time.sec - blockTime.sec;
+	blockTime.usec = tsdPtr->timerList->time.usec -
 		blockTime.usec;
 	if (blockTime.usec < 0) {
 	    blockTime.sec -= 1;
@@ -451,14 +506,14 @@ TimerCheckProc(
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->firstTimerHandlerPtr) {
+    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerList) {
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
 
 	Tcl_GetTime(&blockTime);
-	blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - blockTime.sec;
-	blockTime.usec = tsdPtr->firstTimerHandlerPtr->time.usec -
+	blockTime.sec = tsdPtr->timerList->time.sec - blockTime.sec;
+	blockTime.usec = tsdPtr->timerList->time.usec -
 		blockTime.usec;
 	if (blockTime.usec < 0) {
 	    blockTime.sec -= 1;
@@ -510,9 +565,9 @@ TimerHandlerEventProc(
     int flags)			/* Flags that indicate what events to handle,
 				 * such as TCL_FILE_EVENTS. */
 {
-    TimerHandler *timerHandlerPtr, **nextPtrPtr;
+    TimerHandler *timerHandlerPtr, *nextPtr;
     Tcl_Time time;
-    int currentTimerId;
+    size_t currentGeneration, currentEpoch;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     /*
@@ -531,9 +586,7 @@ TimerHandlerEventProc(
      * 1. New handlers can get added to the list while the current one is
      *	  being processed. If new ones get added, we don't want to process
      *	  them during this pass through the list to avoid starving other event
-     *	  sources. This is implemented using the token number in the handler:
-     *	  new handlers will have a newer token than any of the ones currently
-     *	  on the list.
+     *	  sources. This is implemented using check of the generation epoch.
      * 2. The handler can call Tcl_DoOneEvent, so we have to remove the
      *	  handler from the list before calling it. Otherwise an infinite loop
      *	  could result.
@@ -551,36 +604,60 @@ TimerHandlerEventProc(
      */
 
     tsdPtr->timerPending = 0;
-    currentTimerId = tsdPtr->lastTimerId;
+    currentGeneration = tsdPtr->timerGeneration++;
     Tcl_GetTime(&time);
-    while (1) {
-	nextPtrPtr = &tsdPtr->firstTimerHandlerPtr;
-	timerHandlerPtr = tsdPtr->firstTimerHandlerPtr;
-	if (timerHandlerPtr == NULL) {
-	    break;
-	}
+    for (timerHandlerPtr = tsdPtr->timerList; 
+	 timerHandlerPtr != NULL;
+	 timerHandlerPtr = nextPtr
+    ) {
+    	nextPtr = timerHandlerPtr->nextPtr;
 
 	if (TCL_TIME_BEFORE(time, timerHandlerPtr->time)) {
 	    break;
 	}
 
 	/*
-	 * Bail out if the next timer is of a newer generation.
+	 * Bypass timers of newer generation.
 	 */
 
-	if ((currentTimerId - PTR2INT(timerHandlerPtr->token)) < 0) {
-	    break;
+	if (timerHandlerPtr->generation > currentGeneration) {
+	    continue;
 	}
 
+	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
+	 
 	/*
 	 * Remove the handler from the queue before invoking it, to avoid
 	 * potential reentrancy problems.
 	 */
 
-	(*nextPtrPtr) = timerHandlerPtr->nextPtr;
+	TclSpliceOutEx(timerHandlerPtr, 
+	    tsdPtr->timerList, tsdPtr->lastTimerPtr);
+
+	currentEpoch = tsdPtr->timerListEpoch;
+
+	/* invoke timer proc */
 	(*timerHandlerPtr->proc)(timerHandlerPtr->clientData);
+	/* free it via deleteProc or ckfree */
+	if (timerHandlerPtr->deleteProc) {
+	    (*timerHandlerPtr->deleteProc)(timerHandlerPtr->clientData);
+	}
+
 	ckfree((char *) timerHandlerPtr);
+
+	/* be sure that timer-list was not changed inside the proc call */
+	if (currentEpoch != tsdPtr->timerListEpoch) {
+	    /* timer-list was changed - stop processing */
+	    break;
+	}
     }
+
+    /* Reset generation */
+    if (!tsdPtr->timerList) {
+    	tsdPtr->timerGeneration = 0;
+    }
+
+    /* Compute the next timeout (first timer on the list). */
     TimerSetupProc(NULL, TCL_TIMER_EVENTS);
     return 1;
 }
@@ -588,7 +665,7 @@ TimerHandlerEventProc(
 /*
  *--------------------------------------------------------------
  *
- * Tcl_DoWhenIdle --
+ * TclCreateIdleHandlerEx --, Tcl_DoWhenIdle --
  *
  *	Arrange for proc to be invoked the next time the system is idle (i.e.,
  *	just before the next time that Tcl_DoOneEvent would have to wait for
@@ -604,30 +681,85 @@ TimerHandlerEventProc(
  *--------------------------------------------------------------
  */
 
-void
-Tcl_DoWhenIdle(
-    Tcl_IdleProc *proc,		/* Function to invoke. */
-    ClientData clientData)	/* Arbitrary value to pass to proc. */
+IdleHandler *
+TclCreateIdleHandlerEx(
+    Tcl_IdleProc *proc,			/* Function to invoke. */
+    Tcl_IdleDeleteProc *deleteProc,	/* Function to cleanup */
+    size_t extraDataSize)
 {
     register IdleHandler *idlePtr;
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    idlePtr = (IdleHandler *) ckalloc(sizeof(IdleHandler));
+    idlePtr = (IdleHandler *) ckalloc(sizeof(IdleHandler) + extraDataSize);
+    if (idlePtr == NULL) {
+	return NULL;
+    }
     idlePtr->proc = proc;
-    idlePtr->clientData = clientData;
+    idlePtr->deleteProc = deleteProc;
+    idlePtr->clientData = IdleHandler2ClientData(idlePtr);
     idlePtr->generation = tsdPtr->idleGeneration;
-    idlePtr->nextPtr = NULL;
-    if (tsdPtr->lastIdlePtr == NULL) {
-	tsdPtr->idleList = idlePtr;
-    } else {
-	tsdPtr->lastIdlePtr->nextPtr = idlePtr;
-    }
-    tsdPtr->lastIdlePtr = idlePtr;
 
+    /* attach to the idle queue */
+    TclSpliceTailEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+
+    /* reset next block time */
     blockTime.sec = 0;
     blockTime.usec = 0;
     Tcl_SetMaxBlockTime(&blockTime);
+
+    return idlePtr;
+}
+
+void
+Tcl_DoWhenIdle(
+    Tcl_IdleProc *proc,		/* Function to invoke. */
+    ClientData clientData)	/* Arbitrary value to pass to proc. */
+{
+    register IdleHandler *idlePtr = TclCreateIdleHandlerEx(proc, NULL, 0);
+
+    if (idlePtr) {
+    	idlePtr->clientData = clientData;
+    }
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TclDeleteIdleHandler --
+ *
+ *	Delete a previously-registered idle handler.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *--------------------------------------------------------------
+ */
+
+void
+TclDeleteIdleHandler(
+    IdleHandler *idlePtr)	/* Result previously returned by */
+				/* TclCreateIdleHandlerEx */
+{
+    ThreadSpecificData *tsdPtr;
+
+    if (idlePtr == NULL) {
+	return;
+    }
+
+    tsdPtr = InitTimer();
+
+    /* detach entry from the owner list */
+    TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+
+    /* free it via deleteProc and ckfree */
+    if (idlePtr->deleteProc) {
+	(*idlePtr->deleteProc)(idlePtr->clientData);
+    }
+    ckfree((char *)idlePtr);
 }
 
 /*
@@ -653,26 +785,24 @@ Tcl_CancelIdleCall(
     Tcl_IdleProc *proc,		/* Function that was previously registered. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    register IdleHandler *idlePtr, *prevPtr;
-    IdleHandler *nextPtr;
+    register IdleHandler *idlePtr, *nextPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    for (prevPtr = NULL, idlePtr = tsdPtr->idleList; idlePtr != NULL;
-	    prevPtr = idlePtr, idlePtr = idlePtr->nextPtr) {
-	while ((idlePtr->proc == proc)
+    for (idlePtr = tsdPtr->idleList;
+    	idlePtr != NULL;
+	idlePtr = nextPtr
+    ) {
+    	nextPtr = idlePtr->nextPtr;
+	if ((idlePtr->proc == proc)
 		&& (idlePtr->clientData == clientData)) {
-	    nextPtr = idlePtr->nextPtr;
-	    ckfree((char *) idlePtr);
-	    idlePtr = nextPtr;
-	    if (prevPtr == NULL) {
-		tsdPtr->idleList = idlePtr;
-	    } else {
-		prevPtr->nextPtr = idlePtr;
-	    }
-	    if (idlePtr == NULL) {
-		tsdPtr->lastIdlePtr = prevPtr;
-		return;
+	    /* detach entry from the owner list */
+	    TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+
+	    /* free it via deleteProc and ckfree */
+	    if (idlePtr->deleteProc) {
+		(*idlePtr->deleteProc)(idlePtr->clientData);
 	    }
+	    ckfree((char *) idlePtr);
 	}
     }
 }
@@ -700,7 +830,7 @@ int
 TclServiceIdle(void)
 {
     IdleHandler *idlePtr;
-    int oldGeneration;
+    size_t currentGeneration;
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
@@ -708,8 +838,7 @@ TclServiceIdle(void)
 	return 0;
     }
 
-    oldGeneration = tsdPtr->idleGeneration;
-    tsdPtr->idleGeneration++;
+    currentGeneration = tsdPtr->idleGeneration++;
 
     /*
      * The code below is trickier than it may look, for the following reasons:
@@ -728,15 +857,19 @@ TclServiceIdle(void)
      *	  during the call.
      */
 
-    for (idlePtr = tsdPtr->idleList;
-	    ((idlePtr != NULL)
-		    && ((oldGeneration - idlePtr->generation) >= 0));
-	    idlePtr = tsdPtr->idleList) {
-	tsdPtr->idleList = idlePtr->nextPtr;
-	if (tsdPtr->idleList == NULL) {
-	    tsdPtr->lastIdlePtr = NULL;
-	}
+    while ((idlePtr = tsdPtr->idleList) != NULL
+	&& idlePtr->generation <= currentGeneration
+    ) {
+	/* detach entry from the owner's list */
+	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+
+	/* execute event */
 	(*idlePtr->proc)(idlePtr->clientData);
+
+	/* free it via deleteProc and ckfree */
+	if (idlePtr->deleteProc) {
+	    (*idlePtr->deleteProc)(idlePtr->clientData);
+	}
 	ckfree((char *) idlePtr);
     }
     if (tsdPtr->idleList) {
@@ -744,6 +877,10 @@ TclServiceIdle(void)
 	blockTime.usec = 0;
 	Tcl_SetMaxBlockTime(&blockTime);
     }
+    /* Reset generation */
+    if (!tsdPtr->idleList) {
+    	tsdPtr->idleGeneration = 0;
+    }
     return 1;
 }
 
@@ -833,14 +970,35 @@ Tcl_AfterObjCmd(
 
     switch (index) {
     case -1: {
+    	TimerHandler *timerPtr;
 	if (ms < 0) {
 	    ms = 0;
 	}
 	if (objc == 2) {
 	    return AfterDelay(interp, ms);
 	}
-	afterPtr = (AfterInfo *) ckalloc((unsigned) (sizeof(AfterInfo)));
+
+	Tcl_GetTime(&wakeup);
+	wakeup.sec += (long)(ms / 1000);
+	wakeup.usec += ((long)(ms % 1000)) * 1000;
+	if (wakeup.usec > 1000000) {
+	    wakeup.sec++;
+	    wakeup.usec -= 1000000;
+	}
+
+	timerPtr = TclCreateAbsoluteTimerHandlerEx(&wakeup, AfterProc,
+			FreeAfterPtr, sizeof(AfterInfo));
+	if (timerPtr == NULL) { /* error handled in panic */
+	    return TCL_ERROR;
+	}
+	afterPtr = TimerHandler2AfterInfo(timerPtr);
+
+	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
+	TclSpliceTailEx(afterPtr, 
+		assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
+	afterPtr->flags = 0;
+
 	if (objc == 3) {
 	    afterPtr->commandPtr = objv[2];
 	} else {
@@ -858,19 +1016,7 @@ Tcl_AfterObjCmd(
 	 * around when wrap-around occurs.
 	 */
 
-	afterPtr->id = tsdPtr->afterId;
-	tsdPtr->afterId += 1;
-	Tcl_GetTime(&wakeup);
-	wakeup.sec += (long)(ms / 1000);
-	wakeup.usec += ((long)(ms % 1000)) * 1000;
-	if (wakeup.usec > 1000000) {
-	    wakeup.sec++;
-	    wakeup.usec -= 1000000;
-	}
-	afterPtr->token = TclCreateAbsoluteTimerHandler(&wakeup, AfterProc,
-							(ClientData) afterPtr);
-	/* attach to the list */
-	TclSpliceTailEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
+	afterPtr->id = tsdPtr->afterId++;
 
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
 	return TCL_OK;
@@ -907,37 +1053,48 @@ Tcl_AfterObjCmd(
 	    Tcl_DecrRefCount(commandPtr);
 	}
 	if (afterPtr != NULL) {
-	    if (afterPtr->token != NULL) {
-		Tcl_DeleteTimerHandler(afterPtr->token);
+	    if (!(afterPtr->flags & IDLE_EVENT)) {
+		TclDeleteTimerHandler(AfterInfo2TimerHandler(afterPtr));
 	    } else {
-		Tcl_CancelIdleCall(AfterProc, (ClientData) afterPtr);
+		TclDeleteIdleHandler(AfterInfo2IdleHandler(afterPtr));
 	    }
-	    FreeAfterPtr(afterPtr);
 	}
 	break;
     }
-    case AFTER_IDLE:
+    case AFTER_IDLE: {
+    	IdleHandler *idlePtr;
+
 	if (objc < 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "script script ...");
 	    return TCL_ERROR;
 	}
-	afterPtr = (AfterInfo *) ckalloc((unsigned) (sizeof(AfterInfo)));
+
+	idlePtr = TclCreateIdleHandlerEx(AfterProc,
+			FreeAfterPtr, sizeof(AfterInfo));
+	if (idlePtr == NULL) { /* error handled in panic */
+	    return TCL_ERROR;
+	}
+	afterPtr = IdleHandler2AfterInfo(idlePtr);
+
+	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
+	TclSpliceTailEx(afterPtr, 
+		assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
+	afterPtr->flags = IDLE_EVENT;
+
 	if (objc == 3) {
 	    afterPtr->commandPtr = objv[2];
 	} else {
 	    afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
 	}
 	Tcl_IncrRefCount(afterPtr->commandPtr);
-	afterPtr->id = tsdPtr->afterId;
-	tsdPtr->afterId += 1;
-	afterPtr->token = NULL;
-	/* attach to the list */
-	TclSpliceTailEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
-
-	Tcl_DoWhenIdle(AfterProc, (ClientData) afterPtr);
+	
+	afterPtr->id = tsdPtr->afterId++;
+	
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
-	break;
+
+	return TCL_OK;
+    };
     case AFTER_INFO: {
 	Tcl_Obj *resultListPtr;
 
@@ -964,7 +1121,7 @@ Tcl_AfterObjCmd(
 	resultListPtr = Tcl_NewObj();
 	Tcl_ListObjAppendElement(interp, resultListPtr, afterPtr->commandPtr);
 	Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
- 		(afterPtr->token == NULL) ? "idle" : "timer", -1));
+ 		(afterPtr->flags & IDLE_EVENT) ? "idle" : "timer", -1));
 	Tcl_SetObjResult(interp, resultListPtr);
 	break;
     }
@@ -1131,6 +1288,14 @@ AfterProc(
      * a core dump.
      */
 
+
+    /* remove delete proc from handler (we'll do cleanup here) */
+    if (!(afterPtr->flags & IDLE_EVENT)) {
+	AfterInfo2TimerHandler(afterPtr)->deleteProc = NULL;
+    } else {
+	AfterInfo2IdleHandler(afterPtr)->deleteProc = NULL;
+    }
+
     /* detach entry from the owner's list */
     TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 
@@ -1152,7 +1317,7 @@ AfterProc(
      */
 
     Tcl_DecrRefCount(afterPtr->commandPtr);
-    ckfree((char *) afterPtr);
+
 }
 
 /*
@@ -1168,23 +1333,23 @@ AfterProc(
  *	None.
  *
  * Side effects:
- *	The memory associated with afterPtr is released.
+ *	The memory associated with afterPtr is not released (owned by handler).
  *
  *----------------------------------------------------------------------
  */
 
 static void
 FreeAfterPtr(
-    AfterInfo *afterPtr)		/* Command to be deleted. */
+    ClientData clientData)		/* Command to be deleted. */
 {
+    AfterInfo *afterPtr = (AfterInfo *) clientData;
     AfterAssocData *assocPtr = afterPtr->assocPtr;
 
     /* detach entry from the owner's list */
     TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 
-    /* free command and entry */
+    /* free command of entry */
     Tcl_DecrRefCount(afterPtr->commandPtr);
-    ckfree((char *) afterPtr);
 }
 
 /*
@@ -1215,18 +1380,12 @@ AfterCleanupProc(
     AfterInfo *afterPtr;
 
     while ( (afterPtr = assocPtr->lastAfterPtr) ) {
-	/* detach entry from the owner's list */
-	TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
-
-	if (afterPtr->token != NULL) {
-	    Tcl_DeleteTimerHandler(afterPtr->token);
+	if (!(afterPtr->flags & IDLE_EVENT)) {
+	    TclDeleteTimerHandler(AfterInfo2TimerHandler(afterPtr));
 	} else {
-	    Tcl_CancelIdleCall(AfterProc, (ClientData) afterPtr);
+	    TclDeleteIdleHandler(AfterInfo2IdleHandler(afterPtr));
 	}
-	Tcl_DecrRefCount(afterPtr->commandPtr);
-	ckfree((char *) afterPtr);
     }
-    ckfree((char *) assocPtr);
 }
 
 /*
-- 
cgit v0.12


From a66afb09682a193da54b17a65482242d1e7a23ff Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:21:57 +0000
Subject: rewrite interpreter limit handling using new timer event handling
 (with delete callback)

---
 generic/tclInt.h    | 91 ++++++++++++++++++++++++++---------------------------
 generic/tclInterp.c | 18 ++++++++---
 2 files changed, 59 insertions(+), 50 deletions(-)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index 99f9346..021ba00 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -128,6 +128,50 @@ typedef int ptrdiff_t;
 #endif
 
 /*
+ *----------------------------------------------------------------
+ * Data structures related to timer / idle events.
+ *----------------------------------------------------------------
+ */
+
+/*
+ * For each timer callback that's pending there is one record of the following
+ * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
+ * together in a list sorted by time (earliest event first).
+ */
+
+				 
+typedef struct TimerHandler {
+    Tcl_TimerProc	*proc;	/* Function to call timer event */
+    Tcl_TimerDeleteProc *deleteProc; /* Function to cleanup timer event */
+    ClientData clientData;	/* Argument to pass to proc and deleteProc */
+    size_t generation;		/* Used to distinguish older handlers from
+				 * recently-created ones. */
+    Tcl_TimerToken token;	/* Identifies handler so it can be deleted. */
+    struct TimerHandler *nextPtr; /* Next and prev event in timer/idle queue, */
+    struct TimerHandler *prevPtr; /* or NULL for end/start of the queue. */
+    Tcl_Time	time;		/* When timer is to fire (if timer event). */
+/*  ExtraData	 */
+} TimerHandler;
+
+/*
+ * There is one of the following structures for each of the handlers declared
+ * in a call to Tcl_DoWhenIdle. All of the currently-active handlers are
+ * linked together into a list.
+ */
+
+typedef struct IdleHandler {
+    Tcl_IdleProc	*proc;	/* Function to call idle event */
+    Tcl_IdleDeleteProc  *deleteProc; /* Function to cleanup idle event */
+    ClientData clientData;	/* Argument to pass to proc and deleteProc */
+    size_t generation;		/* Used to distinguish older handlers from
+				 * recently-created ones. */
+    struct IdleHandler *nextPtr;/* Next and prev event in idle queue, */
+    struct IdleHandler *prevPtr;/* or NULL for end/start of the queue. */
+/*  ExtraData	 */
+} IdleHandler;
+
+
+/*
  * The following procedures allow namespaces to be customized to support
  * special name resolution rules for commands/variables.
  */
@@ -1797,7 +1841,7 @@ typedef struct Interp {
 				 * reached. */
 	int timeGranularity;	/* Mod factor used to determine how often to
 				 * evaluate the limit check. */
-	Tcl_TimerToken timeEvent;
+	TimerHandler *timeEvent;
 				/* Handle for a timer callback that will occur
 				 * when the time-limit is exceeded. */
 
@@ -2500,51 +2544,6 @@ MODULE_SCOPE char	tclEmptyString;
 				/* 'Shortest possible' after masking */
 
 
-
-/*
- *----------------------------------------------------------------
- * Data structures related to timer / idle events.
- *----------------------------------------------------------------
- */
-
-/*
- * For each timer callback that's pending there is one record of the following
- * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
- * together in a list sorted by time (earliest event first).
- */
-
-				 
-typedef struct TimerHandler {
-    Tcl_TimerProc	*proc;	/* Function to call timer event */
-    Tcl_TimerDeleteProc *deleteProc; /* Function to cleanup timer event */
-    ClientData clientData;	/* Argument to pass to proc and deleteProc */
-    size_t generation;		/* Used to distinguish older handlers from
-				 * recently-created ones. */
-    Tcl_TimerToken token;	/* Identifies handler so it can be deleted. */
-    struct TimerHandler *nextPtr; /* Next and prev event in timer/idle queue, */
-    struct TimerHandler *prevPtr; /* or NULL for end/start of the queue. */
-    Tcl_Time	time;		/* When timer is to fire (if timer event). */
-/*  ExtraData	 */
-} TimerHandler;
-
-/*
- * There is one of the following structures for each of the handlers declared
- * in a call to Tcl_DoWhenIdle. All of the currently-active handlers are
- * linked together into a list.
- */
-
-typedef struct IdleHandler {
-    Tcl_IdleProc	*proc;	/* Function to call idle event */
-    Tcl_IdleDeleteProc  *deleteProc; /* Function to cleanup idle event */
-    ClientData clientData;	/* Argument to pass to proc and deleteProc */
-    size_t generation;		/* Used to distinguish older handlers from
-				 * recently-created ones. */
-    struct IdleHandler *nextPtr;/* Next and prev event in idle queue, */
-    struct IdleHandler *prevPtr;/* or NULL for end/start of the queue. */
-/*  ExtraData	 */
-} IdleHandler;
-
-
 /*
  * Macros to wrap ExtraData and TimerHandler resp. IdleHandler (and vice versa)
  */
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index dbbf10a..cab58bd 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -3511,7 +3511,7 @@ TclLimitRemoveAllHandlers(
      */
 
     if (iPtr->limit.timeEvent != NULL) {
-	Tcl_DeleteTimerHandler(iPtr->limit.timeEvent);
+	TclDeleteTimerHandler(iPtr->limit.timeEvent);
 	iPtr->limit.timeEvent = NULL;
     }
 }
@@ -3681,6 +3681,15 @@ Tcl_LimitGetCommands(
 
     return iPtr->limit.cmdCount;
 }
+
+static void
+TimeLimitDeleteCallback(
+    ClientData clientData)
+{
+    Interp *iPtr = clientData;
+
+    iPtr->limit.timeEvent = NULL;
+}
 
 /*
  *----------------------------------------------------------------------
@@ -3711,7 +3720,7 @@ Tcl_LimitSetTime(
 
     memcpy(&iPtr->limit.time, timeLimitPtr, sizeof(Tcl_Time));
     if (iPtr->limit.timeEvent != NULL) {
-	Tcl_DeleteTimerHandler(iPtr->limit.timeEvent);
+	TclDeleteTimerHandler(iPtr->limit.timeEvent);
     }
     nextMoment.sec = timeLimitPtr->sec;
     nextMoment.usec = timeLimitPtr->usec+10;
@@ -3719,8 +3728,9 @@ Tcl_LimitSetTime(
 	nextMoment.sec++;
 	nextMoment.usec -= 1000000;
     }
-    iPtr->limit.timeEvent = TclCreateAbsoluteTimerHandler(&nextMoment,
-	    TimeLimitCallback, interp);
+    iPtr->limit.timeEvent = TclCreateAbsoluteTimerHandlerEx(&nextMoment,
+	    TimeLimitCallback, TimeLimitDeleteCallback, 0);
+    iPtr->limit.timeEvent->clientData = interp;
     iPtr->limit.exceeded &= ~TCL_LIMIT_TIME;
 }
 
-- 
cgit v0.12


From c2e3847bb8d6327328f95266f169d2d3d49b1861 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:22:04 +0000
Subject: after-id: introduced object of type "afterObjType" as self-referenced
 weak pointer to timer/idle event, used for fast access to the "after" event
 (cancel, info etc.); test cases extended to cover it additionally

---
 generic/tclTimer.c | 203 +++++++++++++++++++++++++++++++++++++++++++++--------
 tests/event.test   |  53 ++++++++++++++
 2 files changed, 227 insertions(+), 29 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 40316ca..68c1865 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -26,6 +26,7 @@ typedef struct AfterInfo {
 				 * interp in which command will be
 				 * executed. */
     Tcl_Obj *commandPtr;	/* Command to execute. */
+    Tcl_Obj *selfPtr;		/* Points to the handle object (self) */
     size_t id;			/* Integer identifier for command */
     int			flags;	/* Flags (IDLE_EVENT) */
     struct AfterInfo *nextPtr;	/* Next in list of all "after" commands for
@@ -123,15 +124,127 @@ static void		AfterCleanupProc(ClientData clientData,
 static int		AfterDelay(Tcl_Interp *interp, Tcl_WideInt ms);
 static void		AfterProc(ClientData clientData);
 static void		FreeAfterPtr(ClientData clientData);
-static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr,
-			    Tcl_Obj *commandPtr);
+static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr, Tcl_Obj *objPtr);
 static ThreadSpecificData *InitTimer(void);
 static void		TimerExitProc(ClientData clientData);
 static int		TimerHandlerEventProc(Tcl_Event *evPtr, int flags);
 static void		TimerCheckProc(ClientData clientData, int flags);
 static void		TimerSetupProc(ClientData clientData, int flags);
 
-/*
+static void             AfterObj_DupInternalRep(Tcl_Obj *, Tcl_Obj *);
+static void		AfterObj_FreeInternalRep(Tcl_Obj *);
+static void		AfterObj_UpdateString(Tcl_Obj *);
+
+
+
+/*
+ * Type definition.
+ */
+
+Tcl_ObjType afterObjType = {
+    "after",                    /* name */
+    AfterObj_FreeInternalRep,   /* freeIntRepProc */
+    AfterObj_DupInternalRep,    /* dupIntRepProc */
+    AfterObj_UpdateString,      /* updateStringProc */
+    NULL                        /* setFromAnyProc */
+};
+
+/*
+ *----------------------------------------------------------------------
+ */
+static void
+AfterObj_DupInternalRep(srcPtr, dupPtr)
+    Tcl_Obj *srcPtr;
+    Tcl_Obj *dupPtr;
+{
+    /* 
+     * Because we should have only a single reference to the after event,
+     * we'll copy string representation only.
+     */
+    if (dupPtr->bytes == NULL) {
+	if (srcPtr->bytes == NULL) {
+	    AfterObj_UpdateString(srcPtr);
+	}
+	if (srcPtr->bytes != tclEmptyStringRep) {
+	    TclInitStringRep(dupPtr, srcPtr->bytes, srcPtr->length);
+	} else {
+	    dupPtr->bytes = tclEmptyStringRep;
+	}
+    }
+}
+/*
+ *----------------------------------------------------------------------
+ */
+static void
+AfterObj_FreeInternalRep(objPtr)
+    Tcl_Obj *objPtr;
+{
+    /* 
+     * Because we should always have a reference by active after event,
+     * so it is a triggered / canceled event - just reset type and pointers
+     */
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
+    objPtr->internalRep.twoPtrValue.ptr2 = NULL;
+    objPtr->typePtr = NULL;
+
+    /* prevent no string representation bug */
+    if (objPtr->bytes == NULL) {
+	objPtr->length = 0;
+	objPtr->bytes = tclEmptyStringRep;
+    }
+}
+/*
+ *----------------------------------------------------------------------
+ */
+static void
+AfterObj_UpdateString(objPtr)
+    Tcl_Obj  *objPtr;
+{
+    char buf[16 + TCL_INTEGER_SPACE];
+    int len;
+ 
+    AfterInfo *afterPtr = (AfterInfo*)objPtr->internalRep.twoPtrValue.ptr1;
+
+    /* if already triggered / canceled - equivalent not found, we can use empty */
+    if (!afterPtr) {
+	objPtr->length = 0;
+	objPtr->bytes = tclEmptyStringRep;
+	return;
+    }
+
+    len = sprintf(buf, "after#%d", afterPtr->id);
+
+    objPtr->length = len;
+    objPtr->bytes = ckalloc((size_t)++len);
+    if (objPtr->bytes)
+	memcpy(objPtr->bytes, buf, len);
+
+}
+/*
+ *----------------------------------------------------------------------
+ */
+Tcl_Obj*
+GetAfterObj(
+    AfterInfo *afterPtr)
+{
+    Tcl_Obj * objPtr = afterPtr->selfPtr;
+    
+    if (objPtr != NULL) {
+	return objPtr;
+    }
+    
+    TclNewObj(objPtr);
+    objPtr->typePtr = &afterObjType;
+    objPtr->bytes = NULL;
+    objPtr->internalRep.twoPtrValue.ptr1 = afterPtr;
+    objPtr->internalRep.twoPtrValue.ptr2 = NULL;
+    Tcl_IncrRefCount(objPtr);
+    afterPtr->selfPtr = objPtr;
+
+    return objPtr;
+};
+
+/*
  *----------------------------------------------------------------------
  *
  * InitTimer --
@@ -915,7 +1028,6 @@ Tcl_AfterObjCmd(
     AfterAssocData *assocPtr;
     int length;
     int index;
-    char buf[16 + TCL_INTEGER_SPACE];
     static CONST char *afterSubCmds[] = {
 	"cancel", "idle", "info", NULL
     };
@@ -998,6 +1110,7 @@ Tcl_AfterObjCmd(
 	TclSpliceTailEx(afterPtr, 
 		assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 	afterPtr->flags = 0;
+	afterPtr->selfPtr = NULL;
 
 	if (objc == 3) {
 	    afterPtr->commandPtr = objv[2];
@@ -1018,7 +1131,7 @@ Tcl_AfterObjCmd(
 
 	afterPtr->id = tsdPtr->afterId++;
 
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
+	Tcl_SetObjResult(interp, GetAfterObj(afterPtr));
 	return TCL_OK;
     }
     case AFTER_CANCEL: {
@@ -1030,27 +1143,35 @@ Tcl_AfterObjCmd(
 	    Tcl_WrongNumArgs(interp, 2, objv, "id|command");
 	    return TCL_ERROR;
 	}
+
+	afterPtr = NULL;
 	if (objc == 3) {
 	    commandPtr = objv[2];
 	} else {
 	    commandPtr = Tcl_ConcatObj(objc-2, objv+2);;
 	}
-	command = Tcl_GetStringFromObj(commandPtr, &length);
-	for (afterPtr = assocPtr->lastAfterPtr;  afterPtr != NULL;
-		afterPtr = afterPtr->prevPtr) {
-	    tempCommand = Tcl_GetStringFromObj(afterPtr->commandPtr,
-		    &tempLength);
-	    if ((length == tempLength)
-		    && (memcmp((void*) command, (void*) tempCommand,
-			    (unsigned) length) == 0)) {
-		break;
+	if (commandPtr->typePtr == &afterObjType) {
+	    afterPtr = (AfterInfo*)commandPtr->internalRep.twoPtrValue.ptr1;
+	} else {
+	    command = Tcl_GetStringFromObj(commandPtr, &length);
+	    for (afterPtr = assocPtr->lastAfterPtr;
+		 afterPtr != NULL;
+		 afterPtr = afterPtr->prevPtr
+	    ) {
+		tempCommand = Tcl_GetStringFromObj(afterPtr->commandPtr,
+			&tempLength);
+		if ((length == tempLength)
+			&& (memcmp((void*) command, (void*) tempCommand,
+				(unsigned) length) == 0)) {
+		    break;
+		}
+	    }
+	    if (afterPtr == NULL) {
+		afterPtr = GetAfterEvent(assocPtr, commandPtr);
+	    }
+	    if (objc != 3) {
+		Tcl_DecrRefCount(commandPtr);
 	    }
-	}
-	if (afterPtr == NULL) {
-	    afterPtr = GetAfterEvent(assocPtr, commandPtr);
-	}
-	if (objc != 3) {
-	    Tcl_DecrRefCount(commandPtr);
 	}
 	if (afterPtr != NULL) {
 	    if (!(afterPtr->flags & IDLE_EVENT)) {
@@ -1081,6 +1202,7 @@ Tcl_AfterObjCmd(
 	TclSpliceTailEx(afterPtr, 
 		assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 	afterPtr->flags = IDLE_EVENT;
+	afterPtr->selfPtr = NULL;
 
 	if (objc == 3) {
 	    afterPtr->commandPtr = objv[2];
@@ -1091,7 +1213,7 @@ Tcl_AfterObjCmd(
 	
 	afterPtr->id = tsdPtr->afterId++;
 	
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
+	Tcl_SetObjResult(interp, GetAfterObj(afterPtr));
 
 	return TCL_OK;
     };
@@ -1099,19 +1221,27 @@ Tcl_AfterObjCmd(
 	Tcl_Obj *resultListPtr;
 
 	if (objc == 2) {
-	    for (afterPtr = assocPtr->lastAfterPtr; afterPtr != NULL;
-		    afterPtr = afterPtr->prevPtr) {
-		if (assocPtr->interp == interp) {
-		    sprintf(buf, "after#%d", afterPtr->id);
-		    Tcl_AppendElement(interp, buf);
+	    /* return list of all after-events */
+	    Tcl_Obj *listPtr = Tcl_NewListObj(0, NULL);
+	    for (afterPtr = assocPtr->lastAfterPtr;
+		 afterPtr != NULL;
+		 afterPtr = afterPtr->prevPtr
+	    ) {
+		if (assocPtr->interp != interp) {
+		    continue;
 		}
+		
+		Tcl_ListObjAppendElement(NULL, listPtr, GetAfterObj(afterPtr));
 	    }
+
+	    Tcl_SetObjResult(interp, listPtr);
 	    return TCL_OK;
 	}
 	if (objc != 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "?id?");
 	    return TCL_ERROR;
 	}
+
 	afterPtr = GetAfterEvent(assocPtr, objv[2]);
 	if (afterPtr == NULL) {
 	    Tcl_AppendResult(interp, "event \"", TclGetString(objv[2]),
@@ -1228,7 +1358,7 @@ static AfterInfo *
 GetAfterEvent(
     AfterAssocData *assocPtr,	/* Points to "after"-related information for
 				 * this interpreter. */
-    Tcl_Obj *commandPtr)
+    Tcl_Obj *objPtr)
 {
     char *cmdString;		/* Textual identifier for after event, such as
 				 * "after#6". */
@@ -1236,7 +1366,11 @@ GetAfterEvent(
     int id;
     char *end;
 
-    cmdString = TclGetString(commandPtr);
+    if (objPtr->typePtr == &afterObjType) {
+	return (AfterInfo*)objPtr->internalRep.twoPtrValue.ptr1;
+    }
+
+    cmdString = TclGetString(objPtr);
     if (strncmp(cmdString, "after#", 6) != 0) {
 	return NULL;
     }
@@ -1288,7 +1422,6 @@ AfterProc(
      * a core dump.
      */
 
-
     /* remove delete proc from handler (we'll do cleanup here) */
     if (!(afterPtr->flags & IDLE_EVENT)) {
 	AfterInfo2TimerHandler(afterPtr)->deleteProc = NULL;
@@ -1296,6 +1429,12 @@ AfterProc(
 	AfterInfo2IdleHandler(afterPtr)->deleteProc = NULL;
     }
 
+    /* release object (mark it was triggered) */
+    if (afterPtr->selfPtr && afterPtr->selfPtr->typePtr == &afterObjType) {
+	afterPtr->selfPtr->internalRep.twoPtrValue.ptr1 = NULL;
+	Tcl_DecrRefCount(afterPtr->selfPtr);
+    }
+
     /* detach entry from the owner's list */
     TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 
@@ -1345,6 +1484,12 @@ FreeAfterPtr(
     AfterInfo *afterPtr = (AfterInfo *) clientData;
     AfterAssocData *assocPtr = afterPtr->assocPtr;
 
+    /* release object (mark it was triggered) */
+    if (afterPtr->selfPtr && afterPtr->selfPtr->typePtr == &afterObjType) {
+	afterPtr->selfPtr->internalRep.twoPtrValue.ptr1 = NULL;
+	Tcl_DecrRefCount(afterPtr->selfPtr);
+    }
+
     /* detach entry from the owner's list */
     TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 
diff --git a/tests/event.test b/tests/event.test
index 4996b97..b6d4144 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -513,6 +513,59 @@ test event-11.4 {Tcl_VwaitCmd procedure} {} {
     list [vwait y] $x $y $z $q
 } {{} x-done y-done before q-done}
 
+test event-11.4.2 {cancel} {} {
+    foreach i [after info] {
+	after cancel $i
+    }
+    set x {}
+    # success cases:
+    after 10 {lappend x 1}
+    after 10 {lappend x 2}
+    after 10 {lappend x 3}
+    # cancel via object representation (4-6) and searching by id (7-9):
+    foreach i [list \
+	[after 0 {lappend x 4-unexpected}] \
+	[after 5 {lappend x 5-unexpected}] \
+	[after 10 {lappend x 6-unexpected}] \
+	[string trim " [after 0 {lappend x 7-unexpected}] "] \
+	[string trim " [after 5 {lappend x 8-unexpected}] "] \
+	[string trim " [after 10 {lappend x 9-unexpected}] "] \
+    ] {
+	after cancel $i
+    }
+    after 20 {set y done}
+    list [vwait y] $x $y
+} {{} {1 2 3} done}
+
+test event-11.4.3 {cancel twice and info} {} {
+    foreach i [after info] {
+	after cancel $i
+    }
+    set x {}
+    # success cases:
+    after 10 {lappend x 1}
+    after 10 {lappend x 2}
+    after 10 {lappend x 3}
+    # cancel via object representation (4-6) and searching by id (7-9):
+    foreach i [list \
+	[after 0 {lappend x 4-unexpected}] \
+	[after 5 {lappend x 5-unexpected}] \
+	[after 10 {lappend x 6-unexpected}] \
+	[string trim " [after 0 {lappend x 7-unexpected}] "] \
+	[string trim " [after 5 {lappend x 8-unexpected}] "] \
+	[string trim " [after 10 {lappend x 9-unexpected}] "] \
+    ] {
+	after cancel $i
+	# just to test possible segfault:
+	after cancel $i
+	if {![catch {after info $i} i]} {; # unexpected (event doesn't exist)
+	    error "\"after info\" returns \"$i\" - should be an error"
+	}
+    }
+    after 20 {set y done}
+    list [vwait y] $x $y
+} {{} {1 2 3} done}
+
 foreach i [after info] {
     after cancel $i
 }
-- 
cgit v0.12


From 420147bdad4cfcba7f38fb2497d6a1848c22d162 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:23:20 +0000
Subject: [bug/stable fix] don't execute TimerSetupProc directly (may be
 unwanted, because changes the blocking time, also if
 TCL_TIMER_EVENTS|TCL_IDLE_EVENTS not set), so let do that within
 Tcl_DoOneEvent cycle only (we have registered an event source). [performance]
 optimization for "after 0" as immediately execution without time (invoke as
 soon as possible) - generation and invocation of such timers twice faster
 now. [performance] leave handler-event in the queue as long as pending timers
 still available (with expired time or immediate timers) by generation lock,
 resp. changed/not invalidated timer-queue) - so fewer event/allocations and
 guarantee to be executed within the next event cycle;

---
 generic/tclTimer.c | 76 +++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 55 insertions(+), 21 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 68c1865..5a34260 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -135,7 +135,15 @@ static void             AfterObj_DupInternalRep(Tcl_Obj *, Tcl_Obj *);
 static void		AfterObj_FreeInternalRep(Tcl_Obj *);
 static void		AfterObj_UpdateString(Tcl_Obj *);
 
+static inline void
+QueueTimerHandlerEvent()
+{
+    Tcl_Event *timerEvPtr;
 
+    timerEvPtr = (Tcl_Event *) ckalloc(sizeof(Tcl_Event));
+    timerEvPtr->proc = TimerHandlerEventProc;
+    Tcl_QueueEvent(timerEvPtr, TCL_QUEUE_TAIL);
+}
 
 /*
  * Type definition.
@@ -367,6 +375,10 @@ Tcl_CreateTimerHandler(
  *	Arrange for a given function to be invoked at a particular time in the
  *	future.
  *
+ *	Specifying the timePtr as NULL ensures that timer event-handler will
+ *	be queued immediately to guarantee the execution of timer-event as 
+ *	soon as possible
+ *
  * Results:
  *	The return value is a handler or token of the timer event, which may
  *	be used to delete the event before it fires.
@@ -398,7 +410,13 @@ TclCreateAbsoluteTimerHandlerEx(
      * Fill in fields for the event.
      */
 
-    memcpy((void *)&timerHandlerPtr->time, (void *)timePtr, sizeof(Tcl_Time));
+    if (timePtr) {
+	memcpy((void *)&timerHandlerPtr->time, (void *)timePtr,
+		sizeof(timerHandlerPtr->time));
+    } else {
+	memset((void *)&timerHandlerPtr->time, 0,
+		sizeof(timerHandlerPtr->time));
+    }
     timerHandlerPtr->proc = proc;
     timerHandlerPtr->deleteProc = deleteProc;
     timerHandlerPtr->clientData = TimerHandler2ClientData(timerHandlerPtr);
@@ -423,7 +441,7 @@ TclCreateAbsoluteTimerHandlerEx(
     	/* search from end as long as one with time before not found */
 	for (thPtrPos = tsdPtr->lastTimerPtr; thPtrPos != NULL;
 	    thPtrPos = thPtrPos->prevPtr) {
-	    if (TCL_TIME_BEFORE(thPtrPos->time, timerHandlerPtr->time)) {
+	    if (!TCL_TIME_BEFORE(timerHandlerPtr->time, thPtrPos->time)) {
 		break;
 	    }
 	}
@@ -444,7 +462,13 @@ TclCreateAbsoluteTimerHandlerEx(
 	}
     }
 
-    TimerSetupProc(NULL, TCL_ALL_EVENTS);
+    if (!timePtr) {
+	/* execute immediately: queue handler event right now */
+	if (!tsdPtr->timerPending) {
+	    QueueTimerHandlerEvent();
+	}
+	tsdPtr->timerPending++;
+    }
 
     return timerHandlerPtr;
 }
@@ -615,11 +639,12 @@ TimerCheckProc(
     ClientData data,		/* Not used. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_Event *timerEvPtr;
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerList) {
+    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerList
+      && !tsdPtr->timerPending
+    ) {
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
@@ -641,12 +666,9 @@ TimerCheckProc(
 	 * If the first timer has expired, stick an event on the queue.
 	 */
 
-	if (blockTime.sec == 0 && blockTime.usec == 0 &&
-		!tsdPtr->timerPending) {
+	if (blockTime.sec == 0 && blockTime.usec == 0) {
 	    tsdPtr->timerPending = 1;
-	    timerEvPtr = (Tcl_Event *) ckalloc(sizeof(Tcl_Event));
-	    timerEvPtr->proc = TimerHandlerEventProc;
-	    Tcl_QueueEvent(timerEvPtr, TCL_QUEUE_TAIL);
+	    QueueTimerHandlerEvent();
 	}
     }
 }
@@ -716,7 +738,6 @@ TimerHandlerEventProc(
      *	  timers appearing before later ones.
      */
 
-    tsdPtr->timerPending = 0;
     currentGeneration = tsdPtr->timerGeneration++;
     Tcl_GetTime(&time);
     for (timerHandlerPtr = tsdPtr->timerList; 
@@ -734,6 +755,7 @@ TimerHandlerEventProc(
 	 */
 
 	if (timerHandlerPtr->generation > currentGeneration) {
+	    tsdPtr->timerPending++;
 	    continue;
 	}
 
@@ -761,18 +783,26 @@ TimerHandlerEventProc(
 	/* be sure that timer-list was not changed inside the proc call */
 	if (currentEpoch != tsdPtr->timerListEpoch) {
 	    /* timer-list was changed - stop processing */
+	    tsdPtr->timerPending++;
 	    break;
 	}
     }
 
+    /* don't need to queue event again by pending timer events */
+    if (tsdPtr->timerPending > 1) {
+    	tsdPtr->timerPending = 1;
+    	return 0; /* leave handler event in the queue */
+    }
+
     /* Reset generation */
     if (!tsdPtr->timerList) {
     	tsdPtr->timerGeneration = 0;
     }
 
-    /* Compute the next timeout (first timer on the list). */
-    TimerSetupProc(NULL, TCL_TIMER_EVENTS);
-    return 1;
+    /* Compute the next timeout (later via TimerSetupProc using the first timer). */
+    tsdPtr->timerPending = 0;
+
+    return 1; /* processing done, again later via TimerCheckProc */
 }
 
 /*
@@ -1082,6 +1112,7 @@ Tcl_AfterObjCmd(
 
     switch (index) {
     case -1: {
+    	Tcl_Time *timePtr = NULL;
     	TimerHandler *timerPtr;
 	if (ms < 0) {
 	    ms = 0;
@@ -1090,15 +1121,18 @@ Tcl_AfterObjCmd(
 	    return AfterDelay(interp, ms);
 	}
 
-	Tcl_GetTime(&wakeup);
-	wakeup.sec += (long)(ms / 1000);
-	wakeup.usec += ((long)(ms % 1000)) * 1000;
-	if (wakeup.usec > 1000000) {
-	    wakeup.sec++;
-	    wakeup.usec -= 1000000;
+	if (ms) {
+	    timePtr = &wakeup;
+	    Tcl_GetTime(&wakeup);
+	    wakeup.sec += (long)(ms / 1000);
+	    wakeup.usec += ((long)(ms % 1000)) * 1000;
+	    if (wakeup.usec > 1000000) {
+		wakeup.sec++;
+		wakeup.usec -= 1000000;
+	    }
 	}
 
-	timerPtr = TclCreateAbsoluteTimerHandlerEx(&wakeup, AfterProc,
+	timerPtr = TclCreateAbsoluteTimerHandlerEx(timePtr, AfterProc,
 			FreeAfterPtr, sizeof(AfterInfo));
 	if (timerPtr == NULL) { /* error handled in panic */
 	    return TCL_ERROR;
-- 
cgit v0.12


From 13a39efcafa31a2d71bd8b642e02f9235a34bfda Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:23:31 +0000
Subject: bug fix: wrong release of after-id tcl-object if it switch type
 (object leak)

---
 generic/tclTimer.c | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 5a34260..041163b 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -1464,12 +1464,15 @@ AfterProc(
     }
 
     /* release object (mark it was triggered) */
-    if (afterPtr->selfPtr && afterPtr->selfPtr->typePtr == &afterObjType) {
-	afterPtr->selfPtr->internalRep.twoPtrValue.ptr1 = NULL;
+    if (afterPtr->selfPtr) {
+	if (afterPtr->selfPtr->typePtr == &afterObjType) {
+	    afterPtr->selfPtr->internalRep.twoPtrValue.ptr1 = NULL;
+	}
 	Tcl_DecrRefCount(afterPtr->selfPtr);
+	afterPtr->selfPtr = NULL;
     }
 
-    /* detach entry from the owner's list */
+    /* detach after-entry from the owner's list */
     TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 
     /*
@@ -1518,13 +1521,16 @@ FreeAfterPtr(
     AfterInfo *afterPtr = (AfterInfo *) clientData;
     AfterAssocData *assocPtr = afterPtr->assocPtr;
 
-    /* release object (mark it was triggered) */
-    if (afterPtr->selfPtr && afterPtr->selfPtr->typePtr == &afterObjType) {
-	afterPtr->selfPtr->internalRep.twoPtrValue.ptr1 = NULL;
+    /* release object (mark it was removed) */
+    if (afterPtr->selfPtr) {
+	if (afterPtr->selfPtr->typePtr == &afterObjType) {
+	    afterPtr->selfPtr->internalRep.twoPtrValue.ptr1 = NULL;
+	}
 	Tcl_DecrRefCount(afterPtr->selfPtr);
+	afterPtr->selfPtr = NULL;
     }
 
-    /* detach entry from the owner's list */
+    /* detach after-entry from the owner's list */
     TclSpliceOutEx(afterPtr, assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
 
     /* free command of entry */
-- 
cgit v0.12


From f629f9d07d2b465bba72bc71df2d2c9d3856bca8 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:23:40 +0000
Subject: [performance] introduced additional queue for prompt timer events
 (after 0) that should be executed immediately (no time); normalizes timer,
 prompt and idle events structures using common TimerEntry structure for all
 types;

---
 generic/tcl.h       |   1 -
 generic/tclInt.h    |  89 +++++-----
 generic/tclInterp.c |   4 +-
 generic/tclTimer.c  | 478 +++++++++++++++++++++++++++++-----------------------
 4 files changed, 310 insertions(+), 262 deletions(-)

diff --git a/generic/tcl.h b/generic/tcl.h
index e36f4d8..6a3c66a 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -696,7 +696,6 @@ typedef void (Tcl_FileFreeProc) _ANSI_ARGS_((ClientData clientData));
 typedef void (Tcl_FreeInternalRepProc) _ANSI_ARGS_((struct Tcl_Obj *objPtr));
 typedef void (Tcl_FreeProc) _ANSI_ARGS_((char *blockPtr));
 typedef void (Tcl_IdleProc) _ANSI_ARGS_((ClientData clientData));
-typedef void (Tcl_IdleDeleteProc) _ANSI_ARGS_((ClientData clientData));
 typedef void (Tcl_InterpDeleteProc) _ANSI_ARGS_((ClientData clientData,
 	Tcl_Interp *interp));
 typedef int (Tcl_MathProc) _ANSI_ARGS_((ClientData clientData,
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 021ba00..a0bab62 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -133,43 +133,54 @@ typedef int ptrdiff_t;
  *----------------------------------------------------------------
  */
 
+#define TCL_PROMPT_EVENT (1 << 0)	/* Mark immediate event */
+#define TCL_IDLE_EVENT   (1 << 5)	/* Mark idle event */
+
 /*
- * For each timer callback that's pending there is one record of the following
- * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
- * together in a list sorted by time (earliest event first).
+ * This structure used for handling of prompt timer events (without time to 
+ * invoke, e. g. created with "after 0") or declared in a call to Tcl_DoWhenIdle
+ * (created with "after idle"). All of the currently-active handlers are linked
+ * together into corresponding list.
  */
 
-				 
-typedef struct TimerHandler {
-    Tcl_TimerProc	*proc;	/* Function to call timer event */
-    Tcl_TimerDeleteProc *deleteProc; /* Function to cleanup timer event */
+typedef struct TimerEntry {
+    Tcl_TimerProc	*proc;	/* Function to call timer/idle event */
+    Tcl_TimerDeleteProc *deleteProc; /* Function to cleanup idle event */
     ClientData clientData;	/* Argument to pass to proc and deleteProc */
+    int			flags;	/* Flags (TCL_IDLE_EVENT, TCL_PROMPT_EVENT) */
     size_t generation;		/* Used to distinguish older handlers from
 				 * recently-created ones. */
-    Tcl_TimerToken token;	/* Identifies handler so it can be deleted. */
-    struct TimerHandler *nextPtr; /* Next and prev event in timer/idle queue, */
-    struct TimerHandler *prevPtr; /* or NULL for end/start of the queue. */
-    Tcl_Time	time;		/* When timer is to fire (if timer event). */
+    struct TimerEntry *nextPtr;/* Next and prev event in idle queue, */
+    struct TimerEntry *prevPtr;/* or NULL for end/start of the queue. */
 /*  ExtraData	 */
-} TimerHandler;
+} TimerEntry;
 
 /*
- * There is one of the following structures for each of the handlers declared
- * in a call to Tcl_DoWhenIdle. All of the currently-active handlers are
- * linked together into a list.
+ * For each timer callback that's pending there is one record of the following
+ * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
+ * together in a list via TimerEntry sorted by time (earliest event first).
  */
 
-typedef struct IdleHandler {
-    Tcl_IdleProc	*proc;	/* Function to call idle event */
-    Tcl_IdleDeleteProc  *deleteProc; /* Function to cleanup idle event */
-    ClientData clientData;	/* Argument to pass to proc and deleteProc */
-    size_t generation;		/* Used to distinguish older handlers from
-				 * recently-created ones. */
-    struct IdleHandler *nextPtr;/* Next and prev event in idle queue, */
-    struct IdleHandler *prevPtr;/* or NULL for end/start of the queue. */
+				 
+typedef struct TimerHandler {
+    Tcl_Time		time;	/* When timer is to fire (if timer event). */
+    Tcl_TimerToken	token;	/* Identifies handler so it can be deleted. */
+    struct TimerEntry	entry;
 /*  ExtraData	 */
-} IdleHandler;
+} TimerHandler;
+
+/*
+ * Macros to wrap ExtraData and TimerHandler resp. TimerEntry (and vice versa)
+ */
+#define TimerEntry2ClientData(ptr)					\
+	    ( (ClientData)(((TimerEntry *)(ptr))+1) )
+#define ClientData2TimerEntry(ptr)					\
+	    ( ((TimerEntry *)(ptr))-1 )
 
+#define TimerEntry2TimerHandler(ptr)					\
+	    ( (TimerHandler *)(((char *)(ptr)) - TclOffset(TimerHandler,entry)) )
+#define TimerHandler2TimerEntry(ptr)					\
+	    ( &(ptr)->entry )
 
 /*
  * The following procedures allow namespaces to be customized to support
@@ -1841,8 +1852,7 @@ typedef struct Interp {
 				 * reached. */
 	int timeGranularity;	/* Mod factor used to determine how often to
 				 * evaluate the limit check. */
-	TimerHandler *timeEvent;
-				/* Handle for a timer callback that will occur
+	TimerEntry *timeEvent;	/* Handle for a timer callback that will occur
 				 * when the time-limit is exceeded. */
 
 	Tcl_HashTable callbacks;/* Mapping from (interp,type) pair to data
@@ -2545,19 +2555,6 @@ MODULE_SCOPE char	tclEmptyString;
 
 
 /*
- * Macros to wrap ExtraData and TimerHandler resp. IdleHandler (and vice versa)
- */
-#define TimerHandler2ClientData(ptr)					\
-	    ( (ClientData)(((TimerHandler *)(ptr))+1) )
-#define ClientData2TimerHandler(ptr)					\
-	    ( ((TimerHandler *)(ptr))-1 )
-
-#define IdleHandler2ClientData(ptr)					\
-	    ( (ClientData)(((IdleHandler *)(ptr))+1) )
-#define ClientData2IdleHandler(ptr)					\
-	    ( ((IdleHandler *)(ptr))-1 )
-
-/*
  *----------------------------------------------------------------
  * Procedures shared among Tcl modules but not used by the outside world:
  *----------------------------------------------------------------
@@ -2925,14 +2922,14 @@ MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
 			    ClientData clientData);
-MODULE_SCOPE TimerHandler*  TclCreateAbsoluteTimerHandlerEx(
-			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
-			    Tcl_TimerDeleteProc *deleteProc, size_t extraSize);
-MODULE_SCOPE void	TclDeleteTimerHandler(TimerHandler *timerHandlerPtr);
-MODULE_SCOPE IdleHandler*   TclCreateIdleHandlerEx(
-			    Tcl_IdleProc *proc, Tcl_IdleDeleteProc *deleteProc,
+MODULE_SCOPE TimerEntry* TclCreateAbsoluteTimerHandlerEx(
+			    Tcl_Time *timePtr,
+			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
 			    size_t extraDataSize);
-MODULE_SCOPE void	TclDeleteIdleHandler(IdleHandler *idlePtr);
+MODULE_SCOPE TimerEntry* TclCreateTimerEntryEx(
+			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
+			    size_t extraDataSize, int flags);
+MODULE_SCOPE void	TclDeleteTimerEntry(TimerEntry *entryPtr);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index cab58bd..50537de 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -3511,7 +3511,7 @@ TclLimitRemoveAllHandlers(
      */
 
     if (iPtr->limit.timeEvent != NULL) {
-	TclDeleteTimerHandler(iPtr->limit.timeEvent);
+	TclDeleteTimerEntry(iPtr->limit.timeEvent);
 	iPtr->limit.timeEvent = NULL;
     }
 }
@@ -3720,7 +3720,7 @@ Tcl_LimitSetTime(
 
     memcpy(&iPtr->limit.time, timeLimitPtr, sizeof(Tcl_Time));
     if (iPtr->limit.timeEvent != NULL) {
-	TclDeleteTimerHandler(iPtr->limit.timeEvent);
+	TclDeleteTimerEntry(iPtr->limit.timeEvent);
     }
     nextMoment.sec = timeLimitPtr->sec;
     nextMoment.usec = timeLimitPtr->usec+10;
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 041163b..7eee89e 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -18,8 +18,6 @@
  * interpreter are linked together in a list.
  */
 
-#define IDLE_EVENT  (1 << 1)	/* Mark idle event */
-
 typedef struct AfterInfo {
     struct AfterAssocData *assocPtr;
 				/* Pointer to the "tclAfter" assocData for the
@@ -28,7 +26,6 @@ typedef struct AfterInfo {
     Tcl_Obj *commandPtr;	/* Command to execute. */
     Tcl_Obj *selfPtr;		/* Points to the handle object (self) */
     size_t id;			/* Integer identifier for command */
-    int			flags;	/* Flags (IDLE_EVENT) */
     struct AfterInfo *nextPtr;	/* Next in list of all "after" commands for
 				 * this interpreter. */
     struct AfterInfo *prevPtr;	/* Prev in list of all "after" commands for
@@ -63,15 +60,17 @@ typedef struct AfterAssocData {
  */
 
 typedef struct {
-    TimerHandler *timerList;	/* First event in queue. */
-    TimerHandler *lastTimerPtr;	/* Last event in queue. */
+    TimerEntry *timerList;	/* First event in queue. */
+    TimerEntry *lastTimerPtr;	/* Last event in queue. */
+    TimerEntry *promptList;	/* First immediate event in queue. */
+    TimerEntry *lastPromptPtr;	/* Last immediate event in queue. */
     size_t timerListEpoch;	/* Used for safe process of event queue (stop
     				 * the cycle after modifying of event queue) */
     int lastTimerId;		/* Timer identifier of most recently created
 				 * timer. */
     int timerPending;		/* 1 if a timer event is in the queue. */
-    IdleHandler *idleList;	/* First in list of all idle handlers. */
-    IdleHandler *lastIdlePtr;	/* Last in list (or NULL for empty list). */
+    TimerEntry *idleList;	/* First in list of all idle handlers. */
+    TimerEntry *lastIdlePtr;	/* Last in list (or NULL for empty list). */
     size_t timerGeneration;	/* Used to fill in the "generation" fields of */
     size_t idleGeneration;	/* timer or idle structures. Increments each
 				 * time we place a new handler to queue inside,
@@ -87,15 +86,10 @@ static Tcl_ThreadDataKey dataKey;
  * Helper macros to wrap AfterInfo and handlers (and vice versa)
  */
 
-#define TimerHandler2AfterInfo(ptr)					\
-	    ( (AfterInfo*)TimerHandler2ClientData(ptr) )
-#define AfterInfo2TimerHandler(ptr)					\
-	    ClientData2TimerHandler(ptr)
-
-#define IdleHandler2AfterInfo(ptr)					\
-	    ( (AfterInfo*)IdleHandler2ClientData(ptr) )
-#define AfterInfo2IdleHandler(ptr)					\
-	    ClientData2IdleHandler(ptr)
+#define TimerEntry2AfterInfo(ptr)					\
+	    ( (AfterInfo*)TimerEntry2ClientData(ptr) )
+#define AfterInfo2TimerEntry(ptr)					\
+	    ClientData2TimerEntry(ptr)
 
 /*
  * Helper macros for working with times. TCL_TIME_BEFORE encodes how to write
@@ -128,7 +122,9 @@ static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr, Tcl_Obj *objPtr);
 static ThreadSpecificData *InitTimer(void);
 static void		TimerExitProc(ClientData clientData);
 static int		TimerHandlerEventProc(Tcl_Event *evPtr, int flags);
+#if 0
 static void		TimerCheckProc(ClientData clientData, int flags);
+#endif
 static void		TimerSetupProc(ClientData clientData, int flags);
 
 static void             AfterObj_DupInternalRep(Tcl_Obj *, Tcl_Obj *);
@@ -276,7 +272,7 @@ InitTimer(void)
 
     if (tsdPtr == NULL) {
 	tsdPtr = TCL_TSD_INIT(&dataKey);
-	Tcl_CreateEventSource(TimerSetupProc, TimerCheckProc, NULL);
+	Tcl_CreateEventSource(TimerSetupProc, NULL, tsdPtr);
 	Tcl_CreateThreadExitHandler(TimerExitProc, NULL);
     }
     return tsdPtr;
@@ -306,15 +302,18 @@ TimerExitProc(
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
 	    TclThreadDataKeyGet(&dataKey);
 
-    Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, NULL);
     if (tsdPtr != NULL) {
-	register TimerHandler *timerHandlerPtr;
+	Tcl_DeleteEventSource(TimerSetupProc, NULL, tsdPtr);
 
-	while ((timerHandlerPtr = tsdPtr->timerList) != NULL) {
-	    tsdPtr->timerList = timerHandlerPtr->nextPtr;
-	    ckfree((char *) timerHandlerPtr);
+	while ((tsdPtr->lastPromptPtr) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->lastPromptPtr);
+	}
+	while ((tsdPtr->lastTimerPtr) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->lastTimerPtr);
+	}
+	while ((tsdPtr->lastIdlePtr) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->lastIdlePtr);
 	}
-	tsdPtr->lastTimerPtr = NULL;
     }
 }
 
@@ -343,7 +342,7 @@ Tcl_CreateTimerHandler(
     Tcl_TimerProc *proc,	/* Function to invoke. */
     ClientData clientData)	/* Arbitrary data to pass to proc. */
 {
-    register TimerHandler *timerHandlerPtr;
+    register TimerEntry *entryPtr;
     Tcl_Time time;
 
     /*
@@ -358,13 +357,13 @@ Tcl_CreateTimerHandler(
 	time.sec += 1;
     }
 
-    timerHandlerPtr = TclCreateAbsoluteTimerHandlerEx(&time, proc, NULL, 0);
-    if (timerHandlerPtr == NULL) {
+    entryPtr = TclCreateAbsoluteTimerHandlerEx(&time, proc, NULL, 0);
+    if (entryPtr == NULL) {
     	return NULL;
     }
-    timerHandlerPtr->clientData = clientData;
+    entryPtr->clientData = clientData;
 
-    return timerHandlerPtr->token;
+    return TimerEntry2TimerHandler(entryPtr)->token;
 }
 
 /*
@@ -375,13 +374,9 @@ Tcl_CreateTimerHandler(
  *	Arrange for a given function to be invoked at a particular time in the
  *	future.
  *
- *	Specifying the timePtr as NULL ensures that timer event-handler will
- *	be queued immediately to guarantee the execution of timer-event as 
- *	soon as possible
- *
  * Results:
- *	The return value is a handler or token of the timer event, which may
- *	be used to delete the event before it fires.
+ *	The return value is a handler entry or token of the timer event, which
+ *	may be used to delete the event before it fires.
  *
  * Side effects:
  *	When the time in timePtr has been reached, proc will be invoked
@@ -390,40 +385,37 @@ Tcl_CreateTimerHandler(
  *--------------------------------------------------------------
  */
 
-TimerHandler*
+TimerEntry*
 TclCreateAbsoluteTimerHandlerEx(
     Tcl_Time *timePtr,			/* Time to be invoked */
     Tcl_TimerProc *proc,		/* Function to invoke */
     Tcl_TimerDeleteProc *deleteProc,	/* Function to cleanup */
     size_t extraDataSize)
 {
-    register TimerHandler *timerHandlerPtr, *thPtrPos;
+    register TimerEntry *entryPtr, *entryPtrPos;
+    register TimerHandler *timerPtr;
     ThreadSpecificData *tsdPtr;
 
     tsdPtr = InitTimer();
-    timerHandlerPtr = (TimerHandler *) ckalloc(sizeof(TimerHandler) + extraDataSize);
-    if (timerHandlerPtr == NULL) {
+    timerPtr = (TimerHandler *) ckalloc(sizeof(TimerHandler) + extraDataSize);
+    if (timerPtr == NULL) {
 	return NULL;
     }
+    entryPtr = TimerHandler2TimerEntry(timerPtr);
 
     /*
      * Fill in fields for the event.
      */
 
-    if (timePtr) {
-	memcpy((void *)&timerHandlerPtr->time, (void *)timePtr,
-		sizeof(timerHandlerPtr->time));
-    } else {
-	memset((void *)&timerHandlerPtr->time, 0,
-		sizeof(timerHandlerPtr->time));
-    }
-    timerHandlerPtr->proc = proc;
-    timerHandlerPtr->deleteProc = deleteProc;
-    timerHandlerPtr->clientData = TimerHandler2ClientData(timerHandlerPtr);
-    timerHandlerPtr->generation = tsdPtr->timerGeneration;
+    memcpy((void *)&(timerPtr->time), (void *)timePtr, sizeof(*timePtr));
+    entryPtr->proc = proc;
+    entryPtr->deleteProc = deleteProc;
+    entryPtr->clientData = TimerEntry2ClientData(entryPtr);
+    entryPtr->flags = 0;
+    entryPtr->generation = tsdPtr->timerGeneration;
     tsdPtr->timerListEpoch++; /* signal-timer list was changed */
     tsdPtr->lastTimerId++;
-    timerHandlerPtr->token = (Tcl_TimerToken) INT2PTR(tsdPtr->lastTimerId);
+    timerPtr->token = (Tcl_TimerToken) INT2PTR(tsdPtr->lastTimerId);
 
     /*
      * Add the event to the queue in the correct position
@@ -431,46 +423,40 @@ TclCreateAbsoluteTimerHandlerEx(
      */
 
     /* if before current first (e. g. "after 0" before first "after 1000") */
-    if ( !(thPtrPos = tsdPtr->timerList)
-      || TCL_TIME_BEFORE(timerHandlerPtr->time, thPtrPos->time)
+    if ( !(entryPtrPos = tsdPtr->timerList)
+      || TCL_TIME_BEFORE(timerPtr->time, 
+	    TimerEntry2TimerHandler(entryPtrPos)->time)
     ) {
     	/* splice to the head */
-	TclSpliceInEx(timerHandlerPtr, 
+	TclSpliceInEx(entryPtr, 
 		tsdPtr->timerList, tsdPtr->lastTimerPtr);
     } else {
     	/* search from end as long as one with time before not found */
-	for (thPtrPos = tsdPtr->lastTimerPtr; thPtrPos != NULL;
-	    thPtrPos = thPtrPos->prevPtr) {
-	    if (!TCL_TIME_BEFORE(timerHandlerPtr->time, thPtrPos->time)) {
+	for (entryPtrPos = tsdPtr->lastTimerPtr; entryPtrPos != NULL;
+	    entryPtrPos = entryPtrPos->prevPtr) {
+	    if (!TCL_TIME_BEFORE(timerPtr->time,
+		    TimerEntry2TimerHandler(entryPtrPos)->time)) {
 		break;
 	    }
 	}
 	/* normally it should be always true, because checked above, but ... */
-	if (thPtrPos != NULL) {
+	if (entryPtrPos != NULL) {
 	    /* insert after found element (with time before new) */
-	    timerHandlerPtr->prevPtr = thPtrPos;
-	    if ((timerHandlerPtr->nextPtr = thPtrPos->nextPtr)) {
-		thPtrPos->nextPtr->prevPtr = timerHandlerPtr;
+	    entryPtr->prevPtr = entryPtrPos;
+	    if ((entryPtr->nextPtr = entryPtrPos->nextPtr)) {
+		entryPtrPos->nextPtr->prevPtr = entryPtr;
 	    } else {
-		tsdPtr->lastTimerPtr = timerHandlerPtr;
+		tsdPtr->lastTimerPtr = entryPtr;
 	    }
-	    thPtrPos->nextPtr = timerHandlerPtr;
+	    entryPtrPos->nextPtr = entryPtr;
 	} else {
 	    /* unexpected case, but ... splice to the head */
-	    TclSpliceInEx(timerHandlerPtr, 
+	    TclSpliceInEx(entryPtr, 
 		tsdPtr->timerList, tsdPtr->lastTimerPtr);
 	}
     }
 
-    if (!timePtr) {
-	/* execute immediately: queue handler event right now */
-	if (!tsdPtr->timerPending) {
-	    QueueTimerHandlerEvent();
-	}
-	tsdPtr->timerPending++;
-    }
-
-    return timerHandlerPtr;
+    return entryPtr;
 }
 
 Tcl_TimerToken
@@ -479,15 +465,15 @@ TclCreateAbsoluteTimerHandler(
     Tcl_TimerProc *proc,
     ClientData clientData)
 {
-    register TimerHandler *timerHandlerPtr;
+    register TimerEntry *entryPtr;
 
-    timerHandlerPtr = TclCreateAbsoluteTimerHandlerEx(timePtr, proc, NULL, 0);
-    if (timerHandlerPtr == NULL) {
+    entryPtr = TclCreateAbsoluteTimerHandlerEx(timePtr, proc, NULL, 0);
+    if (entryPtr == NULL) {
     	return NULL;
     }
-    timerHandlerPtr->clientData = clientData;
+    entryPtr->clientData = clientData;
 
-    return timerHandlerPtr->token;
+    return TimerEntry2TimerHandler(entryPtr)->token;
 }
 
 /*
@@ -513,48 +499,81 @@ Tcl_DeleteTimerHandler(
     Tcl_TimerToken token)	/* Result previously returned by
 				 * Tcl_CreateTimerHandler. */
 {
-    register TimerHandler *timerHandlerPtr;
+    register TimerEntry *entryPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     if (token == NULL) {
 	return;
     }
 
-    for (timerHandlerPtr = tsdPtr->lastTimerPtr;
-	timerHandlerPtr != NULL;
-	timerHandlerPtr = timerHandlerPtr->prevPtr
+    for (entryPtr = tsdPtr->lastTimerPtr;
+	entryPtr != NULL;
+	entryPtr = entryPtr->prevPtr
     ) {
-	if (timerHandlerPtr->token != token) {
+	if (TimerEntry2TimerHandler(entryPtr)->token != token) {
 	    continue;
 	}
 
-	TclDeleteTimerHandler(timerHandlerPtr);
+	TclDeleteTimerEntry(entryPtr);
 	return;
     }
 }
 
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TclDeleteTimerEntry --
+ *
+ *	Delete a previously-registered prompt, timer or idle handler.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Destroy the timer callback, so that its associated function will
+ *	not be called. If the callback has already fired this will be executed
+ *	internally.
+ *
+ *--------------------------------------------------------------
+ */
+
 void
-TclDeleteTimerHandler(
-    TimerHandler *timerHandlerPtr)	/* Result previously returned by */
-					/* TclCreateAbsoluteTimerHandlerEx. */
+TclDeleteTimerEntry(
+    TimerEntry *entryPtr)	/* Result previously returned by */
+	/* TclCreateAbsoluteTimerHandlerEx or TclCreateTimerEntryEx. */
 {
     ThreadSpecificData *tsdPtr;
 
-    if (timerHandlerPtr == NULL) {
+    if (entryPtr == NULL) {
 	return;
     }
 
     tsdPtr = InitTimer();
 
-    tsdPtr->timerListEpoch++; /* signal-timer list was changed */
-    TclSpliceOutEx(timerHandlerPtr, tsdPtr->timerList, tsdPtr->lastTimerPtr);
+    if (entryPtr->flags & TCL_PROMPT_EVENT) {
+    	/* prompt handler */
+	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
+    } else if (entryPtr->flags & TCL_IDLE_EVENT) {
+    	/* idle handler */
+	TclSpliceOutEx(entryPtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+    } else {
+    	/* timer event-handler */
+	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
+	TclSpliceOutEx(entryPtr, tsdPtr->timerList, tsdPtr->lastTimerPtr);
+    }
 
     /* free it via deleteProc or ckfree */
-    if (timerHandlerPtr->deleteProc) {
-	(*timerHandlerPtr->deleteProc)(timerHandlerPtr->clientData);
+    if (entryPtr->deleteProc) {
+	(*entryPtr->deleteProc)(entryPtr->clientData);
     }
 
-    ckfree((char *)timerHandlerPtr);
+    if (entryPtr->flags & (TCL_PROMPT_EVENT|TCL_IDLE_EVENT)) {
+    	ckfree((char *)entryPtr);
+    } else {
+    	/* shift to the allocated pointer */
+    	ckfree((char *)TimerEntry2TimerHandler(entryPtr));
+    }
 }
 
 /*
@@ -580,10 +599,12 @@ TimerSetupProc(
     ClientData data,		/* Not used. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_Time blockTime;
-    ThreadSpecificData *tsdPtr = InitTimer();
+    Tcl_Time blockTime, *firstTime;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
 
-    if (((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList)
+    if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
+
+    if (((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
 	    || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)) {
 	/*
 	 * There is an idle handler or a pending timer event, so just poll.
@@ -598,9 +619,9 @@ TimerSetupProc(
 	 */
 
 	Tcl_GetTime(&blockTime);
-	blockTime.sec = tsdPtr->timerList->time.sec - blockTime.sec;
-	blockTime.usec = tsdPtr->timerList->time.usec -
-		blockTime.usec;
+	firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
+	blockTime.sec = firstTime->sec - blockTime.sec;
+	blockTime.usec = firstTime->usec - blockTime.usec;
 	if (blockTime.usec < 0) {
 	    blockTime.sec -= 1;
 	    blockTime.usec += 1000000;
@@ -609,6 +630,16 @@ TimerSetupProc(
 	    blockTime.sec = 0;
 	    blockTime.usec = 0;
 	}
+
+	/*
+	 * If the first timer has expired, stick an event on the queue.
+	 */
+
+	if (blockTime.sec == 0 && blockTime.usec == 0) {
+	    tsdPtr->timerPending = 1;
+	    QueueTimerHandlerEvent();
+	}
+    
     } else {
 	return;
     }
@@ -616,6 +647,7 @@ TimerSetupProc(
     Tcl_SetMaxBlockTime(&blockTime);
 }
 
+#if 0
 /*
  *----------------------------------------------------------------------
  *
@@ -639,20 +671,27 @@ TimerCheckProc(
     ClientData data,		/* Not used. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_Time blockTime;
+    Tcl_Time blockTime, *firstTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerList
+    if ((flags & TCL_TIMER_EVENTS)
       && !tsdPtr->timerPending
     ) {
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
 
+	if (tsdPtr->promptList) {
+	    goto queuetmr;
+	}
+
+	if (!tsdPtr->timerList) {
+	    return;
+	}
 	Tcl_GetTime(&blockTime);
-	blockTime.sec = tsdPtr->timerList->time.sec - blockTime.sec;
-	blockTime.usec = tsdPtr->timerList->time.usec -
-		blockTime.usec;
+	firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
+	blockTime.sec = firstTime->sec - blockTime.sec;
+	blockTime.usec = firstTime->usec - blockTime.usec;
 	if (blockTime.usec < 0) {
 	    blockTime.sec -= 1;
 	    blockTime.usec += 1000000;
@@ -667,12 +706,14 @@ TimerCheckProc(
 	 */
 
 	if (blockTime.sec == 0 && blockTime.usec == 0) {
+    queuetmr:
 	    tsdPtr->timerPending = 1;
 	    QueueTimerHandlerEvent();
 	}
     }
 }
 
+#endif
 /*
  *----------------------------------------------------------------------
  *
@@ -700,7 +741,7 @@ TimerHandlerEventProc(
     int flags)			/* Flags that indicate what events to handle,
 				 * such as TCL_FILE_EVENTS. */
 {
-    TimerHandler *timerHandlerPtr, *nextPtr;
+    TimerEntry *entryPtr, *nextPtr;
     Tcl_Time time;
     size_t currentGeneration, currentEpoch;
     ThreadSpecificData *tsdPtr = InitTimer();
@@ -739,14 +780,42 @@ TimerHandlerEventProc(
      */
 
     currentGeneration = tsdPtr->timerGeneration++;
+
+    /* First process all prompt (immediate) events */
+    while ((entryPtr = tsdPtr->promptList) != NULL
+	&& entryPtr->generation <= currentGeneration
+    ) {
+	/* detach entry from the owner's list */
+	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
+
+	/* execute event */
+	(*entryPtr->proc)(entryPtr->clientData);
+
+	/* free it via deleteProc and ckfree */
+	if (entryPtr->deleteProc) {
+	    (*entryPtr->deleteProc)(entryPtr->clientData);
+	}
+	ckfree((char *) entryPtr);
+    }
+
+    /* if pending prompt events (new generation) - repeat event cycle right now */
+    if (tsdPtr->promptList) {
+    	tsdPtr->timerPending = 1;
+    	return 0; /* leave handler event in the queue */
+    }
+
+    /* Hereafter all timer events with time before now */
+    if (!tsdPtr->timerList) {
+    	goto done;
+    }
     Tcl_GetTime(&time);
-    for (timerHandlerPtr = tsdPtr->timerList; 
-	 timerHandlerPtr != NULL;
-	 timerHandlerPtr = nextPtr
+    for (entryPtr = tsdPtr->timerList;
+	 entryPtr != NULL;
+	 entryPtr = nextPtr
     ) {
-    	nextPtr = timerHandlerPtr->nextPtr;
+    	nextPtr = entryPtr->nextPtr;
 
-	if (TCL_TIME_BEFORE(time, timerHandlerPtr->time)) {
+	if (TCL_TIME_BEFORE(time, TimerEntry2TimerHandler(entryPtr)->time)) {
 	    break;
 	}
 
@@ -754,7 +823,8 @@ TimerHandlerEventProc(
 	 * Bypass timers of newer generation.
 	 */
 
-	if (timerHandlerPtr->generation > currentGeneration) {
+	if (entryPtr->generation > currentGeneration) {
+	    /* increase pending to signal repeat */
 	    tsdPtr->timerPending++;
 	    continue;
 	}
@@ -766,19 +836,19 @@ TimerHandlerEventProc(
 	 * potential reentrancy problems.
 	 */
 
-	TclSpliceOutEx(timerHandlerPtr, 
+	TclSpliceOutEx(entryPtr, 
 	    tsdPtr->timerList, tsdPtr->lastTimerPtr);
 
 	currentEpoch = tsdPtr->timerListEpoch;
 
 	/* invoke timer proc */
-	(*timerHandlerPtr->proc)(timerHandlerPtr->clientData);
+	(*entryPtr->proc)(entryPtr->clientData);
 	/* free it via deleteProc or ckfree */
-	if (timerHandlerPtr->deleteProc) {
-	    (*timerHandlerPtr->deleteProc)(timerHandlerPtr->clientData);
+	if (entryPtr->deleteProc) {
+	    (*entryPtr->deleteProc)(entryPtr->clientData);
 	}
 
-	ckfree((char *) timerHandlerPtr);
+	ckfree((char *) TimerEntry2TimerHandler(entryPtr));
 
 	/* be sure that timer-list was not changed inside the proc call */
 	if (currentEpoch != tsdPtr->timerListEpoch) {
@@ -788,121 +858,116 @@ TimerHandlerEventProc(
 	}
     }
 
+done:
     /* don't need to queue event again by pending timer events */
     if (tsdPtr->timerPending > 1) {
     	tsdPtr->timerPending = 1;
     	return 0; /* leave handler event in the queue */
     }
 
-    /* Reset generation */
+    /* Reset generation if both timer queue are empty */
     if (!tsdPtr->timerList) {
-    	tsdPtr->timerGeneration = 0;
+	tsdPtr->timerGeneration = 0;
     }
 
     /* Compute the next timeout (later via TimerSetupProc using the first timer). */
     tsdPtr->timerPending = 0;
 
-    return 1; /* processing done, again later via TimerCheckProc */
+    return 1; /* processing done, again later via TimerSetupProc */
 }
 
 /*
  *--------------------------------------------------------------
  *
- * TclCreateIdleHandlerEx --, Tcl_DoWhenIdle --
+ * TclCreateTimerEntryEx --
  *
- *	Arrange for proc to be invoked the next time the system is idle (i.e.,
- *	just before the next time that Tcl_DoOneEvent would have to wait for
+ *	Arrange for proc to be invoked delayed (but prompt) as timer event,
+ *	without time ("after 0").
+ *	Or as idle event (the next time the system is idle i.e., just 
+ *	before the next time that Tcl_DoOneEvent would have to wait for
  *	something to happen).
  *
+ *	Providing the flag TCL_PROMPT_EVENT ensures that timer event-handler
+ *	will be queued immediately to guarantee the execution of timer-event
+ *	as soon as possible
+ *
  * Results:
- *	None.
+ *	Returns the created timer entry.
  *
  * Side effects:
- *	Proc will eventually be called, with clientData as argument. See the
- *	manual entry for details.
+ *	None.
  *
  *--------------------------------------------------------------
  */
 
-IdleHandler *
-TclCreateIdleHandlerEx(
-    Tcl_IdleProc *proc,			/* Function to invoke. */
-    Tcl_IdleDeleteProc *deleteProc,	/* Function to cleanup */
-    size_t extraDataSize)
+TimerEntry *
+TclCreateTimerEntryEx(
+    Tcl_TimerProc *proc,		/* Function to invoke. */
+    Tcl_TimerDeleteProc *deleteProc,	/* Function to cleanup */
+    size_t extraDataSize,
+    int flags)
 {
-    register IdleHandler *idlePtr;
-    Tcl_Time blockTime;
+    register TimerEntry *entryPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    idlePtr = (IdleHandler *) ckalloc(sizeof(IdleHandler) + extraDataSize);
-    if (idlePtr == NULL) {
+    entryPtr = (TimerEntry *) ckalloc(sizeof(TimerEntry) + extraDataSize);
+    if (entryPtr == NULL) {
 	return NULL;
     }
-    idlePtr->proc = proc;
-    idlePtr->deleteProc = deleteProc;
-    idlePtr->clientData = IdleHandler2ClientData(idlePtr);
-    idlePtr->generation = tsdPtr->idleGeneration;
-
-    /* attach to the idle queue */
-    TclSpliceTailEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
-
-    /* reset next block time */
-    blockTime.sec = 0;
-    blockTime.usec = 0;
-    Tcl_SetMaxBlockTime(&blockTime);
-
-    return idlePtr;
-}
-
-void
-Tcl_DoWhenIdle(
-    Tcl_IdleProc *proc,		/* Function to invoke. */
-    ClientData clientData)	/* Arbitrary value to pass to proc. */
-{
-    register IdleHandler *idlePtr = TclCreateIdleHandlerEx(proc, NULL, 0);
-
-    if (idlePtr) {
-    	idlePtr->clientData = clientData;
+    entryPtr->proc = proc;
+    entryPtr->deleteProc = deleteProc;
+    entryPtr->clientData = TimerEntry2ClientData(entryPtr);
+    entryPtr->flags = flags;
+    if (flags & TCL_PROMPT_EVENT) {
+    	/* use timer generation, because usually no differences between 
+    	 * call of "after 0" and "after 1" */
+	entryPtr->generation = tsdPtr->timerGeneration;
+	/* attach to the prompt queue */
+	TclSpliceTailEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
+	
+	/* execute immediately: queue handler event right now */
+	if (!tsdPtr->timerPending) {
+	    QueueTimerHandlerEvent();
+	}
+	tsdPtr->timerPending++; /* queued and TimerSetupProc knows about */
+    } else {
+    	/* idle generation */
+	entryPtr->generation = tsdPtr->idleGeneration;
+	/* attach to the idle queue */
+	TclSpliceTailEx(entryPtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
     }
+
+    return entryPtr;
 }
 
 /*
  *--------------------------------------------------------------
  *
- * TclDeleteIdleHandler --
+ * Tcl_DoWhenIdle --
  *
- *	Delete a previously-registered idle handler.
+ *	Arrange for proc to be invoked the next time the system is idle (i.e.,
+ *	just before the next time that Tcl_DoOneEvent would have to wait for
+ *	something to happen).
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	None.
+ *	Proc will eventually be called, with clientData as argument. See the
+ *	manual entry for details.
  *
  *--------------------------------------------------------------
  */
-
 void
-TclDeleteIdleHandler(
-    IdleHandler *idlePtr)	/* Result previously returned by */
-				/* TclCreateIdleHandlerEx */
+Tcl_DoWhenIdle(
+    Tcl_IdleProc *proc,		/* Function to invoke. */
+    ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    ThreadSpecificData *tsdPtr;
+    TimerEntry *idlePtr = TclCreateTimerEntryEx(proc, NULL, 0, TCL_IDLE_EVENT);
 
-    if (idlePtr == NULL) {
-	return;
-    }
-
-    tsdPtr = InitTimer();
-
-    /* detach entry from the owner list */
-    TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
-
-    /* free it via deleteProc and ckfree */
-    if (idlePtr->deleteProc) {
-	(*idlePtr->deleteProc)(idlePtr->clientData);
+    if (idlePtr) {
+    	idlePtr->clientData = clientData;
     }
-    ckfree((char *)idlePtr);
 }
 
 /*
@@ -928,7 +993,7 @@ Tcl_CancelIdleCall(
     Tcl_IdleProc *proc,		/* Function that was previously registered. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    register IdleHandler *idlePtr, *nextPtr;
+    register TimerEntry *idlePtr, *nextPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     for (idlePtr = tsdPtr->idleList;
@@ -972,7 +1037,7 @@ Tcl_CancelIdleCall(
 int
 TclServiceIdle(void)
 {
-    IdleHandler *idlePtr;
+    TimerEntry *idlePtr;
     size_t currentGeneration;
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
@@ -1053,7 +1118,6 @@ Tcl_AfterObjCmd(
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     Tcl_WideInt ms;		/* Number of milliseconds to wait */
-    Tcl_Time wakeup;
     AfterInfo *afterPtr;
     AfterAssocData *assocPtr;
     int length;
@@ -1112,8 +1176,7 @@ Tcl_AfterObjCmd(
 
     switch (index) {
     case -1: {
-    	Tcl_Time *timePtr = NULL;
-    	TimerHandler *timerPtr;
+    	TimerEntry *entryPtr;
 	if (ms < 0) {
 	    ms = 0;
 	}
@@ -1122,7 +1185,7 @@ Tcl_AfterObjCmd(
 	}
 
 	if (ms) {
-	    timePtr = &wakeup;
+	    Tcl_Time wakeup;
 	    Tcl_GetTime(&wakeup);
 	    wakeup.sec += (long)(ms / 1000);
 	    wakeup.usec += ((long)(ms % 1000)) * 1000;
@@ -1130,20 +1193,22 @@ Tcl_AfterObjCmd(
 		wakeup.sec++;
 		wakeup.usec -= 1000000;
 	    }
+	    entryPtr = TclCreateAbsoluteTimerHandlerEx(&wakeup, AfterProc,
+			    FreeAfterPtr, sizeof(AfterInfo));
+	} else {
+	    entryPtr = TclCreateTimerEntryEx(AfterProc,
+			    FreeAfterPtr, sizeof(AfterInfo), TCL_PROMPT_EVENT);
 	}
 
-	timerPtr = TclCreateAbsoluteTimerHandlerEx(timePtr, AfterProc,
-			FreeAfterPtr, sizeof(AfterInfo));
-	if (timerPtr == NULL) { /* error handled in panic */
+	if (entryPtr == NULL) { /* error handled in panic */
 	    return TCL_ERROR;
 	}
-	afterPtr = TimerHandler2AfterInfo(timerPtr);
+	afterPtr = TimerEntry2AfterInfo(entryPtr);
 
 	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
 	TclSpliceTailEx(afterPtr, 
 		assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
-	afterPtr->flags = 0;
 	afterPtr->selfPtr = NULL;
 
 	if (objc == 3) {
@@ -1208,34 +1273,29 @@ Tcl_AfterObjCmd(
 	    }
 	}
 	if (afterPtr != NULL) {
-	    if (!(afterPtr->flags & IDLE_EVENT)) {
-		TclDeleteTimerHandler(AfterInfo2TimerHandler(afterPtr));
-	    } else {
-		TclDeleteIdleHandler(AfterInfo2IdleHandler(afterPtr));
-	    }
+	    TclDeleteTimerEntry(AfterInfo2TimerEntry(afterPtr));
 	}
 	break;
     }
     case AFTER_IDLE: {
-    	IdleHandler *idlePtr;
+    	TimerEntry *idlePtr;
 
 	if (objc < 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "script script ...");
 	    return TCL_ERROR;
 	}
 
-	idlePtr = TclCreateIdleHandlerEx(AfterProc,
-			FreeAfterPtr, sizeof(AfterInfo));
+	idlePtr = TclCreateTimerEntryEx(AfterProc,
+			FreeAfterPtr, sizeof(AfterInfo), TCL_IDLE_EVENT);
 	if (idlePtr == NULL) { /* error handled in panic */
 	    return TCL_ERROR;
 	}
-	afterPtr = IdleHandler2AfterInfo(idlePtr);
+	afterPtr = TimerEntry2AfterInfo(idlePtr);
 
 	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
 	TclSpliceTailEx(afterPtr, 
 		assocPtr->firstAfterPtr, assocPtr->lastAfterPtr);
-	afterPtr->flags = IDLE_EVENT;
 	afterPtr->selfPtr = NULL;
 
 	if (objc == 3) {
@@ -1285,7 +1345,8 @@ Tcl_AfterObjCmd(
 	resultListPtr = Tcl_NewObj();
 	Tcl_ListObjAppendElement(interp, resultListPtr, afterPtr->commandPtr);
 	Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
- 		(afterPtr->flags & IDLE_EVENT) ? "idle" : "timer", -1));
+ 		(AfterInfo2TimerEntry(afterPtr)->flags & TCL_IDLE_EVENT) ? 
+ 		    "idle" : "timer", -1));
 	Tcl_SetObjResult(interp, resultListPtr);
 	break;
     }
@@ -1457,11 +1518,7 @@ AfterProc(
      */
 
     /* remove delete proc from handler (we'll do cleanup here) */
-    if (!(afterPtr->flags & IDLE_EVENT)) {
-	AfterInfo2TimerHandler(afterPtr)->deleteProc = NULL;
-    } else {
-	AfterInfo2IdleHandler(afterPtr)->deleteProc = NULL;
-    }
+    AfterInfo2TimerEntry(afterPtr)->deleteProc = NULL;
 
     /* release object (mark it was triggered) */
     if (afterPtr->selfPtr) {
@@ -1562,14 +1619,9 @@ AfterCleanupProc(
     Tcl_Interp *interp)		/* Interpreter that is being deleted. */
 {
     AfterAssocData *assocPtr = (AfterAssocData *) clientData;
-    AfterInfo *afterPtr;
 
-    while ( (afterPtr = assocPtr->lastAfterPtr) ) {
-	if (!(afterPtr->flags & IDLE_EVENT)) {
-	    TclDeleteTimerHandler(AfterInfo2TimerHandler(afterPtr));
-	} else {
-	    TclDeleteIdleHandler(AfterInfo2IdleHandler(afterPtr));
-	}
+    while ( assocPtr->lastAfterPtr ) {
+	TclDeleteTimerEntry(AfterInfo2TimerEntry(assocPtr->lastAfterPtr));
     }
 }
 
-- 
cgit v0.12


From df949554f991f8fb4a399bdd248437012deebe40 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:23:45 +0000
Subject: =?UTF-8?q?[performance]=20large=20performance=20increase=20by=20e?=
 =?UTF-8?q?vent=20servicing=20cycles=20(3x=20-=205x=20faster=20now);=20[wi?=
 =?UTF-8?q?n]=20prevent=20listen=20using=20PeekMessage=20twice,=20and=20no?=
 =?UTF-8?q?=20wait=20anymore=20for=20too=20short=20timeouts=20(because=20w?=
 =?UTF-8?q?indows=20can=20wait=20too=20long),=20compare=200=C2=B5s=20with?=
 =?UTF-8?q?=20up-to=20100=C2=B5s=20overhead=20within=20MsgWaitForMultipleO?=
 =?UTF-8?q?bjectsEx;=20[bad=20behavior]=20process=20idle=20events=20only?=
 =?UTF-8?q?=20as=20long=20as=20no=20other=20events=20available=20(now=20Tc?=
 =?UTF-8?q?lPeekEventQueued=20will=20be=20used=20to=20check=20new=20events?=
 =?UTF-8?q?=20are=20available=20in=20service=20idle=20cycle);=20[enhanceme?=
 =?UTF-8?q?nt]=20new=20option=20"noidletasks"=20for=20command=20"update",?=
 =?UTF-8?q?=20so=20"update=20noidle"=20means=20"process=20all=20events=20b?=
 =?UTF-8?q?ut=20not=20idle";?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 generic/tclEvent.c  |  14 ++--
 generic/tclInt.h    |   4 +
 generic/tclNotify.c | 119 +++++++++++++++++++++++++----
 generic/tclTimer.c  | 214 ++++++++++++++++++++++------------------------------
 tests/event.test    |   4 +-
 win/tclWinNotify.c  |  47 +++++++-----
 6 files changed, 238 insertions(+), 164 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 4db524c..85c564a 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1410,26 +1410,28 @@ Tcl_UpdateObjCmd(
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     int optionIndex;
-    int flags = 0;		/* Initialized to avoid compiler warning. */
-    static CONST char *updateOptions[] = {"idletasks", NULL};
-    enum updateOptions {REGEXP_IDLETASKS};
+    int flags = TCL_ALL_EVENTS|TCL_DONT_WAIT;
+    static CONST char *updateOptions[] = {"idletasks", "noidletasks", NULL};
+    enum updateOptions {UPDATE_IDLETASKS, UPDATE_NOIDLETASKS};
 
     if (objc == 1) {
-	flags = TCL_ALL_EVENTS|TCL_DONT_WAIT;
     } else if (objc == 2) {
 	if (Tcl_GetIndexFromObj(interp, objv[1], updateOptions,
 		"option", 0, &optionIndex) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	switch ((enum updateOptions) optionIndex) {
-	case REGEXP_IDLETASKS:
+	case UPDATE_IDLETASKS:
 	    flags = TCL_WINDOW_EVENTS|TCL_IDLE_EVENTS|TCL_DONT_WAIT;
 	    break;
+	case UPDATE_NOIDLETASKS:
+	    flags &= ~TCL_IDLE_EVENTS;
+	    break;
 	default:
 	    Tcl_Panic("Tcl_UpdateObjCmd: bad option index to UpdateOptions");
 	}
     } else {
-	Tcl_WrongNumArgs(interp, 1, objv, "?idletasks?");
+	Tcl_WrongNumArgs(interp, 1, objv, "?option?");
 	return TCL_ERROR;
     }
 
diff --git a/generic/tclInt.h b/generic/tclInt.h
index a0bab62..4151f83 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2484,6 +2484,7 @@ MODULE_SCOPE Tcl_ObjType tclByteCodeType;
 MODULE_SCOPE Tcl_ObjType tclDoubleType;
 MODULE_SCOPE Tcl_ObjType tclEndOffsetType;
 MODULE_SCOPE Tcl_ObjType tclIntType;
+MODULE_SCOPE Tcl_ObjType tclIndexType;
 MODULE_SCOPE Tcl_ObjType tclListType;
 MODULE_SCOPE Tcl_ObjType tclDictType;
 MODULE_SCOPE Tcl_ObjType tclProcBodyType;
@@ -2919,6 +2920,8 @@ MODULE_SCOPE int	Tcl_ConcatObjCmd(ClientData clientData,
 MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
+MODULE_SCOPE void	TclSetTimerEventMarker(void);
+MODULE_SCOPE int	TclServiceTimerEvents(void);
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
 			    ClientData clientData);
@@ -2930,6 +2933,7 @@ MODULE_SCOPE TimerEntry* TclCreateTimerEntryEx(
 			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
 			    size_t extraDataSize, int flags);
 MODULE_SCOPE void	TclDeleteTimerEntry(TimerEntry *entryPtr);
+MODULE_SCOPE int	TclPeekEventQueued(int flags);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index b45539a..e883071 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -49,6 +49,8 @@ typedef struct ThreadSpecificData {
     Tcl_Event *lastEventPtr;	/* Last pending event, or NULL if none. */
     Tcl_Event *markerEventPtr;	/* Last high-priority event in queue, or NULL
 				 * if none. */
+    Tcl_Event *timerMarkerPtr;	/* Weak pointer to last event in the queue, 
+    				 * before timer event generation */
     Tcl_Mutex queueMutex;	/* Mutex to protect access to the previous
 				 * three fields. */
     int serviceMode;		/* One of TCL_SERVICE_NONE or
@@ -612,7 +614,7 @@ Tcl_ServiceEvent(
 {
     Tcl_Event *evPtr, *prevPtr;
     Tcl_EventProc *proc;
-    int result;
+    int result = 0;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
@@ -635,6 +637,13 @@ Tcl_ServiceEvent(
     }
 
     /*
+     * If timer marker reached, process timer events now.
+     */
+    if (tsdPtr->timerMarkerPtr == INT2PTR(-1) || !tsdPtr->firstEventPtr) {
+	goto timer;
+    }
+
+    /*
      * Loop through all the events in the queue until we find one that can
      * actually be handled.
      */
@@ -642,6 +651,14 @@ Tcl_ServiceEvent(
     Tcl_MutexLock(&(tsdPtr->queueMutex));
     for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL;
 	    evPtr = evPtr->nextPtr) {
+	
+	/*
+	* If timer marker reached, next cycle will process timer events.
+	*/
+	if (evPtr == tsdPtr->timerMarkerPtr) {
+	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
+	}
+
 	/*
 	 * Call the handler for the event. If it actually handles the event
 	 * then free the storage for the event. There are two tricky things
@@ -721,7 +738,85 @@ Tcl_ServiceEvent(
 	}
     }
     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
-    return 0;
+
+timer:
+    /*
+     * Process timer queue, if alloved and timers are enabled.
+     */
+    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr) {
+	/* reset marker */
+	tsdPtr->timerMarkerPtr = NULL;
+
+	result = TclServiceTimerEvents();
+	if (result <= 0) {
+	    /* events processed, but marker to process still pending timers */
+	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
+	    result = 1;
+	}
+    }
+
+
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclPeekEventQueued --
+ *
+ *	Check whether some event (except idle) available (async, queued, timer).
+ *
+ *	This will be used e. g. in TclServiceIdle to stop the processing of the
+ *	the idle events if some "normal" event occurred.
+ *
+ * Results:
+ *	Returns 1 if some event queued, 0 otherwise.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclPeekEventQueued(
+    int flags)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    return Tcl_AsyncReady()
+        || (tsdPtr->firstEventPtr)
+	|| ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclSetTimerEventMarker --
+ *
+ *	Set timer event marker to the last pending event in the queue.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TclSetTimerEventMarker(void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (tsdPtr->timerMarkerPtr == NULL) {
+	/* marker to last event in the queue */
+	if (!(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
+	    /* marker as "now" - queue is empty, so timers events are first */
+	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
+	};
+    }
 }
 
 /*
@@ -855,21 +950,12 @@ Tcl_DoOneEvent(
 				 * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or
 				 * others defined by event sources. */
 {
-    int result = 0, oldMode;
+    int result = 0, oldMode, i = 0;
     EventSource *sourcePtr;
     Tcl_Time *timePtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
-     * The first thing we do is to service any asynchronous event handlers.
-     */
-
-    if (Tcl_AsyncReady()) {
-	(void) Tcl_AsyncInvoke(NULL, 0);
-	return 1;
-    }
-
-    /*
      * No event flags is equivalent to TCL_ALL_EVENTS.
      */
 
@@ -904,7 +990,8 @@ Tcl_DoOneEvent(
 	}
 
 	/*
-	 * Ask Tcl to service a queued event, if there are any.
+	 * Ask Tcl to service any asynchronous event handlers or 
+	* queued event, if there are any.
 	 */
 
 	if (Tcl_ServiceEvent(flags)) {
@@ -921,6 +1008,8 @@ Tcl_DoOneEvent(
 	    tsdPtr->blockTime.sec = 0;
 	    tsdPtr->blockTime.usec = 0;
 	    tsdPtr->blockTimeSet = 1;
+	    timePtr = &tsdPtr->blockTime;
+	    goto wait; /* for notifier resp. system events */
 	} else {
 	    tsdPtr->blockTimeSet = 0;
 	}
@@ -939,7 +1028,7 @@ Tcl_DoOneEvent(
 	}
 	tsdPtr->inTraversal = 0;
 
-	if ((flags & TCL_DONT_WAIT) || tsdPtr->blockTimeSet) {
+	if (tsdPtr->blockTimeSet) {
 	    timePtr = &tsdPtr->blockTime;
 	} else {
 	    timePtr = NULL;
@@ -949,7 +1038,7 @@ Tcl_DoOneEvent(
 	 * Wait for a new event or a timeout. If Tcl_WaitForEvent returns -1,
 	 * we should abort Tcl_DoOneEvent.
 	 */
-
+    wait:
 	result = Tcl_WaitForEvent(timePtr);
 	if (result < 0) {
 	    result = 0;
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 7eee89e..d3aa5aa 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -121,26 +121,13 @@ static void		FreeAfterPtr(ClientData clientData);
 static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr, Tcl_Obj *objPtr);
 static ThreadSpecificData *InitTimer(void);
 static void		TimerExitProc(ClientData clientData);
-static int		TimerHandlerEventProc(Tcl_Event *evPtr, int flags);
-#if 0
 static void		TimerCheckProc(ClientData clientData, int flags);
-#endif
 static void		TimerSetupProc(ClientData clientData, int flags);
 
 static void             AfterObj_DupInternalRep(Tcl_Obj *, Tcl_Obj *);
 static void		AfterObj_FreeInternalRep(Tcl_Obj *);
 static void		AfterObj_UpdateString(Tcl_Obj *);
 
-static inline void
-QueueTimerHandlerEvent()
-{
-    Tcl_Event *timerEvPtr;
-
-    timerEvPtr = (Tcl_Event *) ckalloc(sizeof(Tcl_Event));
-    timerEvPtr->proc = TimerHandlerEventProc;
-    Tcl_QueueEvent(timerEvPtr, TCL_QUEUE_TAIL);
-}
-
 /*
  * Type definition.
  */
@@ -272,7 +259,7 @@ InitTimer(void)
 
     if (tsdPtr == NULL) {
 	tsdPtr = TCL_TSD_INIT(&dataKey);
-	Tcl_CreateEventSource(TimerSetupProc, NULL, tsdPtr);
+	Tcl_CreateEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
 	Tcl_CreateThreadExitHandler(TimerExitProc, NULL);
     }
     return tsdPtr;
@@ -303,7 +290,7 @@ TimerExitProc(
 	    TclThreadDataKeyGet(&dataKey);
 
     if (tsdPtr != NULL) {
-	Tcl_DeleteEventSource(TimerSetupProc, NULL, tsdPtr);
+	Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
 
 	while ((tsdPtr->lastPromptPtr) != NULL) {
 	    TclDeleteTimerEntry(tsdPtr->lastPromptPtr);
@@ -596,7 +583,7 @@ TclDeleteTimerEntry(
 
 static void
 TimerSetupProc(
-    ClientData data,		/* Not used. */
+    ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
     Tcl_Time blockTime, *firstTime;
@@ -604,10 +591,11 @@ TimerSetupProc(
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
-    if (((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
-	    || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)) {
+    if ( ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)
+      || ((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
+    ) {
 	/*
-	 * There is an idle handler or a pending timer event, so just poll.
+	 * There is a pending timer event or an idle handler, so just poll.
 	 */
 
 	blockTime.sec = 0;
@@ -630,15 +618,6 @@ TimerSetupProc(
 	    blockTime.sec = 0;
 	    blockTime.usec = 0;
 	}
-
-	/*
-	 * If the first timer has expired, stick an event on the queue.
-	 */
-
-	if (blockTime.sec == 0 && blockTime.usec == 0) {
-	    tsdPtr->timerPending = 1;
-	    QueueTimerHandlerEvent();
-	}
     
     } else {
 	return;
@@ -647,15 +626,13 @@ TimerSetupProc(
     Tcl_SetMaxBlockTime(&blockTime);
 }
 
-#if 0
 /*
  *----------------------------------------------------------------------
  *
  * TimerCheckProc --
  *
  *	This function is called by Tcl_DoOneEvent to check the timer event
- *	source for events. This routine checks both the idle and after timer
- *	lists.
+ *	source for events. This routine checks the first timer in the list.
  *
  * Results:
  *	None.
@@ -668,66 +645,63 @@ TimerSetupProc(
 
 static void
 TimerCheckProc(
-    ClientData data,		/* Not used. */
+    ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
     Tcl_Time blockTime, *firstTime;
-    ThreadSpecificData *tsdPtr = InitTimer();
-
-    if ((flags & TCL_TIMER_EVENTS)
-      && !tsdPtr->timerPending
-    ) {
-	/*
-	 * Compute the timeout for the next timer on the list.
-	 */
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
 
-	if (tsdPtr->promptList) {
-	    goto queuetmr;
-	}
+    if (!(flags & TCL_TIMER_EVENTS)) {
+    	return;
+    }
 
-	if (!tsdPtr->timerList) {
-	    return;
-	}
-	Tcl_GetTime(&blockTime);
-	firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
-	blockTime.sec = firstTime->sec - blockTime.sec;
-	blockTime.usec = firstTime->usec - blockTime.usec;
-	if (blockTime.usec < 0) {
-	    blockTime.sec -= 1;
-	    blockTime.usec += 1000000;
-	}
-	if (blockTime.sec < 0) {
-	    blockTime.sec = 0;
-	    blockTime.usec = 0;
-	}
+    if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
-	/*
-	 * If the first timer has expired, stick an event on the queue.
-	 */
+    /* If already pending */
+    if (!tsdPtr->timerList || tsdPtr->timerPending) {
+    	return;
+    }
 
-	if (blockTime.sec == 0 && blockTime.usec == 0) {
-    queuetmr:
-	    tsdPtr->timerPending = 1;
-	    QueueTimerHandlerEvent();
-	}
+    /*
+     * Verify the first timer on the queue.
+     */
+    Tcl_GetTime(&blockTime);
+    firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
+    blockTime.sec = firstTime->sec - blockTime.sec;
+    blockTime.usec = firstTime->usec - blockTime.usec;
+    if (blockTime.usec < 0) {
+        blockTime.sec -= 1;
+        blockTime.usec += 1000000;
+    }
+    if (blockTime.sec < 0) {
+        blockTime.sec = 0;
+        blockTime.usec = 0;
+    }
+    
+    /*
+    * If the first timer has expired, stick an event on the queue.
+    */
+    if (blockTime.sec == 0 && blockTime.usec == 0) {
+        TclSetTimerEventMarker();
+        tsdPtr->timerPending = 1;
     }
 }
 
-#endif
 /*
  *----------------------------------------------------------------------
  *
- * TimerHandlerEventProc --
+ * TclServiceTimerEvents --
  *
- *	This function is called by Tcl_ServiceEvent when a timer event reaches
- *	the front of the event queue. This function handles the event by
+ *	This function is called by Tcl_ServiceEvent when a timer events should 
+ *	be processed. This function handles the event by
  *	invoking the callbacks for all timers that are ready.
  *
  * Results:
  *	Returns 1 if the event was handled, meaning it should be removed from
- *	the queue. Returns 0 if the event was not handled, meaning it should
- *	stay on the queue. The only time the event isn't handled is if the
- *	TCL_TIMER_EVENTS flag bit isn't set.
+ *	the queue. 
+ *	Returns 0 if the event was not handled (no timer events).
+ *	Returns -1 if pending timer events available, meaning the marker should
+ *	stay on the queue.
  *
  * Side effects:
  *	Whatever the timer handler callback functions do.
@@ -735,25 +709,17 @@ TimerCheckProc(
  *----------------------------------------------------------------------
  */
 
-static int
-TimerHandlerEventProc(
-    Tcl_Event *evPtr,		/* Event to service. */
-    int flags)			/* Flags that indicate what events to handle,
-				 * such as TCL_FILE_EVENTS. */
+int
+TclServiceTimerEvents(void)
 {
     TimerEntry *entryPtr, *nextPtr;
     Tcl_Time time;
     size_t currentGeneration, currentEpoch;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    /*
-     * Do nothing if timers aren't enabled. This leaves the event on the
-     * queue, so we will get to it as soon as ServiceEvents() is called with
-     * timers enabled.
-     */
 
-    if (!(flags & TCL_TIMER_EVENTS)) {
-	return 0;
+    if (!tsdPtr->timerPending) {
+    	return 0; /* no timer events */
     }
 
     /*
@@ -798,10 +764,10 @@ TimerHandlerEventProc(
 	ckfree((char *) entryPtr);
     }
 
-    /* if pending prompt events (new generation) - repeat event cycle right now */
+    /* if stil pending prompt events (new generation) - repeat event cycle as 
+     * soon as possible */
     if (tsdPtr->promptList) {
-    	tsdPtr->timerPending = 1;
-    	return 0; /* leave handler event in the queue */
+    	return -1;
     }
 
     /* Hereafter all timer events with time before now */
@@ -859,10 +825,10 @@ TimerHandlerEventProc(
     }
 
 done:
-    /* don't need to queue event again by pending timer events */
+    /* pending timer events, so mark (queue) timer events  */
     if (tsdPtr->timerPending > 1) {
     	tsdPtr->timerPending = 1;
-    	return 0; /* leave handler event in the queue */
+    	return -1;
     }
 
     /* Reset generation if both timer queue are empty */
@@ -873,7 +839,7 @@ done:
     /* Compute the next timeout (later via TimerSetupProc using the first timer). */
     tsdPtr->timerPending = 0;
 
-    return 1; /* processing done, again later via TimerSetupProc */
+    return 1; /* processing done, again later via TimerCheckProc */
 }
 
 /*
@@ -925,11 +891,9 @@ TclCreateTimerEntryEx(
 	/* attach to the prompt queue */
 	TclSpliceTailEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
 	
-	/* execute immediately: queue handler event right now */
-	if (!tsdPtr->timerPending) {
-	    QueueTimerHandlerEvent();
-	}
-	tsdPtr->timerPending++; /* queued and TimerSetupProc knows about */
+	/* execute immediately: signal pending and set timer marker */
+	tsdPtr->timerPending++;
+	TclSetTimerEventMarker();
     } else {
     	/* idle generation */
 	entryPtr->generation = tsdPtr->idleGeneration;
@@ -1018,7 +982,7 @@ Tcl_CancelIdleCall(
 /*
  *----------------------------------------------------------------------
  *
- * TclServiceIdle --
+ * TclServiceIdle -- , TclServiceIdleEx --
  *
  *	This function is invoked by the notifier when it becomes idle. It will
  *	invoke all idle handlers that are present at the time the call is
@@ -1035,14 +999,14 @@ Tcl_CancelIdleCall(
  */
 
 int
-TclServiceIdle(void)
+TclServiceIdleEx(
+    int count)
 {
     TimerEntry *idlePtr;
     size_t currentGeneration;
-    Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    if (tsdPtr->idleList == NULL) {
+    if ((idlePtr = tsdPtr->idleList) == NULL) {
 	return 0;
     }
 
@@ -1065,9 +1029,7 @@ TclServiceIdle(void)
      *	  during the call.
      */
 
-    while ((idlePtr = tsdPtr->idleList) != NULL
-	&& idlePtr->generation <= currentGeneration
-    ) {
+    while (idlePtr->generation <= currentGeneration) {
 	/* detach entry from the owner's list */
 	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
 
@@ -1079,18 +1041,28 @@ TclServiceIdle(void)
 	    (*idlePtr->deleteProc)(idlePtr->clientData);
 	}
 	ckfree((char *) idlePtr);
+
+	/* stop processing idle if no more idle, count reached or other queued */
+	if ( (idlePtr = tsdPtr->idleList) == NULL
+	  || !--count
+	  || TclPeekEventQueued(TCL_ALL_EVENTS)
+	) {
+	    break;
+	}
     }
-    if (tsdPtr->idleList) {
-	blockTime.sec = 0;
-	blockTime.usec = 0;
-	Tcl_SetMaxBlockTime(&blockTime);
-    }
+
     /* Reset generation */
     if (!tsdPtr->idleList) {
     	tsdPtr->idleGeneration = 0;
     }
     return 1;
 }
+
+int
+TclServiceIdle(void)
+{
+    return TclServiceIdleEx(INT_MAX);
+}
 
 /*
  *----------------------------------------------------------------------
@@ -1152,21 +1124,17 @@ Tcl_AfterObjCmd(
      * First lets see if the command was passed a number as the first argument.
      */
 
-    if (objv[1]->typePtr == &tclIntType
-#ifndef NO_WIDE_TYPE
-	|| objv[1]->typePtr == &tclWideIntType
-#endif
-	|| objv[1]->typePtr == &tclBignumType
-	|| ( Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0, 
-				 &index) != TCL_OK )) {
-	index = -1;
-	if (Tcl_GetWideIntFromObj(NULL, objv[1], &ms) != TCL_OK) {
-	    Tcl_AppendResult(interp, "bad argument \"",
-			     Tcl_GetString(objv[1]),
-			     "\": must be cancel, idle, info, or an integer",
-			     NULL);
-	    return TCL_ERROR;
-	}
+    index = -1;
+    if ( ( objv[1]->typePtr == &tclIndexType 
+	|| Tcl_GetWideIntFromObj(NULL, objv[1], &ms) != TCL_OK
+      )
+      && Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0,
+				 &index) != TCL_OK
+    ) {
+	Tcl_AppendResult(interp, "bad argument \"",
+		Tcl_GetString(objv[1]),
+		"\": must be cancel, idle, info, or an integer", NULL);
+	return TCL_ERROR;
     }
 
     /* 
diff --git a/tests/event.test b/tests/event.test
index b6d4144..526faf2 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -625,10 +625,10 @@ test event-11.7 {Bug 16828b3744} {
 
 test event-12.1 {Tcl_UpdateCmd procedure} {
     list [catch {update a b} msg] $msg
-} {1 {wrong # args: should be "update ?idletasks?"}}
+} {1 {wrong # args: should be "update ?option?"}}
 test event-12.2 {Tcl_UpdateCmd procedure} {
     list [catch {update bogus} msg] $msg
-} {1 {bad option "bogus": must be idletasks}}
+} {1 {bad option "bogus": must be idletasks or noidletasks}}
 test event-12.3 {Tcl_UpdateCmd procedure} {
     foreach i [after info] {
 	after cancel $i
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index 1cd5823..26aa296 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -437,13 +437,19 @@ Tcl_WaitForEvent(
      */
 
     if (timePtr) {
+
+	Tcl_Time myTime;
+
+	/* No wait if timeout too small (because windows may wait too long) */
+	if (!timePtr->sec && timePtr->usec <= 10) {
+	    goto peek;
+	}
+
 	/*
 	 * TIP #233 (Virtualized Time). Convert virtual domain delay to
 	 * real-time.
 	 */
 
-	Tcl_Time myTime;
-
 	myTime.sec  = timePtr->sec;
 	myTime.usec = timePtr->usec;
 
@@ -452,6 +458,7 @@ Tcl_WaitForEvent(
 	}
 
 	timeout = myTime.sec * 1000 + myTime.usec / 1000;
+
     } else {
 	timeout = INFINITE;
     }
@@ -462,33 +469,38 @@ Tcl_WaitForEvent(
      * currently sitting in the queue.
      */
 
-    if (!PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
-	/*
-	 * Wait for something to happen (a signal from another thread, a
-	 * message, or timeout) or loop servicing asynchronous procedure calls
-	 * queued to this thread.
-	 */
+    if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
+    	goto get;
+    }
 
-    again:
-	result = MsgWaitForMultipleObjectsEx(1, &tsdPtr->event, timeout,
+    /*
+     * Wait for something to happen (a signal from another thread, a
+     * message, or timeout) or loop servicing asynchronous procedure calls
+     * queued to this thread.
+     */
+    
+  again:
+    result = MsgWaitForMultipleObjectsEx(1, &tsdPtr->event, timeout,
 		QS_ALLINPUT, MWMO_ALERTABLE);
-	if (result == WAIT_IO_COMPLETION) {
-	    goto again;
-	} else if (result == WAIT_FAILED) {
-	    status = -1;
-	    goto end;
-	}
+    if (result == WAIT_IO_COMPLETION) {
+	goto again;
+    }
+    ResetEvent(tsdPtr->event);
+    if (result == WAIT_FAILED) {
+	status = -1;
+	goto end;
     }
 
     /*
      * Check to see if there are any messages to process.
      */
-
+  peek:
     if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
 	/*
 	 * Retrieve and dispatch the first message.
 	 */
 
+  get:
 	result = GetMessage(&msg, NULL, 0, 0);
 	if (result == 0) {
 	    /*
@@ -515,7 +527,6 @@ Tcl_WaitForEvent(
     }
 
   end:
-    ResetEvent(tsdPtr->event);
     return status;
 }
 
-- 
cgit v0.12


From 8a1d9a3be57af976d24c218db14975378927f125 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:24:04 +0000
Subject: [performance] much better handling for timer events within
 Tcl_ServiceEvent using timer marker in the queue and direct call of
 TclServiceTimerEvents if marker reached (instead of continuous adding handler
 event, polling it in the queue and removing hereafter); this provides double
 performance increase in the service cycle;

---
 generic/tclIndexObj.c |  16 +++----
 generic/tclInt.h      |   1 -
 generic/tclNotify.c   |  54 +++++++----------------
 generic/tclTimer.c    | 118 ++++++++++++--------------------------------------
 4 files changed, 51 insertions(+), 138 deletions(-)

diff --git a/generic/tclIndexObj.c b/generic/tclIndexObj.c
index 73ba515..ced7bd9 100644
--- a/generic/tclIndexObj.c
+++ b/generic/tclIndexObj.c
@@ -27,7 +27,7 @@ static void		FreeIndex(Tcl_Obj *objPtr);
  * that can be invoked by generic object code.
  */
 
-static Tcl_ObjType indexType = {
+Tcl_ObjType tclIndexType = {
     "index",				/* name */
     FreeIndex,				/* freeIntRepProc */
     DupIndex,				/* dupIntRepProc */
@@ -105,7 +105,7 @@ Tcl_GetIndexFromObj(
      * the common case where the result is cached).
      */
 
-    if (objPtr->typePtr == &indexType) {
+    if (objPtr->typePtr == &tclIndexType) {
 	IndexRep *indexRep = objPtr->internalRep.twoPtrValue.ptr1;
 
 	/*
@@ -179,7 +179,7 @@ Tcl_GetIndexFromObjStruct(
      * See if there is a valid cached result from a previous lookup.
      */
 
-    if (objPtr->typePtr == &indexType) {
+    if (objPtr->typePtr == &tclIndexType) {
 	indexRep = objPtr->internalRep.twoPtrValue.ptr1;
 	if (indexRep->tablePtr==tablePtr && indexRep->offset==offset) {
 	    *indexPtr = indexRep->index;
@@ -240,13 +240,13 @@ Tcl_GetIndexFromObjStruct(
      * operation.
      */
 
-    if (objPtr->typePtr == &indexType) {
+    if (objPtr->typePtr == &tclIndexType) {
  	indexRep = objPtr->internalRep.twoPtrValue.ptr1;
     } else {
 	TclFreeIntRep(objPtr);
  	indexRep = (IndexRep *) ckalloc(sizeof(IndexRep));
  	objPtr->internalRep.twoPtrValue.ptr1 = indexRep;
- 	objPtr->typePtr = &indexType;
+ 	objPtr->typePtr = &tclIndexType;
     }
     indexRep->tablePtr = (void *) tablePtr;
     indexRep->offset = offset;
@@ -382,7 +382,7 @@ DupIndex(
 
     memcpy(dupIndexRep, srcIndexRep, sizeof(IndexRep));
     dupPtr->internalRep.twoPtrValue.ptr1 = dupIndexRep;
-    dupPtr->typePtr = &indexType;
+    dupPtr->typePtr = &tclIndexType;
 }
 
 /*
@@ -532,7 +532,7 @@ Tcl_WrongNumArgs(
 	     * Add the element, quoting it if necessary.
 	     */
 
-	    if (origObjv[i]->typePtr == &indexType) {
+	    if (origObjv[i]->typePtr == &tclIndexType) {
 		register IndexRep *indexRep =
 			origObjv[i]->internalRep.twoPtrValue.ptr1;
 
@@ -588,7 +588,7 @@ Tcl_WrongNumArgs(
 	 * Otherwise, just use the string rep.
 	 */
 
-	if (objv[i]->typePtr == &indexType) {
+	if (objv[i]->typePtr == &tclIndexType) {
 	    register IndexRep *indexRep = objv[i]->internalRep.twoPtrValue.ptr1;
 
 	    Tcl_AppendStringsToObj(objPtr, EXPAND_OF(indexRep), NULL);
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 4151f83..d0d1240 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2933,7 +2933,6 @@ MODULE_SCOPE TimerEntry* TclCreateTimerEntryEx(
 			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
 			    size_t extraDataSize, int flags);
 MODULE_SCOPE void	TclDeleteTimerEntry(TimerEntry *entryPtr);
-MODULE_SCOPE int	TclPeekEventQueued(int flags);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index e883071..89182ea 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -639,7 +639,7 @@ Tcl_ServiceEvent(
     /*
      * If timer marker reached, process timer events now.
      */
-    if (tsdPtr->timerMarkerPtr == INT2PTR(-1) || !tsdPtr->firstEventPtr) {
+    if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) {
 	goto timer;
     }
 
@@ -743,7 +743,7 @@ timer:
     /*
      * Process timer queue, if alloved and timers are enabled.
      */
-    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr) {
+    if (flags & TCL_TIMER_EVENTS && tsdPtr->timerMarkerPtr) {
 	/* reset marker */
 	tsdPtr->timerMarkerPtr = NULL;
 
@@ -762,36 +762,6 @@ timer:
 /*
  *----------------------------------------------------------------------
  *
- * TclPeekEventQueued --
- *
- *	Check whether some event (except idle) available (async, queued, timer).
- *
- *	This will be used e. g. in TclServiceIdle to stop the processing of the
- *	the idle events if some "normal" event occurred.
- *
- * Results:
- *	Returns 1 if some event queued, 0 otherwise.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TclPeekEventQueued(
-    int flags)
-{
-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-
-    return Tcl_AsyncReady()
-        || (tsdPtr->firstEventPtr)
-	|| ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * TclSetTimerEventMarker --
  *
  *	Set timer event marker to the last pending event in the queue.
@@ -950,12 +920,21 @@ Tcl_DoOneEvent(
 				 * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or
 				 * others defined by event sources. */
 {
-    int result = 0, oldMode, i = 0;
+    int result = 0, oldMode;
     EventSource *sourcePtr;
     Tcl_Time *timePtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
+     * The first thing we do is to service any asynchronous event handlers.
+     */
+
+    if (Tcl_AsyncReady()) {
+	(void) Tcl_AsyncInvoke(NULL, 0);
+	return 1;
+    }
+
+    /*
      * No event flags is equivalent to TCL_ALL_EVENTS.
      */
 
@@ -990,8 +969,7 @@ Tcl_DoOneEvent(
 	}
 
 	/*
-	 * Ask Tcl to service any asynchronous event handlers or 
-	* queued event, if there are any.
+	 * Ask Tcl to service a queued event, if there are any.
 	 */
 
 	if (Tcl_ServiceEvent(flags)) {
@@ -1008,8 +986,6 @@ Tcl_DoOneEvent(
 	    tsdPtr->blockTime.sec = 0;
 	    tsdPtr->blockTime.usec = 0;
 	    tsdPtr->blockTimeSet = 1;
-	    timePtr = &tsdPtr->blockTime;
-	    goto wait; /* for notifier resp. system events */
 	} else {
 	    tsdPtr->blockTimeSet = 0;
 	}
@@ -1028,7 +1004,7 @@ Tcl_DoOneEvent(
 	}
 	tsdPtr->inTraversal = 0;
 
-	if (tsdPtr->blockTimeSet) {
+	if ((flags & TCL_DONT_WAIT) || tsdPtr->blockTimeSet) {
 	    timePtr = &tsdPtr->blockTime;
 	} else {
 	    timePtr = NULL;
@@ -1038,7 +1014,7 @@ Tcl_DoOneEvent(
 	 * Wait for a new event or a timeout. If Tcl_WaitForEvent returns -1,
 	 * we should abort Tcl_DoOneEvent.
 	 */
-    wait:
+
 	result = Tcl_WaitForEvent(timePtr);
 	if (result < 0) {
 	    result = 0;
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index d3aa5aa..12b039f 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -121,7 +121,6 @@ static void		FreeAfterPtr(ClientData clientData);
 static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr, Tcl_Obj *objPtr);
 static ThreadSpecificData *InitTimer(void);
 static void		TimerExitProc(ClientData clientData);
-static void		TimerCheckProc(ClientData clientData, int flags);
 static void		TimerSetupProc(ClientData clientData, int flags);
 
 static void             AfterObj_DupInternalRep(Tcl_Obj *, Tcl_Obj *);
@@ -259,7 +258,7 @@ InitTimer(void)
 
     if (tsdPtr == NULL) {
 	tsdPtr = TCL_TSD_INIT(&dataKey);
-	Tcl_CreateEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
+	Tcl_CreateEventSource(TimerSetupProc, NULL, tsdPtr);
 	Tcl_CreateThreadExitHandler(TimerExitProc, NULL);
     }
     return tsdPtr;
@@ -290,7 +289,7 @@ TimerExitProc(
 	    TclThreadDataKeyGet(&dataKey);
 
     if (tsdPtr != NULL) {
-	Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
+	Tcl_DeleteEventSource(TimerSetupProc, NULL, tsdPtr);
 
 	while ((tsdPtr->lastPromptPtr) != NULL) {
 	    TclDeleteTimerEntry(tsdPtr->lastPromptPtr);
@@ -583,7 +582,7 @@ TclDeleteTimerEntry(
 
 static void
 TimerSetupProc(
-    ClientData data,		/* Specific data. */
+    ClientData data,		/* Not used. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
     Tcl_Time blockTime, *firstTime;
@@ -591,11 +590,10 @@ TimerSetupProc(
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
-    if ( ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)
-      || ((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
-    ) {
+    if (((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
+	    || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)) {
 	/*
-	 * There is a pending timer event or an idle handler, so just poll.
+	 * There is an idle handler or a pending timer event, so just poll.
 	 */
 
 	blockTime.sec = 0;
@@ -618,6 +616,15 @@ TimerSetupProc(
 	    blockTime.sec = 0;
 	    blockTime.usec = 0;
 	}
+
+	/*
+	 * If the first timer has expired, stick an event on the queue.
+	 */
+
+	if (!tsdPtr->timerPending && blockTime.sec == 0 && blockTime.usec == 0) {
+	    TclSetTimerEventMarker();
+	    tsdPtr->timerPending = 1;
+	}
     
     } else {
 	return;
@@ -629,67 +636,6 @@ TimerSetupProc(
 /*
  *----------------------------------------------------------------------
  *
- * TimerCheckProc --
- *
- *	This function is called by Tcl_DoOneEvent to check the timer event
- *	source for events. This routine checks the first timer in the list.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	May queue an event and update the maximum notifier block time.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-TimerCheckProc(
-    ClientData data,		/* Specific data. */
-    int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
-{
-    Tcl_Time blockTime, *firstTime;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
-
-    if (!(flags & TCL_TIMER_EVENTS)) {
-    	return;
-    }
-
-    if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
-
-    /* If already pending */
-    if (!tsdPtr->timerList || tsdPtr->timerPending) {
-    	return;
-    }
-
-    /*
-     * Verify the first timer on the queue.
-     */
-    Tcl_GetTime(&blockTime);
-    firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
-    blockTime.sec = firstTime->sec - blockTime.sec;
-    blockTime.usec = firstTime->usec - blockTime.usec;
-    if (blockTime.usec < 0) {
-        blockTime.sec -= 1;
-        blockTime.usec += 1000000;
-    }
-    if (blockTime.sec < 0) {
-        blockTime.sec = 0;
-        blockTime.usec = 0;
-    }
-    
-    /*
-    * If the first timer has expired, stick an event on the queue.
-    */
-    if (blockTime.sec == 0 && blockTime.usec == 0) {
-        TclSetTimerEventMarker();
-        tsdPtr->timerPending = 1;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * TclServiceTimerEvents --
  *
  *	This function is called by Tcl_ServiceEvent when a timer events should 
@@ -839,7 +785,7 @@ done:
     /* Compute the next timeout (later via TimerSetupProc using the first timer). */
     tsdPtr->timerPending = 0;
 
-    return 1; /* processing done, again later via TimerCheckProc */
+    return 1; /* processing done, again later via TimerSetupProc */
 }
 
 /*
@@ -982,7 +928,7 @@ Tcl_CancelIdleCall(
 /*
  *----------------------------------------------------------------------
  *
- * TclServiceIdle -- , TclServiceIdleEx --
+ * TclServiceIdle --
  *
  *	This function is invoked by the notifier when it becomes idle. It will
  *	invoke all idle handlers that are present at the time the call is
@@ -999,14 +945,14 @@ Tcl_CancelIdleCall(
  */
 
 int
-TclServiceIdleEx(
-    int count)
+TclServiceIdle(void)
 {
     TimerEntry *idlePtr;
     size_t currentGeneration;
+    Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    if ((idlePtr = tsdPtr->idleList) == NULL) {
+    if (tsdPtr->idleList == NULL) {
 	return 0;
     }
 
@@ -1029,7 +975,9 @@ TclServiceIdleEx(
      *	  during the call.
      */
 
-    while (idlePtr->generation <= currentGeneration) {
+    while ((idlePtr = tsdPtr->idleList) != NULL
+	&& idlePtr->generation <= currentGeneration
+    ) {
 	/* detach entry from the owner's list */
 	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
 
@@ -1041,28 +989,18 @@ TclServiceIdleEx(
 	    (*idlePtr->deleteProc)(idlePtr->clientData);
 	}
 	ckfree((char *) idlePtr);
-
-	/* stop processing idle if no more idle, count reached or other queued */
-	if ( (idlePtr = tsdPtr->idleList) == NULL
-	  || !--count
-	  || TclPeekEventQueued(TCL_ALL_EVENTS)
-	) {
-	    break;
-	}
     }
-
+    if (tsdPtr->idleList) {
+	blockTime.sec = 0;
+	blockTime.usec = 0;
+	Tcl_SetMaxBlockTime(&blockTime);
+    }
     /* Reset generation */
     if (!tsdPtr->idleList) {
     	tsdPtr->idleGeneration = 0;
     }
     return 1;
 }
-
-int
-TclServiceIdle(void)
-{
-    return TclServiceIdleEx(INT_MAX);
-}
 
 /*
  *----------------------------------------------------------------------
-- 
cgit v0.12


From ee8dccacb4206a0ac43f8cb427b86775cedc4684 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:24:12 +0000
Subject: command "vwait" extended with timeout argument (in ms), 0 could be
 used to process pending events only (without wait), negative value equivalent
 execution of "vwait" without timeout (infinite); test cases fixed and
 extended;

---
 generic/tclEvent.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++++------
 tests/event.test   | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 140 insertions(+), 10 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 85c564a..27953a4 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1299,6 +1299,14 @@ TclInThreadExit(void)
     }
 }
 
+static void
+VwaitTimeOutProc(
+    ClientData clientData)
+{
+    int *donePtr = (int *) clientData;
+
+    *donePtr = -1;
+}
 /*
  *----------------------------------------------------------------------
  *
@@ -1324,31 +1332,82 @@ Tcl_VwaitObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    int done, foundEvent;
+    int done, foundEvent, flags = TCL_ALL_EVENTS;
     char *nameString;
+    TimerEntry *timerEvent = NULL;
 
-    if (objc != 2) {
-	Tcl_WrongNumArgs(interp, 1, objv, "name");
+    if (objc < 2 || objc > 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "name ?timeout?");
 	return TCL_ERROR;
     }
+
+    /* if timeout specified - create timer event or no-wait by 0ms */
+    if (objc == 3) {
+    	Tcl_Time wakeup;
+    	Tcl_WideInt ms;
+    	if (Tcl_GetWideIntFromObj(interp, objv[2], &ms) != TCL_OK) {
+    	    return TCL_ERROR;
+    	}
+    	if (ms > 0) {
+	    Tcl_GetTime(&wakeup);
+	    wakeup.sec += (long)(ms / 1000);
+	    wakeup.usec += ((long)(ms % 1000)) * 1000;
+	    if (wakeup.usec > 1000000) {
+	        wakeup.sec++;
+	        wakeup.usec -= 1000000;
+	    }
+	    timerEvent = TclCreateAbsoluteTimerHandlerEx(&wakeup, VwaitTimeOutProc, NULL, 0);
+	    timerEvent->clientData = &done;
+	} else if (ms == 0) {
+	    flags |= TCL_DONT_WAIT;
+	} else {
+	    /* infinite vait */
+	    objc = 2;
+	}
+    }
+
     nameString = Tcl_GetString(objv[1]);
     if (Tcl_TraceVar(interp, nameString,
 	    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 	    VwaitVarProc, (ClientData) &done) != TCL_OK) {
 	return TCL_ERROR;
     };
+
     done = 0;
-    foundEvent = 1;
-    while (!done && foundEvent) {
-	foundEvent = Tcl_DoOneEvent(TCL_ALL_EVENTS);
+    do {
+	if ((foundEvent = Tcl_DoOneEvent(flags)) == 0) {
+	    /* no wait, no error - just stop waiting (no more events) */
+	    if (flags |= TCL_DONT_WAIT) {
+		foundEvent = 1;
+		done = -2;
+	    }
+	    break;
+	}
 	if (Tcl_LimitExceeded(interp)) {
+	    foundEvent = -1;
 	    break;
 	}
-    }
+    } while (!done);
+    
     Tcl_UntraceVar(interp, nameString,
 	    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 	    VwaitVarProc, (ClientData) &done);
 
+    /* if timeout-timer and no timeout fired, cancel timer event */
+    if (timerEvent && done != -1) {
+	TclDeleteTimerEntry(timerEvent);
+    }
+
+    /* if timeout specified (and no errors) */
+    if (objc == 3 && foundEvent > 0) {
+    	Tcl_Obj *objPtr;
+
+	/* done - true, timeout false */
+	TclNewLongObj(objPtr, (done > 0));
+	Tcl_SetObjResult(interp, objPtr);
+	return TCL_OK;
+    }
+
     /*
      * Clear out the interpreter's result, since it may have been set by event
      * handlers.
@@ -1360,7 +1419,7 @@ Tcl_VwaitObjCmd(
 		"\": would wait forever", NULL);
 	return TCL_ERROR;
     }
-    if (!done) {
+    if (foundEvent == -1) {
 	Tcl_AppendResult(interp, "limit exceeded", NULL);
 	return TCL_ERROR;
     }
diff --git a/tests/event.test b/tests/event.test
index 526faf2..c905489 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -488,10 +488,10 @@ test event-10.1 {Tcl_Exit procedure} {stdio} {
 
 test event-11.1 {Tcl_VwaitCmd procedure} {
     list [catch {vwait} msg] $msg
-} {1 {wrong # args: should be "vwait name"}}
+} {1 {wrong # args: should be "vwait name ?timeout?"}}
 test event-11.2 {Tcl_VwaitCmd procedure} {
     list [catch {vwait a b} msg] $msg
-} {1 {wrong # args: should be "vwait name"}}
+} {1 {expected integer but got "b"}}
 test event-11.3 {Tcl_VwaitCmd procedure} {
     catch {unset x}
     set x 1
@@ -513,6 +513,77 @@ test event-11.4 {Tcl_VwaitCmd procedure} {} {
     list [vwait y] $x $y $z $q
 } {{} x-done y-done before q-done}
 
+test event-11.4.0 {vwait - interp limit precedence} {} {
+    foreach i [after info] {
+	after cancel $i
+    }
+    set result {}
+    set i [interp create]
+    $i bgerror {lappend errors}; # prevent stdout background errors;
+
+    # limit should be exceeded (wait infinite):
+    $i limit time -milliseconds 0
+    lappend result 1. [catch {$i eval {vwait x}} msg] $msg
+
+    # no limit in between:
+    $i limit time -seconds {} -milliseconds {}
+    lappend result 2. [catch {$i eval {vwait x 0}} msg] $msg
+
+    # limit should be exceeded: (wait infinite by -1)
+    $i limit time -milliseconds 0
+    lappend result 3. [catch {$i eval {vwait x -1}} msg] $msg
+    # limit should be exceeded (wait too long - 1000ms):
+    $i limit time -milliseconds 0
+    lappend result 4. [catch {$i eval {vwait x 1000}} msg] $msg
+
+    set tout [clock seconds]; incr tout 10
+    # wait timeout (before limit):
+    $i limit time -seconds $tout
+    lappend result 5. [catch {$i eval {vwait x 0}} msg] $msg
+    # wait timeout (before limit):
+    $i limit time -seconds $tout
+    lappend result 6. [catch {$i eval {vwait x 10}} msg] $msg
+
+    # wait successful (before limit):
+    $i limit time -seconds $tout
+    lappend result 7. [catch {$i eval {after 0 {set x ""}; vwait x 10}} msg] $msg
+
+    interp delete $i
+    set result
+} [list \
+    1. 1 {limit exceeded} \
+    2. 0 0 \
+    3. 1 {limit exceeded} \
+    4. 1 {limit exceeded} \
+    5. 0 0 \
+    6. 0 0 \
+    7. 0 1 \
+]
+
+test event-11.4.1 {vwait with timeout} {} {
+    foreach i [after info] {
+	after cancel $i
+    }
+    set z {}
+    set x {}
+    # success cases:
+    after 0 {lappend z 0}
+    after 20 {lappend x 1}
+    after 30 {lappend x 2}
+    after 100 {lappend x 3}
+    after 1000 {lappend x "error-too-slow"}
+    vwait x 0; # no-wait
+    lappend z $x; # 0 {} - (x still empty)
+    vwait x 50; # wait up-to 50ms
+    lappend z $x; # 0 {} {1 2}
+    vwait x -1; # wait without timeout
+    lappend z $x; # 0 {} {1 2} {1 2 3}
+    foreach i [after info] {
+	after cancel $i
+    }
+    set z
+} {0 {} {1 2} {1 2 3}}
+
 test event-11.4.2 {cancel} {} {
     foreach i [after info] {
 	after cancel $i
-- 
cgit v0.12


From 5daa7f610ab6e2ea43bca023cb3cfe96811b48b4 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:24:36 +0000
Subject: [performance] do one event (update / event servicing) cycle optimized
 (introduced threshold to prevent sourcing resp. waiting for new events by
 no-wait). [enhancement] new event type introduced: TCL_ASYNC_EVENTS, command
 "update" becomes options to process only specified types, resp. to bypass
 some event types (including -idle/-noidle that in opposite to "idletasks"
 does not included window events); test cases extended.

---
 generic/tcl.h       |   1 +
 generic/tclEvent.c  |  55 ++++++++++++-------
 generic/tclInt.h    |   2 +
 generic/tclNotify.c | 154 ++++++++++++++++++++++++++++++++++++++++++++--------
 generic/tclTimer.c  | 122 +++++++++++++++++++++++++++++++++--------
 tests/event.test    |  61 +++++++++++++++++++--
 6 files changed, 326 insertions(+), 69 deletions(-)

diff --git a/generic/tcl.h b/generic/tcl.h
index 6a3c66a..b65a5cb 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -1297,6 +1297,7 @@ typedef struct {
  * events:
  */
 
+#define TCL_ASYNC_EVENTS	(1<<0)
 #define TCL_DONT_WAIT		(1<<1)
 #define TCL_WINDOW_EVENTS	(1<<2)
 #define TCL_FILE_EVENTS		(1<<3)
diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 27953a4..d18836b 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1468,30 +1468,42 @@ Tcl_UpdateObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    int optionIndex;
-    int flags = TCL_ALL_EVENTS|TCL_DONT_WAIT;
-    static CONST char *updateOptions[] = {"idletasks", "noidletasks", NULL};
-    enum updateOptions {UPDATE_IDLETASKS, UPDATE_NOIDLETASKS};
-
-    if (objc == 1) {
-    } else if (objc == 2) {
-	if (Tcl_GetIndexFromObj(interp, objv[1], updateOptions,
+    int i, optionIndex;
+    static CONST defUpdateFlags = TCL_ALL_EVENTS|TCL_DONT_WAIT;
+    int flags = defUpdateFlags;
+    static CONST char *updateOptions[] = {"idletasks",  /* backwards compat. */
+	"-nowait", "-wait",				/* new options */
+	"-idle", "-noidle", "-timer", "-notimer",	
+	"-file", "-nofile", "-window", "-nowindow",
+	"-async", "-noasync",
+	NULL};
+    static CONST struct {
+	int minus;
+	int plus;
+    } *updateFlag, updateFlags[] = {
+	{TCL_ALL_EVENTS, 
+	    TCL_WINDOW_EVENTS|TCL_IDLE_EVENTS}, /* idletasks */
+	{0, TCL_DONT_WAIT},	{TCL_DONT_WAIT, 0},	/* -nowait, -wait */
+	{0, TCL_IDLE_EVENTS},	{TCL_IDLE_EVENTS, 0},	/* -idle, -noidle */
+	{0, TCL_TIMER_EVENTS},	{TCL_TIMER_EVENTS, 0},	/* -file, -nofile */
+	{0, TCL_FILE_EVENTS},	{TCL_FILE_EVENTS, 0},	/* -file, -nofile */
+	{0, TCL_WINDOW_EVENTS},	{TCL_WINDOW_EVENTS, 0},	/* -window, -nowindow */
+	{0, TCL_ASYNC_EVENTS},	{TCL_ASYNC_EVENTS, 0},	/* -async, -noasync */
+	{0, 0} /* dummy / place holder */
+    };
+
+    for (i = 1; i < objc; i++) {
+	if (Tcl_GetIndexFromObj(interp, objv[i], updateOptions,
 		"option", 0, &optionIndex) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	switch ((enum updateOptions) optionIndex) {
-	case UPDATE_IDLETASKS:
-	    flags = TCL_WINDOW_EVENTS|TCL_IDLE_EVENTS|TCL_DONT_WAIT;
-	    break;
-	case UPDATE_NOIDLETASKS:
-	    flags &= ~TCL_IDLE_EVENTS;
-	    break;
-	default:
-	    Tcl_Panic("Tcl_UpdateObjCmd: bad option index to UpdateOptions");
+	updateFlag = &updateFlags[optionIndex];
+	/* pure positive option and still default - reset all events */
+	if (flags == defUpdateFlags && !updateFlag->minus) {
+	    flags &= ~TCL_ALL_EVENTS;
 	}
-    } else {
-	Tcl_WrongNumArgs(interp, 1, objv, "?option?");
-	return TCL_ERROR;
+	flags &= ~updateFlag->minus;
+	flags |= updateFlag->plus;
     }
 
     while (Tcl_DoOneEvent(flags) != 0) {
@@ -1500,6 +1512,9 @@ Tcl_UpdateObjCmd(
 	    Tcl_AppendResult(interp, "limit exceeded", NULL);
 	    return TCL_ERROR;
 	}
+
+	/* be sure not to produce infinite wait (wait only once) */
+	flags |= TCL_DONT_WAIT;
     }
 
     /*
diff --git a/generic/tclInt.h b/generic/tclInt.h
index d0d1240..dd73eac 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2922,6 +2922,7 @@ MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE void	TclSetTimerEventMarker(void);
 MODULE_SCOPE int	TclServiceTimerEvents(void);
+MODULE_SCOPE int	TclServiceIdleEx(int flags, int count);
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
 			    ClientData clientData);
@@ -2933,6 +2934,7 @@ MODULE_SCOPE TimerEntry* TclCreateTimerEntryEx(
 			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
 			    size_t extraDataSize, int flags);
 MODULE_SCOPE void	TclDeleteTimerEntry(TimerEntry *entryPtr);
+MODULE_SCOPE int	TclPeekEventQueued(int flags);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index 89182ea..f13fca3 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -72,11 +72,25 @@ typedef struct ThreadSpecificData {
 				/* Next notifier in global list of notifiers.
 				 * Access is controlled by the listLock global
 				 * mutex. */
+#ifndef TCL_WIDE_CLICKS		/* Last "time" source checked, used as threshold */
+    unsigned long lastCheckClicks;
+#else
+    Tcl_WideInt lastCheckClicks;
+#endif
 } ThreadSpecificData;
 
 static Tcl_ThreadDataKey dataKey;
 
 /*
+ * Used for performance purposes, threshold to bypass check source (if don't wait)
+ * Values under 1000 should be approximately under 1ms, e. g. 10 is ca. 0.01ms
+ */
+#ifndef CHECK_EVENT_SOURCE_THRESHOLD
+    #define CHECK_EVENT_SOURCE_THRESHOLD 10
+#endif
+
+
+/*
  * Global list of notifiers. Access to this list is controlled by the listLock
  * mutex. If this becomes a performance bottleneck, this could be replaced
  * with a hashtable.
@@ -618,28 +632,36 @@ Tcl_ServiceEvent(
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
+     * No event flags is equivalent to TCL_ALL_EVENTS.
+     */
+
+    if ((flags & TCL_ALL_EVENTS) == 0) {
+	flags |= TCL_ALL_EVENTS;
+    }
+
+    /*
      * Asynchronous event handlers are considered to be the highest priority
      * events, and so must be invoked before we process events on the event
      * queue.
      */
 
-    if (Tcl_AsyncReady()) {
+    if ((flags & TCL_ASYNC_EVENTS) && Tcl_AsyncReady()) {
 	(void) Tcl_AsyncInvoke(NULL, 0);
 	return 1;
     }
 
-    /*
-     * No event flags is equivalent to TCL_ALL_EVENTS.
-     */
-
-    if ((flags & TCL_ALL_EVENTS) == 0) {
-	flags |= TCL_ALL_EVENTS;
+    /* Async only */
+    if ((flags & TCL_ALL_EVENTS) == TCL_ASYNC_EVENTS) {
+	return 0;
     }
 
     /*
      * If timer marker reached, process timer events now.
      */
-    if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) {
+    if ( tsdPtr->timerMarkerPtr == INT2PTR(-1)
+      || !tsdPtr->firstEventPtr
+      || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS)
+    ) {
 	goto timer;
     }
 
@@ -743,7 +765,7 @@ timer:
     /*
      * Process timer queue, if alloved and timers are enabled.
      */
-    if (flags & TCL_TIMER_EVENTS && tsdPtr->timerMarkerPtr) {
+    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr) {
 	/* reset marker */
 	tsdPtr->timerMarkerPtr = NULL;
 
@@ -762,6 +784,73 @@ timer:
 /*
  *----------------------------------------------------------------------
  *
+ * TclPeekEventQueued --
+ *
+ *	Check whether some event (except idle) available (async, queued, timer).
+ *
+ *	This will be used e. g. in TclServiceIdle to stop the processing of the
+ *	the idle events if some "normal" event occurred.
+ *
+ * Results:
+ *	Returns 1 if some event queued, 0 otherwise.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclPeekEventQueued(
+    int flags)
+{
+    EventSource *sourcePtr;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    int repeat = 1;
+
+    do {
+    	/* 
+    	 * Events already pending ? 
+    	 */
+	if ( Tcl_AsyncReady()
+	  || (tsdPtr->firstEventPtr)
+	  || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr)
+	) {
+	    return 1;
+	}
+
+	if (flags & TCL_DONT_WAIT) {
+	    /* don't need to wait/check for events too often */
+#ifndef TCL_WIDE_CLICKS
+	    unsigned long clicks = TclpGetClicks();
+#else
+	    Tcl_WideInt clicks = TclpGetWideClicks();
+#endif
+
+	    if ((clicks - tsdPtr->lastCheckClicks) <= CHECK_EVENT_SOURCE_THRESHOLD) {
+		return 0;
+	    }
+	    tsdPtr->lastCheckClicks = clicks;
+	}
+
+	/*
+	 * Check all the event sources for new events.
+	 */
+	for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
+		sourcePtr = sourcePtr->nextPtr) {
+	    if (sourcePtr->checkProc) {
+		(sourcePtr->checkProc)(sourcePtr->clientData, flags);
+	    }
+	}
+    
+    } while (repeat--);
+
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * TclSetTimerEventMarker --
  *
  *	Set timer event marker to the last pending event in the queue.
@@ -920,26 +1009,33 @@ Tcl_DoOneEvent(
 				 * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or
 				 * others defined by event sources. */
 {
-    int result = 0, oldMode;
+    int result = 0, oldMode, i = 0;
     EventSource *sourcePtr;
     Tcl_Time *timePtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
-     * The first thing we do is to service any asynchronous event handlers.
+     * No event flags is equivalent to TCL_ALL_EVENTS.
      */
 
-    if (Tcl_AsyncReady()) {
-	(void) Tcl_AsyncInvoke(NULL, 0);
-	return 1;
+    if ((flags & TCL_ALL_EVENTS) == 0) {
+	flags |= TCL_ALL_EVENTS;
     }
 
     /*
-     * No event flags is equivalent to TCL_ALL_EVENTS.
+     * Asynchronous event handlers are considered to be the highest priority
+     * events, and so must be invoked before we process events on the event
+     * queue.
      */
 
-    if ((flags & TCL_ALL_EVENTS) == 0) {
-	flags |= TCL_ALL_EVENTS;
+    if ((flags & TCL_ASYNC_EVENTS) && Tcl_AsyncReady()) {
+	(void) Tcl_AsyncInvoke(NULL, 0);
+	return 1;
+    }
+
+    /* Async only */
+    if ((flags & TCL_ALL_EVENTS) == TCL_ASYNC_EVENTS) {
+	return 0;
     }
 
     /*
@@ -964,12 +1060,13 @@ Tcl_DoOneEvent(
 	 */
 
 	if ((flags & TCL_ALL_EVENTS) == TCL_IDLE_EVENTS) {
-	    flags = TCL_IDLE_EVENTS | TCL_DONT_WAIT;
+	    flags |= TCL_DONT_WAIT;
 	    goto idleEvents;
 	}
 
 	/*
-	 * Ask Tcl to service a queued event, if there are any.
+	 * Ask Tcl to service any asynchronous event handlers or 
+	* queued event, if there are any.
 	 */
 
 	if (Tcl_ServiceEvent(flags)) {
@@ -983,9 +1080,22 @@ Tcl_DoOneEvent(
 	 */
 
 	if (flags & TCL_DONT_WAIT) {
+	    /* don't need to wait/check for events too often */
+#ifndef TCL_WIDE_CLICKS
+	    unsigned long clicks = TclpGetClicks();
+#else
+	    Tcl_WideInt clicks = TclpGetWideClicks();
+#endif
+	    if ((clicks - tsdPtr->lastCheckClicks) <= CHECK_EVENT_SOURCE_THRESHOLD) {
+		goto idleEvents;
+	    }
+	    tsdPtr->lastCheckClicks = clicks;
+
 	    tsdPtr->blockTime.sec = 0;
 	    tsdPtr->blockTime.usec = 0;
 	    tsdPtr->blockTimeSet = 1;
+	    timePtr = &tsdPtr->blockTime;
+	    goto wait; /* for notifier resp. system events */
 	} else {
 	    tsdPtr->blockTimeSet = 0;
 	}
@@ -1004,7 +1114,7 @@ Tcl_DoOneEvent(
 	}
 	tsdPtr->inTraversal = 0;
 
-	if ((flags & TCL_DONT_WAIT) || tsdPtr->blockTimeSet) {
+	if (tsdPtr->blockTimeSet) {
 	    timePtr = &tsdPtr->blockTime;
 	} else {
 	    timePtr = NULL;
@@ -1014,7 +1124,7 @@ Tcl_DoOneEvent(
 	 * Wait for a new event or a timeout. If Tcl_WaitForEvent returns -1,
 	 * we should abort Tcl_DoOneEvent.
 	 */
-
+    wait:
 	result = Tcl_WaitForEvent(timePtr);
 	if (result < 0) {
 	    result = 0;
@@ -1049,7 +1159,7 @@ Tcl_DoOneEvent(
 
     idleEvents:
 	if (flags & TCL_IDLE_EVENTS) {
-	    if (TclServiceIdle()) {
+	    if (TclServiceIdleEx(flags, INT_MAX)) {
 		result = 1;
 		break;
 	    }
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 12b039f..52a3073 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -121,6 +121,7 @@ static void		FreeAfterPtr(ClientData clientData);
 static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr, Tcl_Obj *objPtr);
 static ThreadSpecificData *InitTimer(void);
 static void		TimerExitProc(ClientData clientData);
+static void		TimerCheckProc(ClientData clientData, int flags);
 static void		TimerSetupProc(ClientData clientData, int flags);
 
 static void             AfterObj_DupInternalRep(Tcl_Obj *, Tcl_Obj *);
@@ -258,7 +259,7 @@ InitTimer(void)
 
     if (tsdPtr == NULL) {
 	tsdPtr = TCL_TSD_INIT(&dataKey);
-	Tcl_CreateEventSource(TimerSetupProc, NULL, tsdPtr);
+	Tcl_CreateEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
 	Tcl_CreateThreadExitHandler(TimerExitProc, NULL);
     }
     return tsdPtr;
@@ -289,7 +290,7 @@ TimerExitProc(
 	    TclThreadDataKeyGet(&dataKey);
 
     if (tsdPtr != NULL) {
-	Tcl_DeleteEventSource(TimerSetupProc, NULL, tsdPtr);
+	Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
 
 	while ((tsdPtr->lastPromptPtr) != NULL) {
 	    TclDeleteTimerEntry(tsdPtr->lastPromptPtr);
@@ -582,7 +583,7 @@ TclDeleteTimerEntry(
 
 static void
 TimerSetupProc(
-    ClientData data,		/* Not used. */
+    ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
     Tcl_Time blockTime, *firstTime;
@@ -590,10 +591,11 @@ TimerSetupProc(
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
-    if (((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
-	    || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)) {
+    if ( ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)
+      || ((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
+    ) {
 	/*
-	 * There is an idle handler or a pending timer event, so just poll.
+	 * There is a pending timer event or an idle handler, so just poll.
 	 */
 
 	blockTime.sec = 0;
@@ -616,11 +618,10 @@ TimerSetupProc(
 	    blockTime.sec = 0;
 	    blockTime.usec = 0;
 	}
-
+	
 	/*
-	 * If the first timer has expired, stick an event on the queue.
-	 */
-
+	* If the first timer has expired, stick an event on the queue right now.
+	*/
 	if (!tsdPtr->timerPending && blockTime.sec == 0 && blockTime.usec == 0) {
 	    TclSetTimerEventMarker();
 	    tsdPtr->timerPending = 1;
@@ -636,6 +637,67 @@ TimerSetupProc(
 /*
  *----------------------------------------------------------------------
  *
+ * TimerCheckProc --
+ *
+ *	This function is called by Tcl_DoOneEvent to check the timer event
+ *	source for events. This routine checks the first timer in the list.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May queue an event and update the maximum notifier block time.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+TimerCheckProc(
+    ClientData data,		/* Specific data. */
+    int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
+{
+    Tcl_Time blockTime, *firstTime;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
+
+    if (!(flags & TCL_TIMER_EVENTS)) {
+    	return;
+    }
+
+    if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
+
+    /* If already pending */
+    if (!tsdPtr->timerList || tsdPtr->timerPending) {
+    	return;
+    }
+
+    /*
+     * Verify the first timer on the queue.
+     */
+    Tcl_GetTime(&blockTime);
+    firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
+    blockTime.sec = firstTime->sec - blockTime.sec;
+    blockTime.usec = firstTime->usec - blockTime.usec;
+    if (blockTime.usec < 0) {
+        blockTime.sec -= 1;
+        blockTime.usec += 1000000;
+    }
+    if (blockTime.sec < 0) {
+        blockTime.sec = 0;
+        blockTime.usec = 0;
+    }
+    
+    /*
+    * If the first timer has expired, stick an event on the queue.
+    */
+    if (blockTime.sec == 0 && blockTime.usec == 0) {
+	TclSetTimerEventMarker();
+	tsdPtr->timerPending = 1;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * TclServiceTimerEvents --
  *
  *	This function is called by Tcl_ServiceEvent when a timer events should 
@@ -785,7 +847,7 @@ done:
     /* Compute the next timeout (later via TimerSetupProc using the first timer). */
     tsdPtr->timerPending = 0;
 
-    return 1; /* processing done, again later via TimerSetupProc */
+    return 1; /* processing done, again later via TimerCheckProc */
 }
 
 /*
@@ -928,7 +990,7 @@ Tcl_CancelIdleCall(
 /*
  *----------------------------------------------------------------------
  *
- * TclServiceIdle --
+ * TclServiceIdle -- , TclServiceIdleEx --
  *
  *	This function is invoked by the notifier when it becomes idle. It will
  *	invoke all idle handlers that are present at the time the call is
@@ -945,14 +1007,15 @@ Tcl_CancelIdleCall(
  */
 
 int
-TclServiceIdle(void)
+TclServiceIdleEx(
+    int flags,
+    int count)
 {
     TimerEntry *idlePtr;
     size_t currentGeneration;
-    Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    if (tsdPtr->idleList == NULL) {
+    if ((idlePtr = tsdPtr->idleList) == NULL) {
 	return 0;
     }
 
@@ -975,9 +1038,7 @@ TclServiceIdle(void)
      *	  during the call.
      */
 
-    while ((idlePtr = tsdPtr->idleList) != NULL
-	&& idlePtr->generation <= currentGeneration
-    ) {
+    while (idlePtr->generation <= currentGeneration) {
 	/* detach entry from the owner's list */
 	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
 
@@ -989,18 +1050,33 @@ TclServiceIdle(void)
 	    (*idlePtr->deleteProc)(idlePtr->clientData);
 	}
 	ckfree((char *) idlePtr);
+
+	/*
+	 * Stop processing idle if idle queue empty, count reached or other
+	 * events queued (only if not idle events only to service).
+	 */
+
+	if ( (idlePtr = tsdPtr->idleList) == NULL
+	  || !--count
+	  || ((flags & TCL_ALL_EVENTS) != TCL_IDLE_EVENTS 
+		&& TclPeekEventQueued(flags))
+	) {
+	    break;
+	}
     }
-    if (tsdPtr->idleList) {
-	blockTime.sec = 0;
-	blockTime.usec = 0;
-	Tcl_SetMaxBlockTime(&blockTime);
-    }
+
     /* Reset generation */
     if (!tsdPtr->idleList) {
     	tsdPtr->idleGeneration = 0;
     }
     return 1;
 }
+
+int
+TclServiceIdle(void)
+{
+    return TclServiceIdleEx(TCL_ALL_EVENTS, INT_MAX);
+}
 
 /*
  *----------------------------------------------------------------------
diff --git a/tests/event.test b/tests/event.test
index c905489..cf65ae17 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -694,12 +694,9 @@ test event-11.7 {Bug 16828b3744} {
 } {}
 
 
-test event-12.1 {Tcl_UpdateCmd procedure} {
-    list [catch {update a b} msg] $msg
-} {1 {wrong # args: should be "update ?option?"}}
 test event-12.2 {Tcl_UpdateCmd procedure} {
     list [catch {update bogus} msg] $msg
-} {1 {bad option "bogus": must be idletasks or noidletasks}}
+} {1 {bad option "bogus": must be idletasks, -nowait, -wait, -idle, -noidle, -timer, -notimer, -file, -nofile, -window, -nowindow, -async, or -noasync}}
 test event-12.3 {Tcl_UpdateCmd procedure} {
     foreach i [after info] {
 	after cancel $i
@@ -729,6 +726,62 @@ test event-12.4 {Tcl_UpdateCmd procedure} {
     list $x $y $z
 } {x-done before z-done}
 
+test event-12.5 {update -idle, update -noidle} {
+    foreach i [after info] {
+	after cancel $i
+    }
+    set x {}
+    after idle {lappend x idle}
+    update -noidle
+    after 0 {lappend x 0}
+    update -noidle
+    after 50 {lappend x 1}
+    update -noidle
+    lappend x 2
+    update -idle
+    lappend x 3
+    after idle {lappend x idle}
+    after 0 {lappend x 4}
+    after 0 {lappend x 5}
+    update -idle
+    lappend x 6
+    update
+    lappend x res:[vwait x 500]
+    set x
+} {0 2 idle 3 idle 6 4 5 1 res:1}
+
+test event-12.6 {update -timer, update -notimer} {
+    foreach i [after info] {
+	after cancel $i
+    }
+    set x {}
+    after idle {lappend x idle.0}
+    update -timer
+    after 0 {lappend x 0a}
+    update -notimer
+    after idle {
+    	lappend x idle.1a;
+	after 0 {lappend x 0b};
+	after idle {lappend x idle.1b}
+    }
+    after 50 {lappend x 1; after idle {lappend x idle.2}}
+    update -timer
+    lappend x 2
+    update -timer -idle
+    lappend x 3
+    after idle {lappend x idle.3}
+    after 0 {lappend x 4}
+    after 0 {lappend x 5}
+    update -timer -idle
+    lappend x 6
+    update
+    lappend x res:[vwait x 500]
+    update -noidle
+    lappend x 7
+    update
+    set x
+} {idle.0 0a 2 idle.1a 0b idle.1b 3 4 5 idle.3 6 1 res:1 7 idle.2}
+
 test event-13.1 {Tcl_WaitForFile procedure, readable} {testfilehandler} {
     foreach i [after info] {
 	after cancel $i
-- 
cgit v0.12


From 0e11ffaa99da39ffd0a3eac314a1f9f848641b83 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:24:42 +0000
Subject: interim commit: try to extend "vwait" with same options as "update"

---
 generic/tclEvent.c | 166 ++++++++++++++++++++++++++++++++++++-----------------
 tests/event.test   |  16 +++---
 2 files changed, 121 insertions(+), 61 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index d18836b..6413d10 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1298,6 +1298,61 @@ TclInThreadExit(void)
 	return tsdPtr->inExit;
     }
 }
+
+
+static int
+GetEventFlagsFromOpts(
+    Tcl_Interp *interp, 	/* Used for error reporting if not NULL. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[],	/* Arguments containing the option to lookup. */
+    int *flagsPtr)		/* Input and resulting flags. */
+{
+    int i, optionIndex, result = TCL_ERROR;
+    int flags = *flagsPtr; /* default flags */
+    static CONST char *updateOptions[] = {
+	"-idle", "-noidle",	/* new options */
+	"-timer", "-notimer",
+	"-file", "-nofile",
+	"-window", "-nowindow",
+	"-async", "-noasync",
+	"-nowait", "-wait",
+	"idletasks",  		/* backwards compat. */
+	NULL};
+    static CONST struct {
+	int mask;
+	int flags;
+    } *updateFlag, updateFlags[] = {
+	{0, TCL_IDLE_EVENTS},	{TCL_IDLE_EVENTS, 0},	/* -idle, -noidle */
+	{0, TCL_TIMER_EVENTS},	{TCL_TIMER_EVENTS, 0},	/* -timer, -notimer */
+	{0, TCL_FILE_EVENTS},	{TCL_FILE_EVENTS, 0},	/* -file, -nofile */
+	{0, TCL_WINDOW_EVENTS},	{TCL_WINDOW_EVENTS, 0},	/* -window, -nowindow */
+	{0, TCL_ASYNC_EVENTS},	{TCL_ASYNC_EVENTS, 0},	/* -async, -noasync */
+	{0, TCL_DONT_WAIT},	{TCL_DONT_WAIT, 0},	/* -nowait, -wait */
+	{TCL_ALL_EVENTS, 
+	    TCL_WINDOW_EVENTS|TCL_IDLE_EVENTS}, /* idletasks */
+	{0, 0} /* dummy / place holder */
+    };
+
+    for (i = 0; i < objc; i++) {
+	if (Tcl_GetIndexFromObj(interp, objv[i], updateOptions,
+		"option", 0, &optionIndex) != TCL_OK) {
+	    goto done;
+	}
+	updateFlag = &updateFlags[optionIndex];
+	/* pure positive option and still default, 
+	 * reset all events (only this flag) */
+	if (!updateFlag->mask && flags == *flagsPtr) {
+	    flags &= ~TCL_ALL_EVENTS;
+	}
+	flags &= ~updateFlag->mask;
+	flags |= updateFlag->flags;
+    }
+    result = TCL_OK;
+
+  done:
+    *flagsPtr = flags;
+    return result;
+}
 
 static void
 VwaitTimeOutProc(
@@ -1332,57 +1387,90 @@ Tcl_VwaitObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    int done, foundEvent, flags = TCL_ALL_EVENTS;
+    int done = 0, foundEvent;
+    int flags = TCL_ALL_EVENTS; /* default flags */
     char *nameString;
+    int opti = 1,	 /* start option index (and index of varname later) */
+    	optc = objc - 2; /* options count without cmd and varname */
     TimerEntry *timerEvent = NULL;
+    Tcl_WideInt ms = -1;
 
-    if (objc < 2 || objc > 3) {
-	Tcl_WrongNumArgs(interp, 1, objv, "name ?timeout?");
+    if (objc < 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "?options? name ?timeout?");
 	return TCL_ERROR;
     }
 
+    /* if arguments available - wrap options to flags */
+    if (objc >= 3) {
+	/* first try to recognize options up to the possible end, thereby
+	 * we assume that varname is not integer, try to get numeric timeout,
+	 * (just assume precidence of option fewer as timeout)
+	 */
+	if (Tcl_GetWideIntFromObj(NULL, objv[objc-1], &ms) == TCL_OK) {
+	    objc--;
+	    optc--;
+	}
+
+	/* now try to parse options (if available) */
+	if ( optc > 0 
+	  && GetEventFlagsFromOpts(interp, optc, objv+1, &flags) != TCL_OK
+	) {
+	    return TCL_ERROR;
+	}
+	/* opti points to varname */
+	opti += optc;
+    }
+
+    done = 0;
+
     /* if timeout specified - create timer event or no-wait by 0ms */
-    if (objc == 3) {
-    	Tcl_Time wakeup;
-    	Tcl_WideInt ms;
-    	if (Tcl_GetWideIntFromObj(interp, objv[2], &ms) != TCL_OK) {
-    	    return TCL_ERROR;
-    	}
-    	if (ms > 0) {
+    if (ms != -1) {
+	Tcl_Time wakeup;
+
+	if (ms > 0) {
 	    Tcl_GetTime(&wakeup);
 	    wakeup.sec += (long)(ms / 1000);
 	    wakeup.usec += ((long)(ms % 1000)) * 1000;
 	    if (wakeup.usec > 1000000) {
-	        wakeup.sec++;
-	        wakeup.usec -= 1000000;
+		wakeup.sec++;
+		wakeup.usec -= 1000000;
 	    }
 	    timerEvent = TclCreateAbsoluteTimerHandlerEx(&wakeup, VwaitTimeOutProc, NULL, 0);
 	    timerEvent->clientData = &done;
 	} else if (ms == 0) {
 	    flags |= TCL_DONT_WAIT;
-	} else {
-	    /* infinite vait */
-	    objc = 2;
 	}
     }
 
-    nameString = Tcl_GetString(objv[1]);
+    nameString = Tcl_GetString(objv[opti]);
     if (Tcl_TraceVar(interp, nameString,
 	    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 	    VwaitVarProc, (ClientData) &done) != TCL_OK) {
+
+	/* if timeout-timer and no timeout fired, cancel timer event */
+	if (timerEvent && done != -1) {
+	    TclDeleteTimerEntry(timerEvent);
+	}
 	return TCL_ERROR;
     };
 
-    done = 0;
     do {
 	if ((foundEvent = Tcl_DoOneEvent(flags)) == 0) {
-	    /* no wait, no error - just stop waiting (no more events) */
-	    if (flags |= TCL_DONT_WAIT) {
+	    /* 
+	     * If don't wait flag set - no error, and two cases:
+	     * option -nowait for vwait means - we don't wait for events
+	     * if no timeout (0) - just stop waiting (no more events)
+	     */
+	    if (flags & TCL_DONT_WAIT) {
 		foundEvent = 1;
+		if (ms != 0) {
+		    goto checkLimit; /* continue waiting */
+		}
 		done = -2;
 	    }
 	    break;
 	}
+      checkLimit:
 	if (Tcl_LimitExceeded(interp)) {
 	    foundEvent = -1;
 	    break;
@@ -1399,7 +1487,7 @@ Tcl_VwaitObjCmd(
     }
 
     /* if timeout specified (and no errors) */
-    if (objc == 3 && foundEvent > 0) {
+    if (ms != -1 && foundEvent > 0) {
     	Tcl_Obj *objPtr;
 
 	/* done - true, timeout false */
@@ -1468,42 +1556,14 @@ Tcl_UpdateObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    int i, optionIndex;
-    static CONST defUpdateFlags = TCL_ALL_EVENTS|TCL_DONT_WAIT;
-    int flags = defUpdateFlags;
-    static CONST char *updateOptions[] = {"idletasks",  /* backwards compat. */
-	"-nowait", "-wait",				/* new options */
-	"-idle", "-noidle", "-timer", "-notimer",	
-	"-file", "-nofile", "-window", "-nowindow",
-	"-async", "-noasync",
-	NULL};
-    static CONST struct {
-	int minus;
-	int plus;
-    } *updateFlag, updateFlags[] = {
-	{TCL_ALL_EVENTS, 
-	    TCL_WINDOW_EVENTS|TCL_IDLE_EVENTS}, /* idletasks */
-	{0, TCL_DONT_WAIT},	{TCL_DONT_WAIT, 0},	/* -nowait, -wait */
-	{0, TCL_IDLE_EVENTS},	{TCL_IDLE_EVENTS, 0},	/* -idle, -noidle */
-	{0, TCL_TIMER_EVENTS},	{TCL_TIMER_EVENTS, 0},	/* -file, -nofile */
-	{0, TCL_FILE_EVENTS},	{TCL_FILE_EVENTS, 0},	/* -file, -nofile */
-	{0, TCL_WINDOW_EVENTS},	{TCL_WINDOW_EVENTS, 0},	/* -window, -nowindow */
-	{0, TCL_ASYNC_EVENTS},	{TCL_ASYNC_EVENTS, 0},	/* -async, -noasync */
-	{0, 0} /* dummy / place holder */
-    };
+    int flags = TCL_ALL_EVENTS|TCL_DONT_WAIT; /* default flags */
 
-    for (i = 1; i < objc; i++) {
-	if (Tcl_GetIndexFromObj(interp, objv[i], updateOptions,
-		"option", 0, &optionIndex) != TCL_OK) {
+    /* if arguments available - wrap options to flags */
+    if (objc > 1) {
+	int i = 1;
+	if (GetEventFlagsFromOpts(interp, objc-1, objv+1, &flags) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	updateFlag = &updateFlags[optionIndex];
-	/* pure positive option and still default - reset all events */
-	if (flags == defUpdateFlags && !updateFlag->minus) {
-	    flags &= ~TCL_ALL_EVENTS;
-	}
-	flags &= ~updateFlag->minus;
-	flags |= updateFlag->plus;
     }
 
     while (Tcl_DoOneEvent(flags) != 0) {
diff --git a/tests/event.test b/tests/event.test
index cf65ae17..cce486a 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -488,10 +488,10 @@ test event-10.1 {Tcl_Exit procedure} {stdio} {
 
 test event-11.1 {Tcl_VwaitCmd procedure} {
     list [catch {vwait} msg] $msg
-} {1 {wrong # args: should be "vwait name ?timeout?"}}
+} {1 {wrong # args: should be "vwait ?options? name ?timeout?"}}
 test event-11.2 {Tcl_VwaitCmd procedure} {
     list [catch {vwait a b} msg] $msg
-} {1 {expected integer but got "b"}}
+} {1 {bad option "a": must be -idle, -noidle, -timer, -notimer, -file, -nofile, -window, -nowindow, -async, -noasync, -nowait, -wait, or idletasks}}
 test event-11.3 {Tcl_VwaitCmd procedure} {
     catch {unset x}
     set x 1
@@ -568,15 +568,15 @@ test event-11.4.1 {vwait with timeout} {} {
     set x {}
     # success cases:
     after 0 {lappend z 0}
-    after 20 {lappend x 1}
-    after 30 {lappend x 2}
-    after 100 {lappend x 3}
+    after 100 {lappend x 1}
+    after 100 {lappend x 2}
+    after 500 {lappend x 3}
     after 1000 {lappend x "error-too-slow"}
     vwait x 0; # no-wait
     lappend z $x; # 0 {} - (x still empty)
-    vwait x 50; # wait up-to 50ms
+    vwait x 200; # wait up-to 200ms
     lappend z $x; # 0 {} {1 2}
-    vwait x -1; # wait without timeout
+    vwait x -1; # infinite wait
     lappend z $x; # 0 {} {1 2} {1 2 3}
     foreach i [after info] {
 	after cancel $i
@@ -696,7 +696,7 @@ test event-11.7 {Bug 16828b3744} {
 
 test event-12.2 {Tcl_UpdateCmd procedure} {
     list [catch {update bogus} msg] $msg
-} {1 {bad option "bogus": must be idletasks, -nowait, -wait, -idle, -noidle, -timer, -notimer, -file, -nofile, -window, -nowindow, -async, or -noasync}}
+} {1 {bad option "bogus": must be -idle, -noidle, -timer, -notimer, -file, -nofile, -window, -nowindow, -async, -noasync, -nowait, -wait, or idletasks}}
 test event-12.3 {Tcl_UpdateCmd procedure} {
     foreach i [after info] {
 	after cancel $i
-- 
cgit v0.12


From d2d76748809298daff2f10a63b2999d559d129dd Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:24:53 +0000
Subject: [enhancement] extend "vwait" with same options as "update", new
 syntax "vwait ?options? ?timeout? varname". some small improvements and
 fixing: - Tcl_DoOneEvent can wait for block time that was set with
 Tcl_SetMaxBlockTime outside an event source traversal,   and stop waiting if
 Tcl_SetMaxBlockTime was called outside an event source (another event occurs
 and interrupt waiting loop), etc; - safer more precise pre-lookup by options
 (use TclObjIsIndexOfTable instead of simply comparison of type with
 tclIndexType); test cases extended to cover conditional "vwait" usage;

---
 generic/tclEvent.c    | 90 +++++++++++++++++++++++++--------------------------
 generic/tclIndexObj.c | 37 +++++++++++++++++++++
 generic/tclInt.h      |  6 ++++
 generic/tclNotify.c   | 54 +++++++++++++++----------------
 generic/tclTimer.c    |  2 +-
 tests/event.test      | 51 ++++++++++++++++++++---------
 6 files changed, 151 insertions(+), 89 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 6413d10..84e4637 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1300,6 +1300,17 @@ TclInThreadExit(void)
 }
 
 
+static CONST char *updateEventOptions[] = {
+	"-idle", "-noidle",	/* new options */
+	"-timer", "-notimer",
+	"-file", "-nofile",
+	"-window", "-nowindow",
+	"-async", "-noasync",
+	"-nowait", "-wait",
+	"idletasks",  		/* backwards compat. */
+	NULL
+};
+
 static int
 GetEventFlagsFromOpts(
     Tcl_Interp *interp, 	/* Used for error reporting if not NULL. */
@@ -1309,15 +1320,6 @@ GetEventFlagsFromOpts(
 {
     int i, optionIndex, result = TCL_ERROR;
     int flags = *flagsPtr; /* default flags */
-    static CONST char *updateOptions[] = {
-	"-idle", "-noidle",	/* new options */
-	"-timer", "-notimer",
-	"-file", "-nofile",
-	"-window", "-nowindow",
-	"-async", "-noasync",
-	"-nowait", "-wait",
-	"idletasks",  		/* backwards compat. */
-	NULL};
     static CONST struct {
 	int mask;
 	int flags;
@@ -1334,7 +1336,7 @@ GetEventFlagsFromOpts(
     };
 
     for (i = 0; i < objc; i++) {
-	if (Tcl_GetIndexFromObj(interp, objv[i], updateOptions,
+	if (Tcl_GetIndexFromObj(interp, objv[i], updateEventOptions,
 		"option", 0, &optionIndex) != TCL_OK) {
 	    goto done;
 	}
@@ -1354,14 +1356,6 @@ GetEventFlagsFromOpts(
     return result;
 }
 
-static void
-VwaitTimeOutProc(
-    ClientData clientData)
-{
-    int *donePtr = (int *) clientData;
-
-    *donePtr = -1;
-}
 /*
  *----------------------------------------------------------------------
  *
@@ -1387,27 +1381,26 @@ Tcl_VwaitObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    int done = 0, foundEvent;
+    int done = 0, foundEvent = 1;
     int flags = TCL_ALL_EVENTS; /* default flags */
     char *nameString;
     int opti = 1,	 /* start option index (and index of varname later) */
     	optc = objc - 2; /* options count without cmd and varname */
-    TimerEntry *timerEvent = NULL;
     Tcl_WideInt ms = -1;
+    Tcl_Time wakeup;
 
     if (objc < 2) {
-	Tcl_WrongNumArgs(interp, 1, objv, "?options? name ?timeout?");
+	Tcl_WrongNumArgs(interp, 1, objv, "?options? ?timeout? name");
 	return TCL_ERROR;
     }
 
     /* if arguments available - wrap options to flags */
     if (objc >= 3) {
 	/* first try to recognize options up to the possible end, thereby
-	 * we assume that varname is not integer, try to get numeric timeout,
-	 * (just assume precidence of option fewer as timeout)
+	 * we assume that option is not an integer, try to get numeric timeout
 	 */
-	if (Tcl_GetWideIntFromObj(NULL, objv[objc-1], &ms) == TCL_OK) {
-	    objc--;
+	if (!TclObjIsIndexOfTable(objv[optc], updateEventOptions)
+	  && Tcl_GetWideIntFromObj(NULL, objv[optc], &ms) == TCL_OK) {
 	    optc--;
 	}
 
@@ -1417,16 +1410,12 @@ Tcl_VwaitObjCmd(
 	) {
 	    return TCL_ERROR;
 	}
-	/* opti points to varname */
-	opti += optc;
     }
 
     done = 0;
 
     /* if timeout specified - create timer event or no-wait by 0ms */
     if (ms != -1) {
-	Tcl_Time wakeup;
-
 	if (ms > 0) {
 	    Tcl_GetTime(&wakeup);
 	    wakeup.sec += (long)(ms / 1000);
@@ -1435,26 +1424,38 @@ Tcl_VwaitObjCmd(
 		wakeup.sec++;
 		wakeup.usec -= 1000000;
 	    }
-	    timerEvent = TclCreateAbsoluteTimerHandlerEx(&wakeup, VwaitTimeOutProc, NULL, 0);
-	    timerEvent->clientData = &done;
 	} else if (ms == 0) {
 	    flags |= TCL_DONT_WAIT;
 	}
     }
 
-    nameString = Tcl_GetString(objv[opti]);
+    nameString = Tcl_GetString(objv[objc-1]);
     if (Tcl_TraceVar(interp, nameString,
 	    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 	    VwaitVarProc, (ClientData) &done) != TCL_OK) {
-
-	/* if timeout-timer and no timeout fired, cancel timer event */
-	if (timerEvent && done != -1) {
-	    TclDeleteTimerEntry(timerEvent);
-	}
 	return TCL_ERROR;
     };
 
     do {
+    	/* if wait - set blocking time */
+	if (ms > 0) {
+	    Tcl_Time blockTime;
+	    Tcl_GetTime(&blockTime);
+	    blockTime.sec = wakeup.sec - blockTime.sec;
+	    blockTime.usec = wakeup.usec - blockTime.usec;
+	    if (blockTime.usec < 0) {
+		blockTime.sec -= 1;
+		blockTime.usec += 1000000;
+	    }
+	    if (  blockTime.sec < 0 
+	      || (blockTime.sec == 0 && blockTime.usec <= 0)
+	    ) {
+		/* timeout occurs */
+		done = -1;
+		break;
+	    }
+	    Tcl_SetMaxBlockTime(&blockTime);
+	}
 	if ((foundEvent = Tcl_DoOneEvent(flags)) == 0) {
 	    /* 
 	     * If don't wait flag set - no error, and two cases:
@@ -1463,14 +1464,16 @@ Tcl_VwaitObjCmd(
 	     */
 	    if (flags & TCL_DONT_WAIT) {
 		foundEvent = 1;
-		if (ms != 0) {
-		    goto checkLimit; /* continue waiting */
-		}
 		done = -2;
 	    }
+	    if (ms > 0) {
+		foundEvent = 1;
+		goto checkWait; /* continue waiting */
+	    }
 	    break;
 	}
-      checkLimit:
+      checkWait:
+	/* check interpreter limit exceeded */
 	if (Tcl_LimitExceeded(interp)) {
 	    foundEvent = -1;
 	    break;
@@ -1481,11 +1484,6 @@ Tcl_VwaitObjCmd(
 	    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 	    VwaitVarProc, (ClientData) &done);
 
-    /* if timeout-timer and no timeout fired, cancel timer event */
-    if (timerEvent && done != -1) {
-	TclDeleteTimerEntry(timerEvent);
-    }
-
     /* if timeout specified (and no errors) */
     if (ms != -1 && foundEvent > 0) {
     	Tcl_Obj *objPtr;
diff --git a/generic/tclIndexObj.c b/generic/tclIndexObj.c
index ced7bd9..4caba7a 100644
--- a/generic/tclIndexObj.c
+++ b/generic/tclIndexObj.c
@@ -63,6 +63,43 @@ typedef struct {
 /*
  *----------------------------------------------------------------------
  *
+ * TclObjIsIndexOfStruct --
+ *
+ *	This function looks up an object's is a index of given table.
+ *
+ *	Used for fast lookup by dynamic options count to check for other
+ *	object types.
+ *
+ * Results:
+ *	1 if object is an option of table, otherwise 0.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+int
+TclObjIsIndexOfStruct(
+    Tcl_Obj *objPtr,		/* Object containing the string to lookup. */
+    const void *tablePtr)	/* Array of strings to compare against the
+				 * value of objPtr; last entry must be NULL
+				 * and there must not be duplicate entries. */
+{
+    IndexRep *indexRep;
+    if (objPtr->typePtr != &tclIndexType) {
+	return 0;
+    }
+    indexRep = objPtr->internalRep.twoPtrValue.ptr1;
+
+    if (indexRep->tablePtr != (void *) tablePtr) {
+	return 0;
+    }
+    return 1;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_GetIndexFromObj --
  *
  *	This function looks up an object's value in a table of strings and
diff --git a/generic/tclInt.h b/generic/tclInt.h
index dd73eac..42223e4 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2561,6 +2561,12 @@ MODULE_SCOPE char	tclEmptyString;
  *----------------------------------------------------------------
  */
 
+MODULE_SCOPE int	TclObjIsIndexOfStruct(Tcl_Obj *objPtr,
+			    const void *tablePtr);
+#define TclObjIsIndexOfTable(objPtr, tablePtr) \
+	((objPtr->typePtr == &tclIndexType) \
+		&& TclObjIsIndexOfStruct(objPtr, tablePtr))
+
 MODULE_SCOPE void	TclAppendBytesToByteArray(Tcl_Obj *objPtr,
 			    const unsigned char *bytes, int len);
 MODULE_SCOPE void       TclAdvanceContinuations(int* line, int** next, int loc);
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index f13fca3..fb251b7 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -989,14 +989,18 @@ Tcl_SetMaxBlockTime(
  * Results:
  *	The return value is 1 if the function actually found an event to
  *	process. If no processing occurred, then 0 is returned (this can
- *	happen if the TCL_DONT_WAIT flag is set or if there are no event
- *	handlers to wait for in the set specified by flags).
+ *	happen if the TCL_DONT_WAIT flag is set or block time was set using
+ *	Tcl_SetMaxBlockTime before or if there are no event handlers to wait
+ *	for in the set specified by flags).
  *
  * Side effects:
  *	May delay execution of process while waiting for an event, unless
  *	TCL_DONT_WAIT is set in the flags argument. Event sources are invoked
  *	to check for and queue events. Event handlers may produce arbitrary
  *	side effects.
+ *	If block time was set (Tcl_SetMaxBlockTime) but another event occurs
+ *	and interrupt wait, the function can return early, thereby it resets
+ *	the block time (caller should use Tcl_SetMaxBlockTime again).
  *
  *----------------------------------------------------------------------
  */
@@ -1013,6 +1017,7 @@ Tcl_DoOneEvent(
     EventSource *sourcePtr;
     Tcl_Time *timePtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    int stopWait;
 
     /*
      * No event flags is equivalent to TCL_ALL_EVENTS.
@@ -1022,20 +1027,26 @@ Tcl_DoOneEvent(
 	flags |= TCL_ALL_EVENTS;
     }
 
+    /* Block time was set outside an event source traversal or no wait */
+    stopWait = tsdPtr->blockTimeSet || (flags & TCL_DONT_WAIT);
+
     /*
      * Asynchronous event handlers are considered to be the highest priority
      * events, and so must be invoked before we process events on the event
      * queue.
      */
 
-    if ((flags & TCL_ASYNC_EVENTS) && Tcl_AsyncReady()) {
-	(void) Tcl_AsyncInvoke(NULL, 0);
-	return 1;
-    }
+    if (flags & TCL_ASYNC_EVENTS) {
+	if (Tcl_AsyncReady()) {
+	    (void) Tcl_AsyncInvoke(NULL, 0);
+	    return 1;
+	}
 
-    /* Async only */
-    if ((flags & TCL_ALL_EVENTS) == TCL_ASYNC_EVENTS) {
-	return 0;
+	/* Async only and don't wait - return */
+	if ( (flags & (TCL_ALL_EVENTS|TCL_DONT_WAIT))
+			== (TCL_ASYNC_EVENTS|TCL_DONT_WAIT) ) {
+	    return 0;
+	}
     }
 
     /*
@@ -1047,12 +1058,10 @@ Tcl_DoOneEvent(
     tsdPtr->serviceMode = TCL_SERVICE_NONE;
 
     /*
-     * The core of this function is an infinite loop, even though we only
-     * service one event. The reason for this is that we may be processing
-     * events that don't do anything inside of Tcl.
+     * Main loop until servicing exact one event or block time resp. 
+     * TCL_DONT_WAIT specified (infinite loop if stopWait = 0).
      */
-
-    while (1) {
+    do {
 	/*
 	 * If idle events are the only things to service, skip the main part
 	 * of the loop and go directly to handle idle events (i.e. don't wait
@@ -1060,7 +1069,6 @@ Tcl_DoOneEvent(
 	 */
 
 	if ((flags & TCL_ALL_EVENTS) == TCL_IDLE_EVENTS) {
-	    flags |= TCL_DONT_WAIT;
 	    goto idleEvents;
 	}
 
@@ -1096,8 +1104,6 @@ Tcl_DoOneEvent(
 	    tsdPtr->blockTimeSet = 1;
 	    timePtr = &tsdPtr->blockTime;
 	    goto wait; /* for notifier resp. system events */
-	} else {
-	    tsdPtr->blockTimeSet = 0;
 	}
 
 	/*
@@ -1164,9 +1170,6 @@ Tcl_DoOneEvent(
 		break;
 	    }
 	}
-	if (flags & TCL_DONT_WAIT) {
-	    break;
-	}
 
 	/*
 	 * If Tcl_WaitForEvent has returned 1, indicating that one system
@@ -1176,16 +1179,13 @@ Tcl_DoOneEvent(
 	 * had the side effect of changing the variable (so the vwait can
 	 * return and unwind properly).
 	 *
-	 * NB: We will process idle events if any first, because otherwise we
-	 *     might never do the idle events if the notifier always gets
-	 *     system events.
+	 * We can stop also if block time was set outside an event source,
+	 * that means timeout was set (so exit loop also without event/result).
 	 */
 
-	if (result) {
-	    break;
-	}
-    }
+    } while (!stopWait);
 
+    tsdPtr->blockTimeSet = 0;
     tsdPtr->serviceMode = oldMode;
     return result;
 }
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 52a3073..63346a1 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -1139,7 +1139,7 @@ Tcl_AfterObjCmd(
      */
 
     index = -1;
-    if ( ( objv[1]->typePtr == &tclIndexType 
+    if ( ( TclObjIsIndexOfTable(objv[1], afterSubCmds)
 	|| Tcl_GetWideIntFromObj(NULL, objv[1], &ms) != TCL_OK
       )
       && Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0,
diff --git a/tests/event.test b/tests/event.test
index cce486a..d2dd2fc 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -488,7 +488,7 @@ test event-10.1 {Tcl_Exit procedure} {stdio} {
 
 test event-11.1 {Tcl_VwaitCmd procedure} {
     list [catch {vwait} msg] $msg
-} {1 {wrong # args: should be "vwait ?options? name ?timeout?"}}
+} {1 {wrong # args: should be "vwait ?options? ?timeout? name"}}
 test event-11.2 {Tcl_VwaitCmd procedure} {
     list [catch {vwait a b} msg] $msg
 } {1 {bad option "a": must be -idle, -noidle, -timer, -notimer, -file, -nofile, -window, -nowindow, -async, -noasync, -nowait, -wait, or idletasks}}
@@ -527,26 +527,26 @@ test event-11.4.0 {vwait - interp limit precedence} {} {
 
     # no limit in between:
     $i limit time -seconds {} -milliseconds {}
-    lappend result 2. [catch {$i eval {vwait x 0}} msg] $msg
+    lappend result 2. [catch {$i eval {vwait 0 x}} msg] $msg
 
     # limit should be exceeded: (wait infinite by -1)
     $i limit time -milliseconds 0
-    lappend result 3. [catch {$i eval {vwait x -1}} msg] $msg
+    lappend result 3. [catch {$i eval {vwait -1 x}} msg] $msg
     # limit should be exceeded (wait too long - 1000ms):
     $i limit time -milliseconds 0
-    lappend result 4. [catch {$i eval {vwait x 1000}} msg] $msg
+    lappend result 4. [catch {$i eval {vwait 1000 x}} msg] $msg
 
     set tout [clock seconds]; incr tout 10
     # wait timeout (before limit):
     $i limit time -seconds $tout
-    lappend result 5. [catch {$i eval {vwait x 0}} msg] $msg
+    lappend result 5. [catch {$i eval {vwait 0 x}} msg] $msg
     # wait timeout (before limit):
     $i limit time -seconds $tout
-    lappend result 6. [catch {$i eval {vwait x 10}} msg] $msg
+    lappend result 6. [catch {$i eval {vwait 10 x}} msg] $msg
 
     # wait successful (before limit):
     $i limit time -seconds $tout
-    lappend result 7. [catch {$i eval {after 0 {set x ""}; vwait x 10}} msg] $msg
+    lappend result 7. [catch {$i eval {after 0 {set x ""}; vwait 10 x}} msg] $msg
 
     interp delete $i
     set result
@@ -560,6 +560,27 @@ test event-11.4.0 {vwait - interp limit precedence} {} {
     7. 0 1 \
 ]
 
+test event-11.4.0 {vwait conditional with timeout (bypass timer)} {} {
+    set x {}
+    after 1000 {lappend x "error-too-slow"}
+    after 0 {lappend x 1-timer}
+    after 1 {lappend x 2-timer}
+    after idle {lappend x 3-idle}
+    vwait -async 50 x; # ignore all except async (timer also)
+    lappend x 4-async
+    vwait -idle 50 x; # ignore all except idle (timer also)
+    lappend x 5-idle
+    after idle {lappend x 6-idle}
+    vwait 100 x; # now we accept timer events
+    lappend x 7-idle
+    vwait 100 x;
+    # cleanup:
+    foreach i [after info] {
+	after cancel $i
+    }
+    set x
+} {4-async 3-idle 5-idle 1-timer 2-timer 7-idle 6-idle}
+
 test event-11.4.1 {vwait with timeout} {} {
     foreach i [after info] {
 	after cancel $i
@@ -568,15 +589,15 @@ test event-11.4.1 {vwait with timeout} {} {
     set x {}
     # success cases:
     after 0 {lappend z 0}
-    after 100 {lappend x 1}
-    after 100 {lappend x 2}
-    after 500 {lappend x 3}
+    after 50 {lappend x 1}
+    after 50 {lappend x 2}
+    after 250 {lappend x 3}
     after 1000 {lappend x "error-too-slow"}
-    vwait x 0; # no-wait
+    vwait 0 x; # no-wait
     lappend z $x; # 0 {} - (x still empty)
-    vwait x 200; # wait up-to 200ms
+    vwait 200 x; # wait up-to 200ms
     lappend z $x; # 0 {} {1 2}
-    vwait x -1; # infinite wait
+    vwait -1 x; # infinite wait
     lappend z $x; # 0 {} {1 2} {1 2 3}
     foreach i [after info] {
 	after cancel $i
@@ -746,7 +767,7 @@ test event-12.5 {update -idle, update -noidle} {
     update -idle
     lappend x 6
     update
-    lappend x res:[vwait x 500]
+    lappend x res:[vwait 500 x]
     set x
 } {0 2 idle 3 idle 6 4 5 1 res:1}
 
@@ -775,7 +796,7 @@ test event-12.6 {update -timer, update -notimer} {
     update -timer -idle
     lappend x 6
     update
-    lappend x res:[vwait x 500]
+    lappend x res:[vwait 500 x]
     update -noidle
     lappend x 7
     update
-- 
cgit v0.12


From c63851a26ab53586d457dfcaf73a9afda52092ec Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:01 +0000
Subject: dynamic increase of timer resolution corresponding wait-time;
 non-blocking wait for event - if block-time set outside an event source
 traversal, use it as timeout, so can return with result 0 (no events);

---
 generic/tclEvent.c  |  38 +++----
 generic/tclInt.h    |  15 ++-
 generic/tclNotify.c |  36 +++---
 generic/tclTimer.c  |  44 ++++----
 win/tclWinNotify.c  | 317 +++++++++++++++++++++++++++++++++++++++++++++++++---
 win/tclWinTime.c    |  10 ++
 6 files changed, 386 insertions(+), 74 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 84e4637..299f1f8 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1330,8 +1330,7 @@ GetEventFlagsFromOpts(
 	{0, TCL_WINDOW_EVENTS},	{TCL_WINDOW_EVENTS, 0},	/* -window, -nowindow */
 	{0, TCL_ASYNC_EVENTS},	{TCL_ASYNC_EVENTS, 0},	/* -async, -noasync */
 	{0, TCL_DONT_WAIT},	{TCL_DONT_WAIT, 0},	/* -nowait, -wait */
-	{TCL_ALL_EVENTS, 
-	    TCL_WINDOW_EVENTS|TCL_IDLE_EVENTS}, /* idletasks */
+	{TCL_ALL_EVENTS, TCL_WINDOW_EVENTS|TCL_IDLE_EVENTS}, /* idletasks */
 	{0, 0} /* dummy / place holder */
     };
 
@@ -1381,12 +1380,12 @@ Tcl_VwaitObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    int done = 0, foundEvent = 1;
+    int done = 0, foundEvent = 1, limit = 0;
     int flags = TCL_ALL_EVENTS; /* default flags */
     char *nameString;
     int opti = 1,	 /* start option index (and index of varname later) */
     	optc = objc - 2; /* options count without cmd and varname */
-    Tcl_WideInt ms = -1;
+    double ms = -1;
     Tcl_Time wakeup;
 
     if (objc < 2) {
@@ -1400,7 +1399,7 @@ Tcl_VwaitObjCmd(
 	 * we assume that option is not an integer, try to get numeric timeout
 	 */
 	if (!TclObjIsIndexOfTable(objv[optc], updateEventOptions)
-	  && Tcl_GetWideIntFromObj(NULL, objv[optc], &ms) == TCL_OK) {
+	  && Tcl_GetDoubleFromObj(NULL, objv[optc], &ms) == TCL_OK) {
 	    optc--;
 	}
 
@@ -1418,12 +1417,7 @@ Tcl_VwaitObjCmd(
     if (ms != -1) {
 	if (ms > 0) {
 	    Tcl_GetTime(&wakeup);
-	    wakeup.sec += (long)(ms / 1000);
-	    wakeup.usec += ((long)(ms % 1000)) * 1000;
-	    if (wakeup.usec > 1000000) {
-		wakeup.sec++;
-		wakeup.usec -= 1000000;
-	    }
+	    TclTimeAddMilliseconds(&wakeup, ms);
 	} else if (ms == 0) {
 	    flags |= TCL_DONT_WAIT;
 	}
@@ -1444,7 +1438,7 @@ Tcl_VwaitObjCmd(
 	    blockTime.sec = wakeup.sec - blockTime.sec;
 	    blockTime.usec = wakeup.usec - blockTime.usec;
 	    if (blockTime.usec < 0) {
-		blockTime.sec -= 1;
+		blockTime.sec--;
 		blockTime.usec += 1000000;
 	    }
 	    if (  blockTime.sec < 0 
@@ -1459,7 +1453,7 @@ Tcl_VwaitObjCmd(
 	if ((foundEvent = Tcl_DoOneEvent(flags)) == 0) {
 	    /* 
 	     * If don't wait flag set - no error, and two cases:
-	     * option -nowait for vwait means - we don't wait for events
+	     * option -nowait for vwait means - we don't wait for events;
 	     * if no timeout (0) - just stop waiting (no more events)
 	     */
 	    if (flags & TCL_DONT_WAIT) {
@@ -1468,14 +1462,14 @@ Tcl_VwaitObjCmd(
 	    }
 	    if (ms > 0) {
 		foundEvent = 1;
-		goto checkWait; /* continue waiting */
 	    }
-	    break;
+	    /* don't stop wait - no event expected here 
+	     * (stop only on error case foundEvent < 0). */
 	}
-      checkWait:
 	/* check interpreter limit exceeded */
 	if (Tcl_LimitExceeded(interp)) {
-	    foundEvent = -1;
+	    limit = 1;
+	    foundEvent = 0;
 	    break;
 	}
     } while (!done);
@@ -1500,13 +1494,13 @@ Tcl_VwaitObjCmd(
      */
 
     Tcl_ResetResult(interp);
-    if (!foundEvent) {
-	Tcl_AppendResult(interp, "can't wait for variable \"", nameString,
-		"\": would wait forever", NULL);
+    if (limit) {
+	Tcl_AppendResult(interp, "limit exceeded", NULL);
 	return TCL_ERROR;
     }
-    if (foundEvent == -1) {
-	Tcl_AppendResult(interp, "limit exceeded", NULL);
+    if (foundEvent <= 0) {
+	Tcl_AppendResult(interp, "can't wait for variable \"", nameString,
+		"\": would wait forever", NULL);
 	return TCL_ERROR;
     }
     return TCL_OK;
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 42223e4..e7fbb01 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2870,6 +2870,19 @@ MODULE_SCOPE double	TclpWideClickInMicrosec(void);
 #endif
 MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
 
+static inline void
+TclTimeAddMilliseconds(
+    register Tcl_Time *timePtr,
+    register double ms
+) {
+    timePtr->sec += (long)(ms / 1000);
+    timePtr->usec += (((long)ms) % 1000) * 1000 + (((long)(ms*1000)) % 1000);
+    if (timePtr->usec > 1000000) {
+	timePtr->sec++;
+	timePtr->usec -= 1000000;
+    }
+}
+
 MODULE_SCOPE Tcl_Obj *	TclDisassembleByteCodeObj(Tcl_Obj *objPtr);
 MODULE_SCOPE int TclUtfCasecmp(CONST char *cs, CONST char *ct);
 
@@ -2926,7 +2939,7 @@ MODULE_SCOPE int	Tcl_ConcatObjCmd(ClientData clientData,
 MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE void	TclSetTimerEventMarker(void);
+MODULE_SCOPE void	TclSetTimerEventMarker(int head);
 MODULE_SCOPE int	TclServiceTimerEvents(void);
 MODULE_SCOPE int	TclServiceIdleEx(int flags, int count);
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index fb251b7..3c4e4de 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -770,7 +770,7 @@ timer:
 	tsdPtr->timerMarkerPtr = NULL;
 
 	result = TclServiceTimerEvents();
-	if (result <= 0) {
+	if (result < 0) {
 	    /* events processed, but marker to process still pending timers */
 	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
 	    result = 1;
@@ -865,13 +865,14 @@ TclPeekEventQueued(
  */
 
 void
-TclSetTimerEventMarker(void)
+TclSetTimerEventMarker(
+    int head)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (tsdPtr->timerMarkerPtr == NULL) {
 	/* marker to last event in the queue */
-	if (!(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
+	if (head || !(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
 	    /* marker as "now" - queue is empty, so timers events are first */
 	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
 	};
@@ -1017,7 +1018,7 @@ Tcl_DoOneEvent(
     EventSource *sourcePtr;
     Tcl_Time *timePtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-    int stopWait;
+    int blockTimeWasSet;
 
     /*
      * No event flags is equivalent to TCL_ALL_EVENTS.
@@ -1027,9 +1028,9 @@ Tcl_DoOneEvent(
 	flags |= TCL_ALL_EVENTS;
     }
 
-    /* Block time was set outside an event source traversal or no wait */
-    stopWait = tsdPtr->blockTimeSet || (flags & TCL_DONT_WAIT);
-
+    /* Block time was set outside an event source traversal, caller has specified a waittime */
+    blockTimeWasSet = tsdPtr->blockTimeSet;
+    
     /*
      * Asynchronous event handlers are considered to be the highest priority
      * events, and so must be invoked before we process events on the event
@@ -1059,7 +1060,7 @@ Tcl_DoOneEvent(
 
     /*
      * Main loop until servicing exact one event or block time resp. 
-     * TCL_DONT_WAIT specified (infinite loop if stopWait = 0).
+     * TCL_DONT_WAIT specified (infinite loop otherwise).
      */
     do {
 	/*
@@ -1133,7 +1134,9 @@ Tcl_DoOneEvent(
     wait:
 	result = Tcl_WaitForEvent(timePtr);
 	if (result < 0) {
-	    result = 0;
+	    if (blockTimeWasSet) {
+		result = 0;
+	    }
 	    break;
 	}
 
@@ -1179,13 +1182,20 @@ Tcl_DoOneEvent(
 	 * had the side effect of changing the variable (so the vwait can
 	 * return and unwind properly).
 	 *
-	 * We can stop also if block time was set outside an event source,
-	 * that means timeout was set (so exit loop also without event/result).
+	 * We can stop also if works in block to event mode (e. g. block time was
+	 * set outside an event source, that means timeout was set so exit loop
+	 * also without event/result).
 	 */
 
-    } while (!stopWait);
-
+	result = 0;
+	if (blockTimeWasSet) {
+	    break;
+	}
+    } while ( !(flags & TCL_DONT_WAIT) );
+    
+    /* Reset block time earliest at the end of event cycle */
     tsdPtr->blockTimeSet = 0;
+
     tsdPtr->serviceMode = oldMode;
     return result;
 }
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 63346a1..aa78b22 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -115,7 +115,7 @@ static Tcl_ThreadDataKey dataKey;
 
 static void		AfterCleanupProc(ClientData clientData,
 			    Tcl_Interp *interp);
-static int		AfterDelay(Tcl_Interp *interp, Tcl_WideInt ms);
+static int		AfterDelay(Tcl_Interp *interp, double ms);
 static void		AfterProc(ClientData clientData);
 static void		FreeAfterPtr(ClientData clientData);
 static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr, Tcl_Obj *objPtr);
@@ -623,7 +623,7 @@ TimerSetupProc(
 	* If the first timer has expired, stick an event on the queue right now.
 	*/
 	if (!tsdPtr->timerPending && blockTime.sec == 0 && blockTime.usec == 0) {
-	    TclSetTimerEventMarker();
+	    TclSetTimerEventMarker(0);
 	    tsdPtr->timerPending = 1;
 	}
     
@@ -690,7 +690,7 @@ TimerCheckProc(
     * If the first timer has expired, stick an event on the queue.
     */
     if (blockTime.sec == 0 && blockTime.usec == 0) {
-	TclSetTimerEventMarker();
+	TclSetTimerEventMarker(0);
 	tsdPtr->timerPending = 1;
     }
 }
@@ -709,7 +709,7 @@ TimerCheckProc(
  *	the queue. 
  *	Returns 0 if the event was not handled (no timer events).
  *	Returns -1 if pending timer events available, meaning the marker should
- *	stay on the queue.
+ *	stay on the head of queue.
  *
  * Side effects:
  *	Whatever the timer handler callback functions do.
@@ -723,6 +723,7 @@ TclServiceTimerEvents(void)
     TimerEntry *entryPtr, *nextPtr;
     Tcl_Time time;
     size_t currentGeneration, currentEpoch;
+    int prevTmrPending;
     ThreadSpecificData *tsdPtr = InitTimer();
 
 
@@ -762,8 +763,13 @@ TclServiceTimerEvents(void)
 	/* detach entry from the owner's list */
 	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
 
+	/* reset current timer pending (correct process nested wait event) */
+	prevTmrPending = tsdPtr->timerPending;
+	tsdPtr->timerPending = 0;
 	/* execute event */
 	(*entryPtr->proc)(entryPtr->clientData);
+	/* restore current timer pending */
+	tsdPtr->timerPending += prevTmrPending;
 
 	/* free it via deleteProc and ckfree */
 	if (entryPtr->deleteProc) {
@@ -775,6 +781,7 @@ TclServiceTimerEvents(void)
     /* if stil pending prompt events (new generation) - repeat event cycle as 
      * soon as possible */
     if (tsdPtr->promptList) {
+        tsdPtr->timerPending = 1;
     	return -1;
     }
 
@@ -815,8 +822,14 @@ TclServiceTimerEvents(void)
 
 	currentEpoch = tsdPtr->timerListEpoch;
 
+	/* reset current timer pending (correct process nested wait event) */
+	prevTmrPending = tsdPtr->timerPending;
+	tsdPtr->timerPending = 0;
 	/* invoke timer proc */
 	(*entryPtr->proc)(entryPtr->clientData);
+	/* restore current timer pending */
+	tsdPtr->timerPending += prevTmrPending;
+
 	/* free it via deleteProc or ckfree */
 	if (entryPtr->deleteProc) {
 	    (*entryPtr->deleteProc)(entryPtr->clientData);
@@ -836,6 +849,7 @@ done:
     /* pending timer events, so mark (queue) timer events  */
     if (tsdPtr->timerPending > 1) {
     	tsdPtr->timerPending = 1;
+
     	return -1;
     }
 
@@ -901,7 +915,7 @@ TclCreateTimerEntryEx(
 	
 	/* execute immediately: signal pending and set timer marker */
 	tsdPtr->timerPending++;
-	TclSetTimerEventMarker();
+	TclSetTimerEventMarker(0);
     } else {
     	/* idle generation */
 	entryPtr->generation = tsdPtr->idleGeneration;
@@ -1103,7 +1117,7 @@ Tcl_AfterObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    Tcl_WideInt ms;		/* Number of milliseconds to wait */
+    double ms;		/* Number of milliseconds to wait */
     AfterInfo *afterPtr;
     AfterAssocData *assocPtr;
     int length;
@@ -1140,7 +1154,7 @@ Tcl_AfterObjCmd(
 
     index = -1;
     if ( ( TclObjIsIndexOfTable(objv[1], afterSubCmds)
-	|| Tcl_GetWideIntFromObj(NULL, objv[1], &ms) != TCL_OK
+	|| Tcl_GetDoubleFromObj(NULL, objv[1], &ms) != TCL_OK
       )
       && Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0,
 				 &index) != TCL_OK
@@ -1169,12 +1183,7 @@ Tcl_AfterObjCmd(
 	if (ms) {
 	    Tcl_Time wakeup;
 	    Tcl_GetTime(&wakeup);
-	    wakeup.sec += (long)(ms / 1000);
-	    wakeup.usec += ((long)(ms % 1000)) * 1000;
-	    if (wakeup.usec > 1000000) {
-		wakeup.sec++;
-		wakeup.usec -= 1000000;
-	    }
+	    TclTimeAddMilliseconds(&wakeup, ms);
 	    entryPtr = TclCreateAbsoluteTimerHandlerEx(&wakeup, AfterProc,
 			    FreeAfterPtr, sizeof(AfterInfo));
 	} else {
@@ -1359,7 +1368,7 @@ Tcl_AfterObjCmd(
 static int
 AfterDelay(
     Tcl_Interp *interp,
-    Tcl_WideInt ms)
+    double ms)
 {
     Interp *iPtr = (Interp *) interp;
 
@@ -1367,12 +1376,7 @@ AfterDelay(
     Tcl_WideInt diff;
 
     Tcl_GetTime(&endTime);
-    endTime.sec += (long)(ms/1000);
-    endTime.usec += ((int)(ms%1000))*1000;
-    if (endTime.usec >= 1000000) {
-	endTime.sec++;
-	endTime.usec -= 1000000;
-    }
+    TclTimeAddMilliseconds(&endTime, ms);
 
     do {
 	Tcl_GetTime(&now);
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index 26aa296..f9ff5b4 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -21,6 +21,8 @@
 
 #define WM_WAKEUP	WM_USER	/* Message that is send by
 				 * Tcl_AlertNotifier. */
+
+//#define WIN_TIMER_PRECISION	15000	/* Handle of interval timer. */
 /*
  * The following static structure contains the state information for the
  * Windows implementation of the Tcl notifier. One of these structures is
@@ -396,6 +398,216 @@ NotifierProc(
 }
 
 /*
+ * Timer resolution primitives
+ */
+
+typedef int (CALLBACK* LPFN_NtQueryTimerResolution)(PULONG,PULONG,PULONG);
+typedef int (CALLBACK* LPFN_NtSetTimerResolution)(ULONG,BOOLEAN,PULONG);
+
+static LPFN_NtQueryTimerResolution NtQueryTimerResolution = NULL;
+static LPFN_NtSetTimerResolution NtSetTimerResolution = NULL;
+
+#define TMR_RES_MICROSEC (1000 / 100)
+#define TMR_RES_TOLERANCE 2.5	/* Tolerance (in percent), prevents entering
+				 * busy wait, but has fewer accuracy because
+				 * can wait a bit longer as wanted */
+
+static struct {
+    int   available;		/* Availability of timer resolution functions */
+    ULONG minRes;		/* Lowest possible resolution (in 100-ns) */
+    ULONG maxRes;		/* Highest possible resolution (in 100-ns) */
+    ULONG curRes;		/* Current resolution (in 100-ns units). */
+    ULONG resRes;		/* Resolution to be restored (delayed restore) */
+    LONG  minDelay;		/* Lowest delay by max resolution (in microsecs) */
+    LONG  maxDelay;		/* Highest delay by min resolution (in microsecs) */
+    size_t count;		/* Waiter count (used to restore the resolution) */
+    CRITICAL_SECTION cs;	/* Mutex guarding this structure. */
+} timerResolution = {
+    -1,
+    15600 * TMR_RES_MICROSEC, 500 * TMR_RES_MICROSEC, 
+    15600 * TMR_RES_MICROSEC, 0,
+    500, 15600,
+    0
+};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * InitTimerResolution --
+ *
+ *	This function initializes the timer resolution functionality.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+InitTimerResolution(void)
+{
+    if (timerResolution.available == -1) {
+    	TclpInitLock();
+    	if (timerResolution.available == -1) {
+    	    HMODULE hLib = GetModuleHandle("Ntdll");
+	    if (hLib) {
+		NtQueryTimerResolution = 
+		    (LPFN_NtQueryTimerResolution)GetProcAddress(hLib, 
+		    	"NtQueryTimerResolution");
+		NtSetTimerResolution = 
+		    (LPFN_NtSetTimerResolution)GetProcAddress(hLib, 
+		    	"NtSetTimerResolution");
+
+		if ( NtSetTimerResolution && NtQueryTimerResolution
+		  && NtQueryTimerResolution(&timerResolution.minRes,
+				&timerResolution.maxRes, &timerResolution.curRes) == 0
+		) {
+		    InitializeCriticalSection(&timerResolution.cs);
+		    timerResolution.resRes = timerResolution.curRes;
+		    timerResolution.minRes -= (timerResolution.minRes % TMR_RES_MICROSEC);
+		    timerResolution.minDelay = timerResolution.maxRes / TMR_RES_MICROSEC;
+		    timerResolution.maxDelay = timerResolution.minRes / TMR_RES_MICROSEC;
+		    if (timerResolution.maxRes <= 1000 * TMR_RES_MICROSEC) {
+		    	timerResolution.available = 1;
+		    }
+		}
+	    }
+	    if (timerResolution.available <= 0) {
+	    	/* not available, set min/max to typical values on windows */ 
+		timerResolution.minRes = 15600 * TMR_RES_MICROSEC;
+		timerResolution.maxRes = 500 * TMR_RES_MICROSEC;
+		timerResolution.minDelay = timerResolution.maxRes / TMR_RES_MICROSEC;
+		timerResolution.maxDelay = timerResolution.minRes / TMR_RES_MICROSEC;
+		timerResolution.available = 0;
+	    }
+	}
+	TclpInitUnlock();
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * SetTimerResolution --
+ *
+ *	This is called by Tcl_WaitForEvent to increase timer resolution if wait
+ *	for events with time smaller as the typical windows value (ca. 15ms).
+ *
+ * Results:
+ *	Returns previous value of timer resolution, used for restoring with
+ *	RestoreTimerResolution.
+ *
+ * Side effects:
+ *	Note that timer resolution takes affect for the whole process (accross
+ *	all threads).
+ *
+ *----------------------------------------------------------------------
+ */
+
+static unsigned long
+SetTimerResolution(
+    unsigned long newResolution,
+    unsigned long actualResolution
+) {
+    /* if available */
+    if (timerResolution.available > 0)
+    {
+	if (newResolution < timerResolution.maxRes) {
+	    newResolution = timerResolution.maxRes;
+	}
+	EnterCriticalSection(&timerResolution.cs);
+	if (!actualResolution) {
+	    timerResolution.count++;
+	    actualResolution = timerResolution.curRes;
+	}
+	if (newResolution < timerResolution.curRes) {
+	    ULONG curRes;
+	    if (NtSetTimerResolution(newResolution, TRUE, &curRes) == 0) {
+		timerResolution.curRes = curRes;
+	    }
+	}
+	LeaveCriticalSection(&timerResolution.cs);
+	return actualResolution;
+    }
+
+    /* resolution unchanged (and counter not increased) */
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * RestoreTimerResolution --
+ *
+ *	This is called by Tcl_WaitForEvent to restore timer resolution to
+ *	previous value.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Because timer resolution takes affect for the whole process, it can
+ *	remain max resolution after execution of this function (if some thread
+ *	still waits with the highest timer resolution).
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+RestoreTimerResolution(
+    unsigned long newResolution
+) {
+    /* if available */
+    if (timerResolution.available > 0 && newResolution) {
+	EnterCriticalSection(&timerResolution.cs);
+	if (timerResolution.count-- <= 1) {
+	    if (newResolution > timerResolution.resRes) {
+	    	timerResolution.resRes = newResolution;
+	    };
+	}
+	LeaveCriticalSection(&timerResolution.cs);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclWinResetTimerResolution --
+ *
+ *	This is called by CalibrationThread to delayed reset of the timer
+ *	resolution (once per second), if no more waiting workers using 
+ *	precise timer resolution.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TclWinResetTimerResolution(void)
+{
+    if ( timerResolution.available > 0
+      && timerResolution.count == 0 && timerResolution.resRes > timerResolution.curRes
+    ) {
+	EnterCriticalSection(&timerResolution.cs);
+	if (timerResolution.count == 0 && timerResolution.resRes > timerResolution.curRes) {
+	    ULONG curRes;
+	    if (NtSetTimerResolution(timerResolution.resRes, TRUE, &curRes) == 0) {
+		timerResolution.curRes = curRes;
+	    };
+	}
+	LeaveCriticalSection(&timerResolution.cs);
+    }
+}
+
+/*
  *----------------------------------------------------------------------
  *
  * Tcl_WaitForEvent --
@@ -420,8 +632,11 @@ Tcl_WaitForEvent(
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     MSG msg;
-    DWORD timeout, result;
-    int status;
+    DWORD timeout, result = WAIT_TIMEOUT;
+    int status = 0;
+    Tcl_Time waitTime = {0, 0};
+    Tcl_Time endTime;
+    unsigned long actualResolution = 0;
 
     /*
      * Allow the notifier to be hooked. This may not make sense on windows,
@@ -438,26 +653,72 @@ Tcl_WaitForEvent(
 
     if (timePtr) {
 
-	Tcl_Time myTime;
+	waitTime.sec  = timePtr->sec;
+	waitTime.usec = timePtr->usec;
 
-	/* No wait if timeout too small (because windows may wait too long) */
-	if (!timePtr->sec && timePtr->usec <= 10) {
+	/* if no wait */
+	if (waitTime.sec == 0 && waitTime.usec == 0) {
+	    result = 0;
 	    goto peek;
 	}
 
-	/*
-	 * TIP #233 (Virtualized Time). Convert virtual domain delay to
-	 * real-time.
-	 */
+	/* calculate end of wait */
+	Tcl_GetTime(&endTime);
+	endTime.sec += waitTime.sec;
+	endTime.usec += waitTime.usec;
+	if (endTime.usec > 1000000) {
+		endTime.usec -= 1000000;
+		endTime.sec++;
+	}
 
-	myTime.sec  = timePtr->sec;
-	myTime.usec = timePtr->usec;
+	/*
+	* TIP #233 (Virtualized Time). Convert virtual domain delay to
+	* real-time.
+	*/
+	(*tclScaleTimeProcPtr) (&waitTime, tclTimeClientData);
 
-	if (myTime.sec != 0 || myTime.usec != 0) {
-	    (*tclScaleTimeProcPtr) (&myTime, tclTimeClientData);
+	if (timerResolution.available == -1) {
+	    InitTimerResolution();
+	}
+	
+    repeat:
+	/* add possible tolerance in percent, so "round" to full ms (-overhead) */
+	waitTime.usec += waitTime.usec * (TMR_RES_TOLERANCE / 100);
+	/* No wait if timeout too small (because windows may wait too long) */
+	if (!waitTime.sec && waitTime.usec < (long)timerResolution.minDelay) {
+	    /* prevent busy wait */
+	    if (waitTime.usec >= 10) {
+	    	timeout = 0;
+		goto wait;
+	    }
+	    goto peek;
+	}
+	
+	if (timerResolution.available) {
+	    if (waitTime.sec || waitTime.usec > timerResolution.maxDelay) {
+	    	long usec;
+	    	timeout = waitTime.sec * 1000;
+		usec = ((timeout * 1000) + waitTime.usec) % 1000000;
+		timeout += (usec - (usec % timerResolution.maxDelay)) / 1000;
+	    } else {
+	    	/* calculate resolution up to 1000 microseconds
+	    	 * (don't use highest, because of too large CPU load) */
+		ULONG res;
+		if (waitTime.usec >= 10000) {
+		    res = 10000 * TMR_RES_MICROSEC;
+		} else {
+		    res = 1000 * TMR_RES_MICROSEC;
+		}
+		timeout = waitTime.usec / 1000;
+		/* set more precise timer resolution for minimal delay */
+		if (!actualResolution || res < timerResolution.curRes) {
+		    actualResolution = SetTimerResolution(
+			res, actualResolution);
+		}
+	    }
+	} else {
+	    timeout = waitTime.sec * 1000 + waitTime.usec / 1000;
 	}
-
-	timeout = myTime.sec * 1000 + myTime.usec / 1000;
 
     } else {
 	timeout = INFINITE;
@@ -468,7 +729,7 @@ Tcl_WaitForEvent(
      * because MsgWaitForMultipleObjects will not wake up if there are events
      * currently sitting in the queue.
      */
-
+  wait:
     if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
     	goto get;
     }
@@ -522,11 +783,31 @@ Tcl_WaitForEvent(
 	    DispatchMessage(&msg);
 	    status = 1;
 	}
-    } else {
-	status = 0;
+    }
+    else
+    if (result == WAIT_TIMEOUT && timeout != INFINITE) {
+	/* Check the wait should be repeated, and correct time for wait */
+	Tcl_Time now;
+
+	Tcl_GetTime(&now);
+	waitTime.sec = (endTime.sec - now.sec);
+	if ((waitTime.usec = (endTime.usec - now.usec)) < 0) {
+	    waitTime.usec += 1000000;
+	    waitTime.sec--;
+	}
+	if (waitTime.sec < 0 || !waitTime.sec && waitTime.usec <= 0) {
+	    goto end;
+	}
+	/* Repeat wait with more precise timer resolution (or using sleep) */
+	goto repeat;
     }
 
   end:
+
+    /* restore timer resolution */
+    if (actualResolution) {
+	RestoreTimerResolution(actualResolution); 
+    }
     return status;
 }
 
diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index 93f62b8..def4548 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -731,6 +731,11 @@ StopCalibration(
     WaitForSingleObject(timeInfo.calibrationThread, 100);
     CloseHandle(timeInfo.exitEvent);
     CloseHandle(timeInfo.calibrationThread);
+
+    /*
+     * Reset timer resolution (shutdown case)
+     */
+    (void)TclWinResetTimerResolution();
 }
 
 /*
@@ -1111,6 +1116,11 @@ CalibrationThread(
 	    break;
 	}
 	UpdateTimeEachSecond();
+
+	/*
+	* Reset timer resolution if expected (check waiter count once per second)
+	*/
+	(void)TclWinResetTimerResolution();
     }
 
     /* lint */
-- 
cgit v0.12


From f8149b6c94e868c891f7116ba4a18bd43aa62718 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:11 +0000
Subject: optimization of Tcl_LimitExceeded by internal usage (tclInt header)

---
 generic/tclInt.h    | 8 ++++++++
 generic/tclInterp.c | 2 ++
 2 files changed, 10 insertions(+)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index e7fbb01..ba15f95 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -4070,6 +4070,14 @@ MODULE_SCOPE void	TclBNInitBignumFromWideUInt(mp_int *bignum,
 
 #define TclLimitExceeded(limit) ((limit).exceeded != 0)
 
+static inline int
+TclInlLimitExceeded(
+    register Tcl_Interp *interp)
+{
+    return (((Interp *)interp)->limit.exceeded != 0);
+}
+#define Tcl_LimitExceeded(interp) TclInlLimitExceeded(interp)
+
 #define TclLimitReady(limit)						\
     (((limit).active == 0) ? 0 :					\
     (++(limit).granularityTicker,					\
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index 50537de..5f1b958 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -3042,6 +3042,8 @@ Tcl_MakeSafe(
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_LimitExceeded
+ 
 int
 Tcl_LimitExceeded(
     Tcl_Interp *interp)
-- 
cgit v0.12


From fdc24c5c31c074dce2539aad1c9cc7facb565099 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:20 +0000
Subject: Use auto-reset event object (system automatically resets the event
 state to nonsignaled after wake-up), avoids unwanted reset if wake-up for
 some other reasons (timeout/aio/message).

---
 win/tclWinNotify.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index f9ff5b4..d9d0f5d 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -118,7 +118,7 @@ Tcl_InitNotifier(void)
 
     tsdPtr->hwnd = NULL;
     tsdPtr->thread = GetCurrentThreadId();
-    tsdPtr->event = CreateEvent(NULL, TRUE /* manual */,
+    tsdPtr->event = CreateEvent(NULL, FALSE /* !manual */,
 	    FALSE /* !signaled */, NULL);
 
     return (ClientData) tsdPtr;
@@ -746,7 +746,6 @@ Tcl_WaitForEvent(
     if (result == WAIT_IO_COMPLETION) {
 	goto again;
     }
-    ResetEvent(tsdPtr->event);
     if (result == WAIT_FAILED) {
 	status = -1;
 	goto end;
-- 
cgit v0.12


From 1b814ecdc54b17f604790d2242e3249dbf38d068 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:25 +0000
Subject: [win32] use timer resolution handling in Tcl_Sleep also;

---
 generic/tclTimer.c | 22 ++++++++--------
 win/tclWinNotify.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 75 insertions(+), 20 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index aa78b22..f1235be 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -611,7 +611,7 @@ TimerSetupProc(
 	blockTime.sec = firstTime->sec - blockTime.sec;
 	blockTime.usec = firstTime->usec - blockTime.usec;
 	if (blockTime.usec < 0) {
-	    blockTime.sec -= 1;
+	    blockTime.sec--;
 	    blockTime.usec += 1000000;
 	}
 	if (blockTime.sec < 0) {
@@ -665,8 +665,8 @@ TimerCheckProc(
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
-    /* If already pending */
-    if (!tsdPtr->timerList || tsdPtr->timerPending) {
+    /* If already pending (or no timer-events) */
+    if (tsdPtr->timerPending || !tsdPtr->timerList) {
     	return;
     }
 
@@ -678,18 +678,14 @@ TimerCheckProc(
     blockTime.sec = firstTime->sec - blockTime.sec;
     blockTime.usec = firstTime->usec - blockTime.usec;
     if (blockTime.usec < 0) {
-        blockTime.sec -= 1;
+        blockTime.sec--;
         blockTime.usec += 1000000;
     }
-    if (blockTime.sec < 0) {
-        blockTime.sec = 0;
-        blockTime.usec = 0;
-    }
     
     /*
     * If the first timer has expired, stick an event on the queue.
     */
-    if (blockTime.sec == 0 && blockTime.usec == 0) {
+    if (blockTime.sec < 0 || blockTime.sec == 0 && blockTime.usec <= 0) {
 	TclSetTimerEventMarker(0);
 	tsdPtr->timerPending = 1;
     }
@@ -726,7 +722,6 @@ TclServiceTimerEvents(void)
     int prevTmrPending;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-
     if (!tsdPtr->timerPending) {
     	return 0; /* no timer events */
     }
@@ -1375,6 +1370,13 @@ AfterDelay(
     Tcl_Time endTime, now;
     Tcl_WideInt diff;
 
+    if (ms <= 0) {
+	/* to cause a context switch only */
+	Tcl_Sleep(0);
+	return TCL_OK;
+    }
+
+
     Tcl_GetTime(&endTime);
     TclTimeAddMilliseconds(&endTime, ms);
 
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index d9d0f5d..9c13ff2 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -671,17 +671,17 @@ Tcl_WaitForEvent(
 		endTime.sec++;
 	}
 
+	if (timerResolution.available == -1) {
+	    InitTimerResolution();
+	}
+	
+    repeat:
 	/*
 	* TIP #233 (Virtualized Time). Convert virtual domain delay to
 	* real-time.
 	*/
 	(*tclScaleTimeProcPtr) (&waitTime, tclTimeClientData);
 
-	if (timerResolution.available == -1) {
-	    InitTimerResolution();
-	}
-	
-    repeat:
 	/* add possible tolerance in percent, so "round" to full ms (-overhead) */
 	waitTime.usec += waitTime.usec * (TMR_RES_TOLERANCE / 100);
 	/* No wait if timeout too small (because windows may wait too long) */
@@ -846,6 +846,18 @@ Tcl_Sleep(
 				 * real. */
     DWORD sleepTime;		/* Time to sleep, real-time */
 
+    unsigned long actualResolution = 0;
+
+    if (ms <= 0) {
+    	/* causes context switch only */
+    	Sleep(0);
+    	return;
+    }
+
+    if (timerResolution.available == -1) {
+	InitTimerResolution();
+    }
+
     vdelay.sec  = ms / 1000;
     vdelay.usec = (ms % 1000) * 1000;
 
@@ -861,10 +873,45 @@ Tcl_Sleep(
      * TIP #233: Scale delay from virtual to real-time.
      */
 
-    (*tclScaleTimeProcPtr) (&vdelay, tclTimeClientData);
-    sleepTime = vdelay.sec * 1000 + vdelay.usec / 1000;
-
     for (;;) {
+	
+	(*tclScaleTimeProcPtr) (&vdelay, tclTimeClientData);
+
+	/* add possible tolerance in percent, so "round" to full ms (-overhead) */
+	vdelay.usec += vdelay.usec * (TMR_RES_TOLERANCE / 100);
+	/* No wait if sleep time too small (because windows may wait too long) */
+	if (!vdelay.sec && vdelay.usec < (long)timerResolution.minDelay) {
+	    sleepTime = 0;
+	    goto wait;
+	}
+
+	if (timerResolution.available) {
+	    if (vdelay.sec || vdelay.usec > timerResolution.maxDelay) {
+	    	long usec;
+	    	sleepTime = vdelay.sec * 1000;
+		usec = ((sleepTime * 1000) + vdelay.usec) % 1000000;
+		sleepTime += (usec - (usec % timerResolution.maxDelay)) / 1000;
+	    } else {
+	    	/* calculate resolution up to 1000 microseconds
+	    	 * (don't use highest, because of too large CPU load) */
+		ULONG res;
+		if (vdelay.usec >= 10000) {
+		    res = 10000 * TMR_RES_MICROSEC;
+		} else {
+		    res = 1000 * TMR_RES_MICROSEC;
+		}
+		sleepTime = vdelay.usec / 1000;
+		/* set more precise timer resolution for minimal delay */
+		if (!actualResolution || res < timerResolution.curRes) {
+		    actualResolution = SetTimerResolution(
+			res, actualResolution);
+		}
+	    }
+	} else {
+	    sleepTime = vdelay.sec * 1000 + vdelay.usec / 1000;
+	}
+
+    wait:
 	Sleep(sleepTime);
 	Tcl_GetTime(&now);
 	if (now.sec > desired.sec) {
@@ -875,9 +922,15 @@ Tcl_Sleep(
 
 	vdelay.sec  = desired.sec  - now.sec;
 	vdelay.usec = desired.usec - now.usec;
+	if (vdelay.usec < 0) {
+	    vdelay.sec--;
+	    vdelay.usec += 1000000;
+	}
+    }
 
-	(*tclScaleTimeProcPtr) (&vdelay, tclTimeClientData);
-	sleepTime = vdelay.sec * 1000 + vdelay.usec / 1000;
+    /* restore timer resolution */
+    if (actualResolution) {
+	RestoreTimerResolution(actualResolution); 
     }
 }
 
-- 
cgit v0.12


From 951cfc22688728ad9615a07682bd2406a3f0db2e Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:32 +0000
Subject: [win] fallback to replace C++ keyword "inline" with C keyword
 "__inline" Otherwise depending on the VC-version, context, include-order it
 can cause:   error C2054: expected '(' to follow 'inline'

---
 generic/tclInt.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index ba15f95..991ffc3 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -55,6 +55,16 @@
 typedef int ptrdiff_t;
 #endif
 
+/* 
+ * [MSVC] fallback to replace C++ keyword "inline" with C keyword "__inline" 
+ * Otherwise depending on the VC-version, context, include-order it can cause:
+ *  error C2054: expected '(' to follow 'inline'
+ */
+#if defined(_MSC_VER) && !defined(inline)
+#	define inline	__inline
+#endif
+
+
 /*
  * Ensure WORDS_BIGENDIAN is defined correctly:
  * Needs to happen here in addition to configure to work with fat compiles on
-- 
cgit v0.12


From eccfe47689dda049eadecf74e70346d13a6126e1 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:40 +0000
Subject: code review + better usage of the waiting tolerance (fewer CPU-greedy
 now, avoid busy-wait if the rest of wait-time too small and can be
 neglected); TMR_RES_TOLERANCE can be defined to use wait-tolerance on *nix
 platforms (currently windows only as relation resp. deviation between default
 timer resolution 15.600 in exact milliseconds, means 15600/15000 + small
 overhead); Decreasing of TMR_RES_TOLERANCE (up to 0) makes tcl more "RTS"
 resp. NRT-capable (very precise wait-intervals, but more CPU-hungry).

---
 generic/tclEvent.c | 36 +++++++++++++++++++++++-------------
 generic/tclInt.h   |  6 ++++++
 generic/tclTimer.c | 38 +++++++++++++++++++++++++++++++++++---
 win/tclWinNotify.c | 49 +++++++++++++++++++++++++++++++------------------
 4 files changed, 95 insertions(+), 34 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 299f1f8..1a5b9d5 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1380,13 +1380,13 @@ Tcl_VwaitObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    int done = 0, foundEvent = 1, limit = 0;
+    int done = 0, foundEvent = 1, limit = 0, checktime = 0;
     int flags = TCL_ALL_EVENTS; /* default flags */
     char *nameString;
-    int opti = 1,	 /* start option index (and index of varname later) */
-    	optc = objc - 2; /* options count without cmd and varname */
+    int optc = objc - 2; /* options count without cmd and varname */
     double ms = -1;
     Tcl_Time wakeup;
+    long tolerance = 0;
 
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?options? ?timeout? name");
@@ -1418,6 +1418,10 @@ Tcl_VwaitObjCmd(
 	if (ms > 0) {
 	    Tcl_GetTime(&wakeup);
 	    TclTimeAddMilliseconds(&wakeup, ms);
+	#ifdef TMR_RES_TOLERANCE
+	    tolerance = (ms < 1000 ? ms : 1000) *
+				(1000 * TMR_RES_TOLERANCE / 100);
+	#endif
 	} else if (ms == 0) {
 	    flags |= TCL_DONT_WAIT;
 	}
@@ -1441,16 +1445,20 @@ Tcl_VwaitObjCmd(
 		blockTime.sec--;
 		blockTime.usec += 1000000;
 	    }
-	    if (  blockTime.sec < 0 
-	      || (blockTime.sec == 0 && blockTime.usec <= 0)
-	    ) {
-		/* timeout occurs */
-		done = -1;
-		break;
+	    /* be sure process at least one event */
+	    if (checktime) {
+		if (  blockTime.sec < 0 
+		  || (blockTime.sec == 0 && blockTime.usec <= tolerance)
+		) {
+		    /* timeout occurs */
+		    done = -1;
+		    break;
+		}
 	    }
+	    checktime = 1;
 	    Tcl_SetMaxBlockTime(&blockTime);
 	}
-	if ((foundEvent = Tcl_DoOneEvent(flags)) == 0) {
+	if ((foundEvent = Tcl_DoOneEvent(flags)) <= 0) {
 	    /* 
 	     * If don't wait flag set - no error, and two cases:
 	     * option -nowait for vwait means - we don't wait for events;
@@ -1459,12 +1467,14 @@ Tcl_VwaitObjCmd(
 	    if (flags & TCL_DONT_WAIT) {
 		foundEvent = 1;
 		done = -2;
-	    }
-	    if (ms > 0) {
+	    } else if (ms > 0 && foundEvent == 0) {
 		foundEvent = 1;
-	    }
+	    } 
 	    /* don't stop wait - no event expected here 
 	     * (stop only on error case foundEvent < 0). */
+	    if (foundEvent < 0) {
+		done = -2;
+	    }
 	}
 	/* check interpreter limit exceeded */
 	if (Tcl_LimitExceeded(interp)) {
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 991ffc3..f13af82 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2876,6 +2876,12 @@ MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
 MODULE_SCOPE double	TclpWideClickInMicrosec(void);
 #	define		TclpWideClicksToNanoseconds(clicks) \
 				((double)(clicks) * TclpWideClickInMicrosec() * 1000)
+	/* Tolerance (in percent), prevents entering busy wait, but has fewer accuracy
+	 * because can wait a bit shorter as wanted. Currently experimental value
+	 * (4.5% equivalent to 15600 / 15000 with small overhead) */
+#     ifndef TMR_RES_TOLERANCE
+#	define TMR_RES_TOLERANCE 4.5
+#     endif
 #   endif
 #endif
 MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index f1235be..c135ffb 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -588,6 +588,7 @@ TimerSetupProc(
 {
     Tcl_Time blockTime, *firstTime;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
+    long tolerance = 0;
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
@@ -619,10 +620,15 @@ TimerSetupProc(
 	    blockTime.usec = 0;
 	}
 	
+    #ifdef TMR_RES_TOLERANCE
+	/* consider timer resolution tolerance (avoid busy wait) */
+	tolerance = ((blockTime.sec <= 0) ? blockTime.usec : 1000000) *
+				(TMR_RES_TOLERANCE / 100);
+    #endif
 	/*
 	* If the first timer has expired, stick an event on the queue right now.
 	*/
-	if (!tsdPtr->timerPending && blockTime.sec == 0 && blockTime.usec == 0) {
+	if (!tsdPtr->timerPending && blockTime.sec == 0 && blockTime.usec <= tolerance) {
 	    TclSetTimerEventMarker(0);
 	    tsdPtr->timerPending = 1;
 	}
@@ -717,7 +723,7 @@ int
 TclServiceTimerEvents(void)
 {
     TimerEntry *entryPtr, *nextPtr;
-    Tcl_Time time;
+    Tcl_Time time, entrytm;
     size_t currentGeneration, currentEpoch;
     int prevTmrPending;
     ThreadSpecificData *tsdPtr = InitTimer();
@@ -791,7 +797,16 @@ TclServiceTimerEvents(void)
     ) {
     	nextPtr = entryPtr->nextPtr;
 
-	if (TCL_TIME_BEFORE(time, TimerEntry2TimerHandler(entryPtr)->time)) {
+	entrytm = TimerEntry2TimerHandler(entryPtr)->time;
+    #ifdef TMR_RES_TOLERANCE
+	entrytm.usec -= ((entrytm.sec <= 0) ? entrytm.usec : 1000000) *
+				(TMR_RES_TOLERANCE / 100);
+	if (entrytm.usec < 0) {
+	    entrytm.usec += 1000000;
+	    entrytm.sec--;
+	}
+    #endif
+	if (TCL_TIME_BEFORE(time, entrytm)) {
 	    break;
 	}
 
@@ -1369,6 +1384,9 @@ AfterDelay(
 
     Tcl_Time endTime, now;
     Tcl_WideInt diff;
+#ifdef TMR_RES_TOLERANCE
+    long tolerance;
+#endif
 
     if (ms <= 0) {
 	/* to cause a context switch only */
@@ -1376,6 +1394,10 @@ AfterDelay(
 	return TCL_OK;
     }
 
+    /* calculate possible maximal tolerance (in usec) of original wait-time */
+#ifdef TMR_RES_TOLERANCE
+    tolerance = ((ms < 1000) ? ms : 1000) * (1000 * TMR_RES_TOLERANCE / 100);
+#endif
 
     Tcl_GetTime(&endTime);
     TclTimeAddMilliseconds(&endTime, ms);
@@ -1399,6 +1421,7 @@ AfterDelay(
 #endif
 	    if (diff > 0) {
 		Tcl_Sleep((long)diff);
+		Tcl_GetTime(&now);
 	    }
 	} else {
 	    diff = TCL_TIME_DIFF_MS(iPtr->limit.time, now);
@@ -1409,11 +1432,20 @@ AfterDelay(
 #endif
 	    if (diff > 0) {
 		Tcl_Sleep((long)diff);
+		Tcl_GetTime(&now);
 	    }
 	    if (Tcl_LimitCheck(interp) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	}
+	/* consider timer resolution tolerance (avoid busy wait) */
+    #ifdef TMR_RES_TOLERANCE
+	now.usec += tolerance;
+	if (now.usec > 1000000) {
+	    now.usec -= 1000000;
+	    now.sec++;
+	}
+    #endif
     } while (TCL_TIME_BEFORE(now, endTime));
     return TCL_OK;
 }
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index 9c13ff2..f92fe2f 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -22,7 +22,6 @@
 #define WM_WAKEUP	WM_USER	/* Message that is send by
 				 * Tcl_AlertNotifier. */
 
-//#define WIN_TIMER_PRECISION	15000	/* Handle of interval timer. */
 /*
  * The following static structure contains the state information for the
  * Windows implementation of the Tcl notifier. One of these structures is
@@ -408,9 +407,6 @@ static LPFN_NtQueryTimerResolution NtQueryTimerResolution = NULL;
 static LPFN_NtSetTimerResolution NtSetTimerResolution = NULL;
 
 #define TMR_RES_MICROSEC (1000 / 100)
-#define TMR_RES_TOLERANCE 2.5	/* Tolerance (in percent), prevents entering
-				 * busy wait, but has fewer accuracy because
-				 * can wait a bit longer as wanted */
 
 static struct {
     int   available;		/* Availability of timer resolution functions */
@@ -636,6 +632,7 @@ Tcl_WaitForEvent(
     int status = 0;
     Tcl_Time waitTime = {0, 0};
     Tcl_Time endTime;
+    long tolerance = 0;
     unsigned long actualResolution = 0;
 
     /*
@@ -657,11 +654,17 @@ Tcl_WaitForEvent(
 	waitTime.usec = timePtr->usec;
 
 	/* if no wait */
-	if (waitTime.sec == 0 && waitTime.usec == 0) {
+	if (waitTime.sec <= 0 && waitTime.usec <= 0) {
 	    result = 0;
 	    goto peek;
 	}
 
+    #ifdef TMR_RES_TOLERANCE
+	/* calculate possible maximal tolerance (in usec) of original wait-time */
+	tolerance = ((waitTime.sec <= 0) ? waitTime.usec : 1000000) *
+			(TMR_RES_TOLERANCE / 100);
+    #endif
+
 	/* calculate end of wait */
 	Tcl_GetTime(&endTime);
 	endTime.sec += waitTime.sec;
@@ -682,8 +685,6 @@ Tcl_WaitForEvent(
 	*/
 	(*tclScaleTimeProcPtr) (&waitTime, tclTimeClientData);
 
-	/* add possible tolerance in percent, so "round" to full ms (-overhead) */
-	waitTime.usec += waitTime.usec * (TMR_RES_TOLERANCE / 100);
 	/* No wait if timeout too small (because windows may wait too long) */
 	if (!waitTime.sec && waitTime.usec < (long)timerResolution.minDelay) {
 	    /* prevent busy wait */
@@ -695,14 +696,18 @@ Tcl_WaitForEvent(
 	}
 	
 	if (timerResolution.available) {
-	    if (waitTime.sec || waitTime.usec > timerResolution.maxDelay) {
-	    	long usec;
-	    	timeout = waitTime.sec * 1000;
-		usec = ((timeout * 1000) + waitTime.usec) % 1000000;
+	    if (waitTime.sec || waitTime.usec + tolerance > timerResolution.maxDelay) {
+		long usec;
+		timeout = waitTime.sec * 1000;
+		usec = (timeout * 1000) + waitTime.usec + tolerance;
+		if (usec > 1000000) {
+		    usec -= 1000000;
+		    timeout += 1000;
+		}
 		timeout += (usec - (usec % timerResolution.maxDelay)) / 1000;
 	    } else {
-	    	/* calculate resolution up to 1000 microseconds
-	    	 * (don't use highest, because of too large CPU load) */
+		/* calculate resolution up to 1000 microseconds
+		 * (don't use highest, because of too large CPU load) */
 		ULONG res;
 		if (waitTime.usec >= 10000) {
 		    res = 10000 * TMR_RES_MICROSEC;
@@ -794,7 +799,7 @@ Tcl_WaitForEvent(
 	    waitTime.usec += 1000000;
 	    waitTime.sec--;
 	}
-	if (waitTime.sec < 0 || !waitTime.sec && waitTime.usec <= 0) {
+	if (waitTime.sec < 0 || !waitTime.sec && waitTime.usec <= tolerance) {
 	    goto end;
 	}
 	/* Repeat wait with more precise timer resolution (or using sleep) */
@@ -845,7 +850,6 @@ Tcl_Sleep(
     Tcl_Time vdelay;		/* Time to sleep, for scaling virtual ->
 				 * real. */
     DWORD sleepTime;		/* Time to sleep, real-time */
-
     unsigned long actualResolution = 0;
 
     if (ms <= 0) {
@@ -865,9 +869,20 @@ Tcl_Sleep(
     desired.sec  = now.sec  + vdelay.sec;
     desired.usec = now.usec + vdelay.usec;
     if (desired.usec > 1000000) {
-	++desired.sec;
 	desired.usec -= 1000000;
+	desired.sec++;
+    }
+
+#ifdef TMR_RES_TOLERANCE
+    /* calculate possible maximal tolerance (in usec) of original wait-time */
+    if (vdelay.sec <= 0) {
+	desired.usec -= vdelay.usec * (TMR_RES_TOLERANCE / 100);
+	if (desired.usec < 0) {
+	    desired.usec += 1000000;
+	    desired.sec--;
+	}
     }
+#endif
 
     /*
      * TIP #233: Scale delay from virtual to real-time.
@@ -877,8 +892,6 @@ Tcl_Sleep(
 	
 	(*tclScaleTimeProcPtr) (&vdelay, tclTimeClientData);
 
-	/* add possible tolerance in percent, so "round" to full ms (-overhead) */
-	vdelay.usec += vdelay.usec * (TMR_RES_TOLERANCE / 100);
 	/* No wait if sleep time too small (because windows may wait too long) */
 	if (!vdelay.sec && vdelay.usec < (long)timerResolution.minDelay) {
 	    sleepTime = 0;
-- 
cgit v0.12


From 251c15c11767bc6e33809b3f13eabc1771a0ba85 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:45 +0000
Subject: resolved some warnings / fixed unix resp. x64 compilation

---
 generic/tclEvent.c  | 1 -
 generic/tclNotify.c | 2 +-
 generic/tclTimer.c  | 8 ++++----
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 1a5b9d5..186b8ae 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1562,7 +1562,6 @@ Tcl_UpdateObjCmd(
 
     /* if arguments available - wrap options to flags */
     if (objc > 1) {
-	int i = 1;
 	if (GetEventFlagsFromOpts(interp, objc-1, objv+1, &flags) != TCL_OK) {
 	    return TCL_ERROR;
 	}
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index 3c4e4de..6e67ed9 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -1014,7 +1014,7 @@ Tcl_DoOneEvent(
 				 * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or
 				 * others defined by event sources. */
 {
-    int result = 0, oldMode, i = 0;
+    int result = 0, oldMode;
     EventSource *sourcePtr;
     Tcl_Time *timePtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index c135ffb..4d26742 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -25,7 +25,7 @@ typedef struct AfterInfo {
 				 * executed. */
     Tcl_Obj *commandPtr;	/* Command to execute. */
     Tcl_Obj *selfPtr;		/* Points to the handle object (self) */
-    size_t id;			/* Integer identifier for command */
+    unsigned int id;		/* Integer identifier for command */
     struct AfterInfo *nextPtr;	/* Next in list of all "after" commands for
 				 * this interpreter. */
     struct AfterInfo *prevPtr;	/* Prev in list of all "after" commands for
@@ -77,7 +77,7 @@ typedef struct {
 				 * a new loop, so that all old handlers can be
 				 * called without calling any of the new ones
 				 * created by old ones. */
-    size_t afterId;		/* For unique identifiers of after events. */
+    unsigned int afterId;	/* For unique identifiers of after events. */
 } ThreadSpecificData;
 
 static Tcl_ThreadDataKey dataKey;
@@ -203,7 +203,7 @@ AfterObj_UpdateString(objPtr)
 	return;
     }
 
-    len = sprintf(buf, "after#%d", afterPtr->id);
+    len = sprintf(buf, "after#%u", afterPtr->id);
 
     objPtr->length = len;
     objPtr->bytes = ckalloc((size_t)++len);
@@ -691,7 +691,7 @@ TimerCheckProc(
     /*
     * If the first timer has expired, stick an event on the queue.
     */
-    if (blockTime.sec < 0 || blockTime.sec == 0 && blockTime.usec <= 0) {
+    if (blockTime.sec < 0 || (blockTime.sec == 0 && blockTime.usec <= 0)) {
 	TclSetTimerEventMarker(0);
 	tsdPtr->timerPending = 1;
     }
-- 
cgit v0.12


From b39f779d1efe91fb83782a84d75e0e6bc055a597 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:25:52 +0000
Subject: after info, after cancel: compare interpreter of the timer-events by
 direct retrieving via internal representation (ignore foreign events), test
 cases extended.

---
 generic/tclTimer.c |  4 ++--
 tests/timer.test   | 26 ++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 4d26742..df974ab 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -1273,7 +1273,7 @@ Tcl_AfterObjCmd(
 		Tcl_DecrRefCount(commandPtr);
 	    }
 	}
-	if (afterPtr != NULL) {
+	if (afterPtr != NULL && afterPtr->assocPtr->interp == interp) {
 	    TclDeleteTimerEntry(AfterInfo2TimerEntry(afterPtr));
 	}
 	break;
@@ -1338,7 +1338,7 @@ Tcl_AfterObjCmd(
 	}
 
 	afterPtr = GetAfterEvent(assocPtr, objv[2]);
-	if (afterPtr == NULL) {
+	if (afterPtr == NULL || afterPtr->assocPtr->interp != interp) {
 	    Tcl_AppendResult(interp, "event \"", TclGetString(objv[2]),
 		    "\" doesn't exist", NULL);
 	    return TCL_ERROR;
diff --git a/tests/timer.test b/tests/timer.test
index db508e5..d9679e1 100644
--- a/tests/timer.test
+++ b/tests/timer.test
@@ -326,15 +326,41 @@ set childEvent [x eval {after idle event in child}]
 test timer-6.19 {Tcl_AfterCmd, info option} {
     lsort [after info]
 } [lsort "$event1 $event2"]
+test timer-6.19.1 {Tcl_AfterCmd, info option (all events in child)} {
+    x eval {after info}
+} [list $childEvent]
 test timer-6.20 {Tcl_AfterCmd, info option} {
     list [catch {after info a b} msg] $msg
 } {1 {wrong # args: should be "after info ?id?"}}
 test timer-6.21 {Tcl_AfterCmd, info option} {
     list [catch {after info $childEvent} msg] $msg
 } "1 {event \"$childEvent\" doesn't exist}"
+test timer-6.21.1 {Tcl_AfterCmd, info option (internal representation)} {
+    list [catch {x eval [list after info $childEvent]} msg] $msg
+} {0 {{event in child} idle}}
+test timer-6.21.1 {Tcl_AfterCmd, info option (internal representation)} {
+    list [catch {x eval [list after info $childEvent]} msg] $msg
+} {0 {{event in child} idle}}
+test timer-6.21.2 {Tcl_AfterCmd, info option (search using string representation)} {
+    list [catch {x eval [list after info [string trim " $childEvent "]]} msg] $msg
+} {0 {{event in child} idle}}
 test timer-6.22 {Tcl_AfterCmd, info option} {
     list [after info $event1] [after info $event2]
 } {{{event 1} idle} {{event 2} timer}}
+test timer-6.22.1 {Tcl_AfterCmd, cancel option (internal representation)} {
+    after cancel $childEvent; # foreign event - does nothing
+    # check still available:
+    list [catch {x eval [list after info $childEvent]} msg] $msg
+} {0 {{event in child} idle}}
+test timer-6.22.2 {Tcl_AfterCmd, cancel option (search using string representation)} {
+    after cancel [string trim " $childEvent "]; # foreign event - does nothing
+    # check still available:
+    set lst [list [catch {x eval [list after info $childEvent]} msg] $msg]
+    # cancel again but in child:
+    x eval [list after cancel [string trim " $childEvent "]]
+    # check it was canceled:
+    lappend lst {*}[list [catch {x eval [list after info $childEvent]} msg] $msg]
+} [list 0 {{event in child} idle} 1 "event \"$childEvent\" doesn't exist"]
 
 after cancel $event1
 after cancel $event2
-- 
cgit v0.12


From 85e45c26583e38ad80c7d1ad6edbeab0e2db7a22 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:26:06 +0000
Subject: make timer test-case more precise and time-independent, ignores short
 tolerance (deviation by waiting); several time-independent test-cases
 optimized (wait shorter now) + some new cases to cover more situations.

---
 tests/timer.test | 257 ++++++++++++++++++++++++++-----------------------------
 1 file changed, 119 insertions(+), 138 deletions(-)

diff --git a/tests/timer.test b/tests/timer.test
index d9679e1..5a63d54 100644
--- a/tests/timer.test
+++ b/tests/timer.test
@@ -17,32 +17,48 @@ if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest
     namespace import -force ::tcltest::*
 }
+# On some platforms the short tolerance (in percent to wait-time) used to avoid
+# busy waiting, so it may cause on the fast mashines, that waiting interupts a bit
+# earlier as expected ("rounded" to this tolerance boundary).
+#
+# Following routines guarantee the timer event always occured in such cases.
+variable tolerance 5
+proc tl-after {ms args} {
+    variable tolerance
+    uplevel [list after [expr {$ms + double($ms*$tolerance/100)}] {*}$args]
+}
+proc tl-vwait {args} {
+    variable tolerance
+    set ms [lindex $args end-1]
+    set vn [lindex $args end]
+    uplevel [list vwait [expr {$ms + double($ms*$tolerance/100)}] {*}[lrange $args 0 end-2] $vn]
+}
 
-test timer-1.1 {Tcl_CreateTimerHandler procedure} {
+proc clean-up-events {} {
     foreach i [after info] {
 	after cancel $i
     }
+}
+
+test timer-1.1 {Tcl_CreateTimerHandler procedure} {
+    clean-up-events
     set x ""
     foreach i {100 200 1000 50 150} {
 	after $i lappend x $i
     }
-    after 200 set done 1
-    vwait done
+    tl-vwait 200 done
     set x
 } {50 100 150 200}
 
 test timer-2.1 {Tcl_DeleteTimerHandler procedure} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x ""
     foreach i {100 200 1000 50 150} {
 	after $i lappend x $i
     }
     after cancel lappend x 150
     after cancel lappend x 50
-    after 200 set done 1
-    vwait done
+    tl-vwait 200 done
     set x
 } {100 200}
 
@@ -59,65 +75,55 @@ test timer-3.1 {TimerHandlerEventProc procedure: event masks} {
     lappend result $x
 } {start fired}
 test timer-3.2 {TimerHandlerEventProc procedure: multiple timers} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     foreach i {200 600 1000} {
 	after $i lappend x $i
     }
-    after 200
+    tl-after 200
     set result ""
     set x ""
     update
     lappend result $x
-    after 400
+    tl-after 400
     update
     lappend result $x
-    after 400
+    tl-after 400
     update
     lappend result $x
 } {200 {200 600} {200 600 1000}}
 test timer-3.3 {TimerHandlerEventProc procedure: reentrant timer deletion} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x {}
     after 100 lappend x 100
     set i [after 300 lappend x 300]
     after 200 after cancel $i
-    after 400
+    tl-after 400
     update
     set x
 } 100
 test timer-3.4 {TimerHandlerEventProc procedure: all expired timers fire} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x {}
     after 100 lappend x a
     after 200 lappend x b
     after 300 lappend x c
-    after 300
+    tl-after 300
     vwait x
     set x
 } {a b c}
 test timer-3.5 {TimerHandlerEventProc procedure: reentrantly added timers don't fire} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x {}
-    after 100 {lappend x a; after 0 lappend x b}
-    after 100
+    after 10 {lappend x a; after 0 lappend x b}
+    after 50
     vwait x
     set x
 } a
 test timer-3.6 {TimerHandlerEventProc procedure: reentrantly added timers don't fire} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x {}
     after 100 {lappend x a; after 100 lappend x b; after 100}
-    after 100
+    tl-after 100
     vwait x
     set result $x
     vwait x
@@ -128,9 +134,7 @@ test timer-3.6 {TimerHandlerEventProc procedure: reentrantly added timers don't
 # below.
 
 test timer-4.1 {Tcl_CancelIdleCall procedure} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x before
     set y before
     set z before
@@ -142,9 +146,7 @@ test timer-4.1 {Tcl_CancelIdleCall procedure} {
     concat $x $y $z
 } {after1 before after3}
 test timer-4.2 {Tcl_CancelIdleCall procedure} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x before
     set y before
     set z before
@@ -157,9 +159,7 @@ test timer-4.2 {Tcl_CancelIdleCall procedure} {
 } {before after2 after3}
 
 test timer-5.1 {Tcl_ServiceIdle, self-rescheduling handlers} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x 1
     set y 23
     after idle {incr x; after idle {incr x; after idle {incr x}}}
@@ -181,18 +181,25 @@ test timer-6.3 {Tcl_AfterCmd procedure, basics} {
 } {1 {bad argument "gorp": must be cancel, idle, info, or an integer}}
 test timer-6.4 {Tcl_AfterCmd procedure, ms argument} {
     set x before
-    after 400 {set x after}
-    after 200
+    # cover prompt events also (immediate handling differs now):
+    after 0 {lappend x immediate}
+    lappend x before-immediate
     update
-    set y $x
-    after 400
+    lappend x after-immediate
+    after 100 {lappend x after}
+    after 10
     update
-    list $y $x
-} {before after}
+    lappend x nothing
+    after 200
+    lappend x before-after
+    update
+    lappend x after-after
+    set x
+} {before before-immediate immediate after-immediate nothing before-after after after-after}
 test timer-6.5 {Tcl_AfterCmd procedure, ms argument} {
     set x before
-    after 300 set x after
-    after 200
+    after 100 set x after
+    after 10
     update
     set y $x
     after 200
@@ -209,47 +216,39 @@ test timer-6.8 {Tcl_AfterCmd procedure, cancel option} {
     after cancel {foo bar}
 } {}
 test timer-6.9 {Tcl_AfterCmd procedure, cancel option} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x before
-    set y [after 100 set x after]
+    set y [after 10 set x after]
     after cancel $y
-    after 200
+    after 100
     update
     set x
 } {before}
 test timer-6.10 {Tcl_AfterCmd procedure, cancel option} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x before
-    after 100 set x after
+    after 10 set x after
     after cancel {set x after}
-    after 200
+    after 100
     update
     set x
 } {before}
 test timer-6.11 {Tcl_AfterCmd procedure, cancel option} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x before
-    after 100 set x after
-    set id [after 300 set x after]
+    after 10 set x after-10
+    set id [after 30 set x after-30]
     after cancel $id
-    after 200
+    after 100
     update
     set y $x
     set x cleared
-    after 200
+    after 100
     update
     list $y $x
-} {after cleared}
+} {after-10 cleared}
 test timer-6.12 {Tcl_AfterCmd procedure, cancel option} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x first
     after idle lappend x second
     after idle lappend x third
@@ -260,9 +259,7 @@ test timer-6.12 {Tcl_AfterCmd procedure, cancel option} {
     set x
 } {first third}
 test timer-6.13 {Tcl_AfterCmd procedure, cancel option, multiple arguments for command} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x first
     after idle lappend x second
     after idle lappend x third
@@ -273,21 +270,18 @@ test timer-6.13 {Tcl_AfterCmd procedure, cancel option, multiple arguments for c
     set x
 } {first third}
 test timer-6.14 {Tcl_AfterCmd procedure, cancel option, cancel during handler, used to dump core} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set id [
-	after 100 {
+	after 10 {
 	    set x done
 	    after cancel $id
+	    after idle {set y done}
 	}
     ]
-    vwait x
-} {}
+    list [tl-vwait 1000 x] [tl-vwait 100 y]
+} {1 1}
 test timer-6.15 {Tcl_AfterCmd procedure, cancel option, multiple interps} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     interp create x
     x eval {set a before; set b before; after idle {set a a-after};
 	    after idle {set b b-after}}
@@ -367,9 +361,7 @@ after cancel $event2
 interp delete x
 
 test timer-6.23 {Tcl_AfterCmd procedure, no option, script with NULL} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x "hello world"
     after 1 "set x ab\0cd"
     after 10
@@ -377,9 +369,7 @@ test timer-6.23 {Tcl_AfterCmd procedure, no option, script with NULL} {
     string length $x
 } {5}
 test timer-6.24 {Tcl_AfterCmd procedure, no option, script with NULL} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x "hello world"
     after 1 set x ab\0cd
     after 10
@@ -387,61 +377,45 @@ test timer-6.24 {Tcl_AfterCmd procedure, no option, script with NULL} {
     string length $x
 } {5}
 test timer-6.25 {Tcl_AfterCmd procedure, cancel option, script with NULL} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x "hello world"
     after 1 set x ab\0cd
     after cancel "set x ab\0ef"
     set x [llength [after info]]
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x
 } {1}
 test timer-6.26 {Tcl_AfterCmd procedure, cancel option, script with NULL} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x "hello world"
     after 1 set x ab\0cd
     after cancel set x ab\0ef
     set y [llength [after info]]
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set y
 } {1}
 test timer-6.27 {Tcl_AfterCmd procedure, idle option, script with NULL} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x "hello world"
     after idle "set x ab\0cd"
     update
     string length $x
 } {5}
 test timer-6.28 {Tcl_AfterCmd procedure, idle option, script with NULL} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x "hello world"
     after idle set x ab\0cd
     update
     string length $x
 } {5}
 test timer-6.29 {Tcl_AfterCmd procedure, info option, script with NULL} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set x "hello world"
     set id junk
     set id [after 10 set x ab\0cd]
     update
     set y [string length [lindex [lindex [after info $id] 0] 2]]
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     set y
 } {5}
 
@@ -472,8 +446,8 @@ test timer-8.1 {AfterProc procedure} {
     set x before
     proc foo {} {
 	set x untouched
-	after 100 {set x after}
-	after 200
+	after 10 {set x after}
+	after 100
 	update
 	return $x
     }
@@ -487,8 +461,8 @@ test timer-8.2 {AfterProc procedure} -setup {
     set handler [interp bgerror {}]
     interp bgerror {} [namespace which myHandler]
 } -body {
-    after 100 {error "After error"}
-    after 200
+    after 10 {error "After error"}
+    after 100
     set y $x
     update
     list $y $x
@@ -499,9 +473,7 @@ test timer-8.2 {AfterProc procedure} -setup {
 "error "After error""
     ("after" script)}}}
 test timer-8.3 {AfterProc procedure, deleting handler from itself} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     proc foo {} {
 	global x
 	set x {}
@@ -511,14 +483,13 @@ test timer-8.3 {AfterProc procedure, deleting handler from itself} {
 	after cancel foo
     }
     after idle foo
-    after 1000 {error "I shouldn't ever have executed"}
+    after 0 {error "I shouldn't ever have executed"}
     update idletasks
+    clean-up-events
     set x
 } {{{error "I shouldn't ever have executed"} timer}}
 test timer-8.4 {AfterProc procedure, deleting handler from itself} {
-    foreach i [after info] {
-	after cancel $i
-    }
+    clean-up-events
     proc foo {} {
 	global x
 	set x {}
@@ -527,15 +498,14 @@ test timer-8.4 {AfterProc procedure, deleting handler from itself} {
 	}
 	after cancel foo
     }
-    after 1000 {error "I shouldn't ever have executed"}
+    after 0 {error "I shouldn't ever have executed"}
+    after 1 {error "I also shouldn't ever have executed"}
     after idle foo
     update idletasks
-    set x
-} {{{error "I shouldn't ever have executed"} timer}}
+    lsort $x
+} [lsort {{{error "I shouldn't ever have executed"} timer} {{error "I also shouldn't ever have executed"} timer}}]
 
-foreach i [after info] {
-    after cancel $i
-}
+clean-up-events
 
 # No test for FreeAfterPtr, since it is already tested above.
 
@@ -543,23 +513,23 @@ foreach i [after info] {
 test timer-9.1 {AfterCleanupProc procedure} {
     catch {interp delete x}
     interp create x
-    x eval {after 200 {
+    x eval {after 10 {
 	lappend x after
 	puts "part 1: this message should not appear"
     }}
-    after 200 {lappend x after2}
-    x eval {after 200 {
+    after 10 {lappend x after2}
+    x eval {after 10 {
 	lappend x after3
 	puts "part 2: this message should not appear"
     }}
-    after 200 {lappend x after4}
-    x eval {after 200 {
+    after 10 {lappend x after4}
+    x eval {after 10 {
 	lappend x after5
 	puts "part 3: this message should not appear"
     }}
     interp delete x
     set x before
-    after 300
+    after 100
     update
     set x
 } {before after2 after4}
@@ -580,17 +550,16 @@ test timer-11.1 {Bug 1350291: [after] overflowing 32-bit field} \
     -body {
 	set b ok
 	set a [after 0x100000001 {set b "after fired early"}]
-	after 100 set done 1
-	vwait done
-	set b
+	list [vwait 100 b] [set b]
     } \
     -cleanup {
 	catch {after cancel $a}
     } \
-    -result ok
+    -result {0 ok}
 
 test timer-11.2 {Bug 1350293: [after] negative argument} \
     -body {
+    	clean-up-events
 	set l {}
 	after 100 {lappend l 100; set done 1}
 	after -1 {lappend l -1}
@@ -599,6 +568,18 @@ test timer-11.2 {Bug 1350293: [after] negative argument} \
     } \
     -result {-1 100}
 
+test timer-11.3 {[after] correct timer ordering (insert ahead)} \
+    -body {
+    	clean-up-events
+	after 10 {set done 1}
+	foreach l {1 0.75 0.5 0.25 0.1 0} {
+	    after $l [list lappend l "ev:$l"]
+	}
+	set l {}
+	vwait done
+	set l
+    } \
+    -result {ev:0 ev:0.1 ev:0.25 ev:0.5 ev:0.75 ev:1}
 
 # cleanup
 ::tcltest::cleanupTests
-- 
cgit v0.12


From a07a5d700e82162dc377db840df58e437da1a8f9 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:26:19 +0000
Subject: fix sporadic errors on some fast cpu/platforms (because bgerror
 executed in background and it is an idle-event, give enough time to process
 it (resp. wait until last idle event is done);

---
 tests/interp.test | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/tests/interp.test b/tests/interp.test
index 510ab4a..2649b47 100644
--- a/tests/interp.test
+++ b/tests/interp.test
@@ -3476,24 +3476,31 @@ test interp-36.7 {SlaveBgerror sets error handler of slave [1999035]} -setup {
     interp create slave
     slave alias handler handler
     slave bgerror handler
-    variable result {untouched}
+    variable result {}
     proc handler {args} {
 	variable result
-	set result [lindex $args 0]
+	lappend result [lindex $args 0]
     }
 } -body {
-    slave eval {
-	variable done {}
-	after 0 error foo
-	after 10 [list ::set [namespace which -variable done] {}]
-	vwait [namespace which -variable done]
+    # because bgerror executed in background and it is idle-event, give enough 
+    # time to process it (resp. wait until last idle event is done).
+    slave eval {; # via vwait
+	after 0 error foo-1
+	after 10 {after idle {set done {}}}
+	vwait done
+    }
+    lappend result between
+    slave eval {; # via update
+	after 1 error foo-2
+	after 10
+	update
     }
     set result
 } -cleanup {
     variable result {}
     unset result
     interp delete slave
-} -result foo
+} -result {foo-1 between foo-2}
 
 test interp-37.1 {safe interps and min() and max(): Bug 2895741} -setup {
     catch {interp delete a}
-- 
cgit v0.12


From d21bae7857c761d57f933bcc4b2256edd5fe7e11 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:27:20 +0000
Subject: added performance test-cases to cover timer-events speed resp.
 event-driven tcl-handling (cherry-picked and back-ported from tclSE-9)

---
 tests-perf/test-performance.tcl | 121 ++++++++++++++++++++++++++++++++
 tests-perf/timer-event.perf.tcl | 149 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 270 insertions(+)
 create mode 100644 tests-perf/test-performance.tcl
 create mode 100644 tests-perf/timer-event.perf.tcl

diff --git a/tests-perf/test-performance.tcl b/tests-perf/test-performance.tcl
new file mode 100644
index 0000000..b0cbb17
--- /dev/null
+++ b/tests-perf/test-performance.tcl
@@ -0,0 +1,121 @@
+# ------------------------------------------------------------------------
+#
+# test-performance.tcl --
+# 
+#  This file provides common performance tests for comparison of tcl-speed
+#  degradation or regression by switching between branches.
+#
+#  To execute test case evaluate direct corresponding file "tests-perf\*.perf.tcl".
+#
+# ------------------------------------------------------------------------
+# 
+# Copyright (c) 2014 Serg G. Brester (aka sebres)
+# 
+# See the file "license.terms" for information on usage and redistribution
+# of this file.
+# 
+
+namespace eval ::tclTestPerf {
+# warm-up interpeter compiler env, calibrate timerate measurement functionality:
+
+# if no timerate here - import from unsupported:
+if {[namespace which -command timerate] eq {}} {
+  namespace inscope ::tcl::unsupported {namespace export timerate}
+  namespace import ::tcl::unsupported::timerate
+}
+
+# if not yet calibrated:
+if {[lindex [timerate {} 10] 6] >= (10-1)} {
+  puts -nonewline "Calibration ... "; flush stdout
+  puts "done: [lrange \
+    [timerate -calibrate {}] \
+  0 1]"
+}
+
+proc {**STOP**} {args} {
+  return -code error -level 4 "**STOP** in [info level [expr {[info level]-2}]] [join $args { }]" 
+}
+
+proc _test_get_commands {lst} {
+  regsub -all {(?:^|\n)[ \t]*(\#[^\n]*|\msetup\M[^\n]*|\mcleanup\M[^\n]*)(?=\n\s*(?:[\{\#]|setup|cleanup|$))} $lst "\n{\\1}"
+}
+
+proc _test_out_total {} {
+  upvar _ _
+
+  set tcnt [llength $_(itm)]
+  if {!$tcnt} {
+    puts ""
+    return
+  }
+
+  set mintm 0x7fffffff
+  set maxtm 0
+  set nett 0
+  set wtm 0
+  set wcnt 0
+  set i 0
+  foreach tm $_(itm) {
+    if {[llength $tm] > 6} {
+      set nett [expr {$nett + [lindex $tm 6]}]
+    }
+    set wtm [expr {$wtm + [lindex $tm 0]}]
+    set wcnt [expr {$wcnt + [lindex $tm 2]}]
+    set tm [lindex $tm 0]
+    if {$tm > $maxtm} {set maxtm $tm; set maxi $i}
+    if {$tm < $mintm} {set mintm $tm; set mini $i}
+    incr i
+  }
+
+  puts [string repeat ** 40]
+  set s [format "%d cases in %.2f sec." $tcnt [expr {([clock milliseconds] - $_(starttime)) / 1000.0}]]
+  if {$nett > 0} {
+    append s [format " (%.2f nett-sec.)" [expr {$nett / 1000.0}]]
+  }
+  puts "Total $s:"
+  lset _(m) 0 [format %.6f $wtm]
+  lset _(m) 2 $wcnt
+  lset _(m) 4 [format %.3f [expr {$wcnt / (($nett ? $nett : ($tcnt * $_(reptime))) / 1000.0)}]]
+  if {[llength $_(m)] > 6} {
+    lset _(m) 6 [format %.3f $nett]
+  }
+  puts $_(m)
+  puts "Average:"
+  lset _(m) 0 [format %.6f [expr {[lindex $_(m) 0] / $tcnt}]]
+  lset _(m) 2 [expr {[lindex $_(m) 2] / $tcnt}]
+  if {[llength $_(m)] > 6} {
+    lset _(m) 6 [format %.3f [expr {[lindex $_(m) 6] / $tcnt}]]
+    lset _(m) 4 [format %.0f [expr {[lindex $_(m) 2] / [lindex $_(m) 6] * 1000}]]
+  }
+  puts $_(m)
+  puts "Min:"
+  puts [lindex $_(itm) $mini]
+  puts "Max:"
+  puts [lindex $_(itm) $maxi]
+  puts [string repeat ** 40]
+  puts ""
+}
+
+proc _test_run {reptime lst {outcmd {puts $_(r)}}} {
+  upvar _ _
+  array set _ [list itm {} reptime $reptime starttime [clock milliseconds]]
+
+  foreach _(c) [_test_get_commands $lst] {
+    puts "% [regsub -all {\n[ \t]*} $_(c) {; }]"
+    if {[regexp {^\s*\#} $_(c)]} continue
+    if {[regexp {^\s*(?:setup|cleanup)\s+} $_(c)]} {
+      puts [if 1 [lindex $_(c) 1]]
+      continue
+    }
+    if {$reptime > 1} {; #if not once:
+      set _(r) [if 1 $_(c)]
+      if {$outcmd ne {}} $outcmd
+    }
+    puts [set _(m) [timerate $_(c) $reptime]]
+    lappend _(itm) $_(m)
+    puts ""
+  }
+  _test_out_total
+}
+
+}; # end of namespace ::tclTestPerf
diff --git a/tests-perf/timer-event.perf.tcl b/tests-perf/timer-event.perf.tcl
new file mode 100644
index 0000000..fdca695
--- /dev/null
+++ b/tests-perf/timer-event.perf.tcl
@@ -0,0 +1,149 @@
+#!/usr/bin/tclsh
+
+# ------------------------------------------------------------------------
+#
+# timer-event.perf.tcl --
+# 
+#  This file provides performance tests for comparison of tcl-speed
+#  of timer events (event-driven tcl-handling).
+#
+# ------------------------------------------------------------------------
+# 
+# Copyright (c) 2014 Serg G. Brester (aka sebres)
+# 
+# See the file "license.terms" for information on usage and redistribution
+# of this file.
+# 
+
+
+if {![namespace exists ::tclTestPerf]} {
+  source [file join [file dirname [info script]] test-performance.tcl]
+}
+
+
+namespace eval ::tclTestPerf-Timer-Event {
+
+namespace path {::tclTestPerf}
+
+proc test-queue {howmuch} {
+
+  # because of extremely short measurement times by tests below, wait a little bit (warming-up),
+  # to minimize influence of the time-gradation (just for better dispersion resp. result-comparison)
+  timerate {after 0} 156
+
+  puts "*** $howmuch events ***"
+  _test_run 0 [string map [list \$howmuch $howmuch \\# \#] {
+    # update / after idle:
+    setup {puts [time {after idle {set foo bar}} $howmuch]}
+    {update; \# $howmuch idle-events}
+    # update idletasks / after idle:
+    setup {puts [time {after idle {set foo bar}} $howmuch]}
+    {update idletasks; \# $howmuch idle-events}
+
+    # update / after 0:
+    setup {puts [time {after 0 {set foo bar}} $howmuch]}
+    {update; \# $howmuch timer-events}
+    # update / after 1:
+    setup {puts [time {after 1 {set foo bar}} $howmuch]; after 1}
+    {update; \# $howmuch timer-events}
+
+    # cancel forwards "after idle" / $howmuch idle-events in queue:
+    setup {set i 0; time {set ev([incr i]) [after idle {set foo bar}]} $howmuch}
+    {set i 0; time {after cancel $ev([incr i])} $howmuch}
+    cleanup {update}
+    # cancel backwards "after idle" / $howmuch idle-events in queue:
+    setup {set i 0; time {set ev([incr i]) [after idle {set foo bar}]} $howmuch}
+    {incr i; time {after cancel $ev([incr i -1])} $howmuch}
+    cleanup {update}
+
+    # cancel forwards "after 0" / $howmuch timer-events in queue:
+    setup {set i 0; time {set ev([incr i]) [after 0 {set foo bar}]} $howmuch}
+    {set i 0; time {after cancel $ev([incr i])} $howmuch}
+    cleanup {update}
+    # cancel backwards "after 0" / $howmuch timer-events in queue:
+    setup {set i 0; time {set ev([incr i]) [after 0 {set foo bar}]} $howmuch}
+    {incr i; time {after cancel $ev([incr i -1])} $howmuch}
+    cleanup {update}
+    # end $howmuch events.
+  }]
+}
+
+proc test-exec {{reptime 1000}} {
+  _test_run $reptime {
+    # after idle + after cancel
+    {after cancel [after idle {set foo bar}]}
+    # after 0 + after cancel
+    {after cancel [after 0 {set foo bar}]}
+    # after idle + update idletasks
+    {after idle {set foo bar}; update idletasks}
+    # after idle + update
+    {after idle {set foo bar}; update}
+    # immediate: after 0 + update
+    {after 0 {set foo bar}; update}
+    # delayed: after 1 + update
+    {after 1 {set foo bar}; update}
+    # empty update:
+    {update}
+    # empty update idle tasks:
+    {update idletasks}
+  }
+}
+
+proc test-exec-new {{reptime 1000}} {
+  _test_run $reptime {
+    # conditional update pure idle only (without window):
+    {update -idle}
+    # conditional update without idle events:
+    {update -noidle}
+    # conditional update timers only:
+    {update -timer}
+    # conditional update AIO only:
+    {update -async}
+
+    # conditional vwait with zero timeout: pure idle only (without window):
+    {vwait -idle 0 x}
+    # conditional vwait with zero timeout: without idle events:
+    {vwait -noidle 0 x}
+    # conditional vwait with zero timeout: timers only:
+    {vwait -timer 0 x}
+    # conditional vwait with zero timeout: AIO only:
+    {vwait -async 0 x}
+  }
+}
+
+proc test-long {{reptime 1000}} {
+  _test_run $reptime {
+    # in-between important event by amount of idle events:
+    {time {after idle {after 30}} 10; after 1 {set important 1}; vwait important;}
+    cleanup {foreach i [after info] {after cancel $i}}
+    # in-between important event (of new generation) by amount of idle events:
+    {time {after idle {after 30}} 10; after 1 {after 0 {set important 1}}; vwait important;} 
+    cleanup {foreach i [after info] {after cancel $i}}
+  }
+}
+
+proc test {{reptime 1000}} {
+  test-exec $reptime
+  if {![catch {update -noidle}]} {
+    test-exec-new $reptime
+  }
+  test-long $reptime
+
+  puts ""
+  foreach howmuch { 10000 20000 40000 60000 } {
+    test-queue $howmuch
+  }
+
+  puts \n**OK**
+}
+
+}; # end of ::tclTestPerf-Timer-Event
+
+# ------------------------------------------------------------------------
+
+# if calling direct:
+if {[info exists ::argv0] && [file tail $::argv0] eq [file tail [info script]]} {
+  array set in {-time 500}
+  array set in $argv
+  ::tclTestPerf-Timer-Event::test $in(-time)
+}
-- 
cgit v0.12


From 86897b9570309f5109b17429741bf6ce57f69d2b Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:27:33 +0000
Subject: =?UTF-8?q?[unix]=20optimized=20Tcl=5FWaitForEvent=20similar=20to?=
 =?UTF-8?q?=20windows=20changes=20(makes=20Tcl=20for=20*nix=20more=20"RTS"?=
 =?UTF-8?q?=20resp.=20NRT-capable):=20-=20more=20precise=20waiting=20now?=
 =?UTF-8?q?=20(e.g.=20still=20microseconds=20by=20time=20up=20to=200.005?=
 =?UTF-8?q?=20ms),=20important=20since=20after/vwait=20accepting=20microse?=
 =?UTF-8?q?conds=20(double);=20-=20avoids=20too=20long=20waiting=20on=20*n?=
 =?UTF-8?q?ix=20wait/sleep=20primitives,=20e.=20g.=20by=20`timerate=20{vwa?=
 =?UTF-8?q?it=200=20a}`=20-=201.5=C2=B5s=20now=20vs.=2031.9=C2=B5s=20befor?=
 =?UTF-8?q?e;=20-=20extended=20with=20new=20internal=20function=20TclpSlee?=
 =?UTF-8?q?p=20(in=20contrast=20to=20Tcl=5FSleep=20accept=20Tcl=5FTime,=20?=
 =?UTF-8?q?so=20microseconds);?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 unix/tclUnixEvent.c |  58 ++----------
 unix/tclUnixNotfy.c | 257 ++++++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 226 insertions(+), 89 deletions(-)

diff --git a/unix/tclUnixEvent.c b/unix/tclUnixEvent.c
index e4d922d..7e75357 100644
--- a/unix/tclUnixEvent.c
+++ b/unix/tclUnixEvent.c
@@ -12,7 +12,10 @@
 #include "tclInt.h"
 #ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
 				 * in tclMacOSXNotify.c */
-
+
+/* declaration of TclpSleep() from tclUnixNotfy.c */
+void	TclpSleep(const Tcl_Time *timePtr);
+
 /*
  *----------------------------------------------------------------------
  *
@@ -33,56 +36,11 @@ void
 Tcl_Sleep(
     int ms)			/* Number of milliseconds to sleep. */
 {
-    struct timeval delay;
-    Tcl_Time before, after, vdelay;
-
-    /*
-     * The only trick here is that select appears to return early under some
-     * conditions, so we have to check to make sure that the right amount of
-     * time really has elapsed.  If it's too early, go back to sleep again.
-     */
-
-    Tcl_GetTime(&before);
-    after = before;
-    after.sec += ms/1000;
-    after.usec += (ms%1000)*1000;
-    if (after.usec > 1000000) {
-	after.usec -= 1000000;
-	after.sec += 1;
-    }
-    while (1) {
-	/*
-	 * TIP #233: Scale from virtual time to real-time for select.
-	 */
-
-	vdelay.sec  = after.sec  - before.sec;
-	vdelay.usec = after.usec - before.usec;
-
-	if (vdelay.usec < 0) {
-	    vdelay.usec += 1000000;
-	    vdelay.sec  -= 1;
-	}
-
-	if ((vdelay.sec != 0) || (vdelay.usec != 0)) {
-	    (*tclScaleTimeProcPtr) (&vdelay, tclTimeClientData);
-	}
-
-	delay.tv_sec  = vdelay.sec;
-	delay.tv_usec = vdelay.usec;
-
-	/*
-	 * Special note: must convert delay.tv_sec to int before comparing to
-	 * zero, since delay.tv_usec is unsigned on some platforms.
-	 */
+    Tcl_Time delay;
 
-	if ((((int) delay.tv_sec) < 0)
-		|| ((delay.tv_usec == 0) && (delay.tv_sec == 0))) {
-	    break;
-	}
-	(void) select(0, (SELECT_MASK *) 0, (SELECT_MASK *) 0,
-		(SELECT_MASK *) 0, &delay);
-	Tcl_GetTime(&before);
-    }
+    delay.sec = ms/1000;
+    delay.usec = (ms%1000)*1000;
+    TclpSleep(&delay);
 }
 
 #endif /* HAVE_COREFOUNDATION */
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index e7ea7a1..a5ee159 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -112,7 +112,7 @@ typedef struct ThreadSpecificData {
 				 * 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.
+    int eventReady;		/* > 0 if an event is ready to be processed.
 				 * Used as condition flag together with waitCV
 				 * above. */
 #endif /* TCL_THREADS */
@@ -492,7 +492,7 @@ Tcl_AlertNotifier(
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *) clientData;
 
     pthread_mutex_lock(&notifierMutex);
-    tsdPtr->eventReady = 1;
+    tsdPtr->eventReady++;
 #ifdef __CYGWIN__
     PostMessageW(tsdPtr->hwnd, 1024, 0, 0);
 #else /* __CYGWIN__ */
@@ -822,12 +822,107 @@ NotifierProc(
      * Process all of the runnable events.
      */
 
-    tsdPtr->eventReady = 1;
+    tsdPtr->eventReady++;
     Tcl_ServiceAll();
     return 0;
 }
 #endif /* TCL_THREADS && __CYGWIN__ */
 
+
+/* 
+ * Several minimal sleep and wait values, corresponding unix timer resolution
+ *
+ * Note: Adjusting of this values may increase NRT-capability, but also may
+ * 	 increase CPU load (resp. busy waits on brief intervals).
+ */
+
+#ifndef TCL_TMR_MIN_DELAY
+#   define TCL_TMR_MIN_DELAY 100
+#   define TCL_TMR_MIN_SLEEP 50
+#   define TCL_TMR_OVERHEAD 50
+#endif
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpSleep --
+ *
+ *	Delay execution for the specified time.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Time passes.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TclpSleep(
+    const Tcl_Time *timePtr)	/* Time to sleep. */
+{
+    struct timeval delay;
+    Tcl_Time before, after, vdelay;
+
+    /*
+     * The only trick here is that select appears to return early under some
+     * conditions, so we have to check to make sure that the right amount of
+     * time really has elapsed.  If it's too early, go back to sleep again.
+     */
+
+    Tcl_GetTime(&before);
+    after = before;
+    if (timePtr) { /* if given calculate, otherwise - 0 usec */
+
+	/*
+	 * TIP #233: Scale from virtual time to real-time for select/usleep.
+	 */
+
+	vdelay = *timePtr;
+	if ((vdelay.sec != 0) || (vdelay.usec != 0)) {
+	    tclScaleTimeProcPtr(&vdelay, tclTimeClientData);
+	}
+
+	after.sec += vdelay.sec;
+	after.usec += vdelay.usec;
+	if (after.usec > 1000000) {
+	    after.usec -= 1000000;
+	    after.sec += 1;
+	}
+    }
+    while (1) {
+	vdelay.sec  = after.sec  - before.sec;
+	vdelay.usec = after.usec - before.usec;
+
+	if (vdelay.usec < 0) {
+	    vdelay.usec += 1000000;
+	    vdelay.sec  -= 1;
+	}
+
+	delay.tv_sec  = vdelay.sec;
+	delay.tv_usec = vdelay.usec;
+
+	/*
+	 * Special note: must convert delay.tv_sec to int before comparing to
+	 * zero, since delay.tv_usec is unsigned on some platforms.
+	 */
+
+	if ((((int) delay.tv_sec) < 0)
+		|| ((delay.tv_usec == 0) && (delay.tv_sec == 0))) {
+	    break;
+	}
+
+	if (delay.tv_sec || delay.tv_usec >= TCL_TMR_MIN_DELAY) {
+	    (void) select(0, (SELECT_MASK *) 0, (SELECT_MASK *) 0,
+		(SELECT_MASK *) 0, &delay);
+	} else if (delay.tv_usec >= TCL_TMR_MIN_SLEEP) {
+	    usleep(delay.tv_usec - TCL_TMR_MIN_SLEEP);
+	}
+	Tcl_GetTime(&before);
+    }
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -851,10 +946,10 @@ Tcl_WaitForEvent(
     Tcl_Time *timePtr)		/* Maximum block time, or NULL. */
 {
     FileHandler *filePtr;
-    int mask;
-    Tcl_Time vTime;
+    int mask, canWait = 1;
+    Tcl_Time now, endTime, waitTime;
 #ifdef TCL_THREADS
-    int waitForFiles;
+    int waitForFiles = 0;
 #ifdef __CYGWIN__
     MSG msg;
 #endif /* __CYGWIN__ */
@@ -868,12 +963,16 @@ Tcl_WaitForEvent(
     struct timeval timeout, *timeoutPtr;
     int numFound;
 #endif /* TCL_THREADS */
-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    ThreadSpecificData *tsdPtr;
 
     if (tclStubs.tcl_WaitForEvent != tclOriginalNotifier.waitForEventProc) {
 	return tclStubs.tcl_WaitForEvent(timePtr);
     }
 
+    Tcl_GetTime(&now);
+
+    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
@@ -881,17 +980,22 @@ Tcl_WaitForEvent(
      */
 
     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;
+	endTime = now;
+	endTime.sec += timePtr->sec;
+	endTime.usec += timePtr->usec;
+	if (endTime.usec > 1000000) {
+	    endTime.usec -= 1000000;
+	    endTime.sec++;
+	}
+	/* 
+	 * If short wait or no wait at all, just process events already available
+	 * right now, avoid waiting too long somewhere (NRT-capability fix).
+	 */
+	if (!timePtr->sec && timePtr->usec < TCL_TMR_MIN_DELAY) {
+	    canWait = 0;
 	}
+
 #ifndef TCL_THREADS
 	timeout.tv_sec = timePtr->sec;
 	timeout.tv_usec = timePtr->usec;
@@ -921,18 +1025,12 @@ 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__ */
-	    )) {
+    /* if cannot wait (but not really necessary to wait), bypass triggering pipe */
+    if (!canWait && (!tsdPtr->numFdBits || tsdPtr->eventReady)) {
+	goto nowait;
+    }
+
+    if (!canWait) {
 	/*
 	 * Cannot emulate a polling select with a polling condition
 	 * variable. Instead, pretend to wait for files and tell the
@@ -943,7 +1041,6 @@ Tcl_WaitForEvent(
 
 	waitForFiles = 1;
 	tsdPtr->pollState = POLL_WANT;
-	timePtr = NULL;
     } else {
 	waitForFiles = (tsdPtr->numFdBits > 0);
 	tsdPtr->pollState = 0;
@@ -970,17 +1067,46 @@ Tcl_WaitForEvent(
 	}
     }
 
+  nowait:
+
     FD_ZERO(&tsdPtr->readyMasks.readable);
     FD_ZERO(&tsdPtr->readyMasks.writable);
     FD_ZERO(&tsdPtr->readyMasks.exception);
 
-    if (!tsdPtr->eventReady) {
+    while (!tsdPtr->eventReady) {
+
+	if (timePtr) {
+	    Tcl_GetTime(&now);
+	    waitTime = endTime;
+	    waitTime.sec -= now.sec;
+	    waitTime.usec -= now.usec;
+	    if (waitTime.usec < 0) {
+		waitTime.usec += 1000000;
+		waitTime.sec--;
+	    }
+	
+	    if (now.sec > endTime.sec) {
+		break; /* end of wait */
+	    }
+	    if (now.sec == endTime.sec) {
+	    	if (now.usec > endTime.usec) {
+		    break; /* end of wait */
+	    	}
+		if (now.usec > endTime.usec + TCL_TMR_OVERHEAD) {
+		    canWait = 0;
+		}
+	    }
+	}
+
 #ifdef __CYGWIN__
 	if (!PeekMessageW(&msg, NULL, 0, 0, 0)) {
 	    DWORD timeout;
 
 	    if (timePtr) {
-		timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
+		/* TIP #233: Scale from virtual time to real-time  */
+		tclScaleTimeProcPtr(&waitTime, tclTimeClientData);
+
+		timeout = waitTime.sec * 1000 + waitTime.usec / 1000;
 	    } else {
 		timeout = 0xFFFFFFFF;
 	    }
@@ -989,21 +1115,74 @@ Tcl_WaitForEvent(
 	    pthread_mutex_lock(&notifierMutex);
 	}
 #else
-	if (timePtr != NULL) {
-	    Tcl_Time now;
+	/* prevent too long waiting (NRT-capability) */
+	if ( !canWait ) {
+	    /* short sleep */
+	    TclpSleep(&waitTime);
+	    break; /* end of wait */
+	}
+	else
+	if (timePtr) {
 	    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);
+#if 1
+	    /* TIP #233: Scale from virtual time to real-time  */
+	    tclScaleTimeProcPtr(&waitTime, tclTimeClientData);
 
-	    pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex, &ptime);
+	    ptime.tv_sec = now.sec;
+	    ptime.tv_nsec = (now.usec + waitTime.usec);
+	    if (ptime.tv_nsec > 1000000) {
+		ptime.tv_nsec -= 1000000;
+		ptime.tv_sec++;
+	    }
+	    ptime.tv_nsec *= 1000; /* usec to nsec */
+#else
+	    ptime.tv_sec = endTime.sec;
+	    ptime.tv_nsec = 1000 * endTime.usec;
+#endif
+
+#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 increment a bit the waiting-time from now. [Bug 1457797]
+	     */
+	    if ( now.sec > endTime.sec 
+	     || (now.sec == endTime.sec && now.usec > endTime.usec)
+	    ) {
+		ptime.tv_sec = now.sec;
+		ptime.tv_nsec = 1000 * now.usec + 10; /* + 10 nanosecond */
+	    }
+#else
+	    /* remove overhead in nsec */
+	    if (ptime.tv_nsec < TCL_TMR_OVERHEAD * 1000) {
+	    	ptime.tv_nsec += 1000000000;
+	    	ptime.tv_sec--;
+	    }
+	    ptime.tv_nsec -= TCL_TMR_OVERHEAD * 1000;
+	    
+#endif /* __APPLE__ && __LP64__ */
+
+	    if (ptime.tv_nsec > 1000000000) {
+		ptime.tv_nsec -= 1000000000;
+		ptime.tv_sec++;
+	    }
+	    if (pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex,
+	    		&ptime) == ETIMEDOUT) {
+		continue; /* repeat wait (if not yet real timeout) */
+	    };
 	} else {
 	    pthread_cond_wait(&tsdPtr->waitCV, &notifierMutex);
 	}
 #endif /* __CYGWIN__ */
+
+	break; /* end of wait */
+    }
+    if (tsdPtr->eventReady > 0) {
+	tsdPtr->eventReady--;
     }
-    tsdPtr->eventReady = 0;
 
 #ifdef __CYGWIN__
     while (PeekMessageW(&msg, NULL, 0, 0, 0)) {
@@ -1272,7 +1451,7 @@ NotifierThreadProc(
 	    }
 
 	    if (found || (tsdPtr->pollState & POLL_DONE)) {
-		tsdPtr->eventReady = 1;
+		tsdPtr->eventReady++;
 		if (tsdPtr->onList) {
 		    /*
 		     * Remove the ThreadSpecificData structure of this thread
-- 
cgit v0.12


From 2ae514f620d54d6e84cd40faa493265aae2a91fe Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:27:47 +0000
Subject: extended performance test-cases (test-nrt-capability): covering of
 brief wait-times and other RTS-near constructs.

---
 tests-perf/timer-event.perf.tcl | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/tests-perf/timer-event.perf.tcl b/tests-perf/timer-event.perf.tcl
index fdca695..12b3320 100644
--- a/tests-perf/timer-event.perf.tcl
+++ b/tests-perf/timer-event.perf.tcl
@@ -111,6 +111,34 @@ proc test-exec-new {{reptime 1000}} {
   }
 }
 
+proc test-nrt-capability {{reptime 1000}} {
+  _test_run $reptime {
+    # comparison values:
+    {after 0 {set a 5}; update}
+    {after 0 {set a 5}; vwait a}
+
+    # conditional vwait with very brief wait-time:
+    {vwait 1 a}
+    {vwait 0.5 a}
+    {vwait 0.2 a}
+    {vwait 0.1 a}
+    {vwait 0.05 a}
+    {vwait 0.02 a}
+    {vwait 0.01 a}
+    {vwait 0.005 a}
+    {vwait 0.001 a}
+
+    # comparison of update's executing event:
+    {after idle {set a 5}; update -idle -timer}
+    {after 0 {set a 5}; update -idle -timer}
+    {after idle {set a 5}; update -idle}
+    # comparison of vwait's executing event:
+    {after idle {set a 5}; vwait -idle -timer a}
+    {after 0 {set a 5}; vwait -idle -timer a}
+    {after idle {set a 5}; vwait -idle a}
+  }
+}
+
 proc test-long {{reptime 1000}} {
   _test_run $reptime {
     # in-between important event by amount of idle events:
@@ -126,6 +154,7 @@ proc test {{reptime 1000}} {
   test-exec $reptime
   if {![catch {update -noidle}]} {
     test-exec-new $reptime
+    test-nrt-capability $reptime
   }
   test-long $reptime
 
-- 
cgit v0.12


From a82f50e67930df0328c5d0d6ddecf54c2548eced Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:28:04 +0000
Subject: bug fix: prevent setting of negative block-time by too few initial
 wait-time, that may expire immediately (for example `vwait 0.0001 test`).

---
 generic/tclEvent.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 186b8ae..05e3109 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1446,16 +1446,18 @@ Tcl_VwaitObjCmd(
 		blockTime.usec += 1000000;
 	    }
 	    /* be sure process at least one event */
-	    if (checktime) {
-		if (  blockTime.sec < 0 
-		  || (blockTime.sec == 0 && blockTime.usec <= tolerance)
-		) {
-		    /* timeout occurs */
+	    if (  blockTime.sec < 0 
+	      || (blockTime.sec == 0 && blockTime.usec <= tolerance)
+	    ) {
+		/* timeout occurs */
+		if (checktime) {
 		    done = -1;
 		    break;
 		}
+		/* expired, be sure non-negative values here */
+		blockTime.usec = blockTime.sec = 0;
+		checktime = 1;
 	    }
-	    checktime = 1;
 	    Tcl_SetMaxBlockTime(&blockTime);
 	}
 	if ((foundEvent = Tcl_DoOneEvent(flags)) <= 0) {
-- 
cgit v0.12


From fc99959a11991ca61d8713436b2a032f67559ae5 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:28:09 +0000
Subject: chanio.test: optimize several tests cases running too long (shorten
 unwanted large sleeps)

---
 tests/chanio.test | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/chanio.test b/tests/chanio.test
index 2f2540e..9346a01 100644
--- a/tests/chanio.test
+++ b/tests/chanio.test
@@ -1771,7 +1771,7 @@ test chan-io-14.9 {reuse of stdio special channels} {stdio openpipe fileevent} {
     # Added delay to give Windows time to stop the spawned process and clean
     # up its grip on the file test1. Added delete as proper test cleanup.
     # The failing tests were 18.1 and 18.2 as first re-users of file "test1".
-    after 10000
+    after 1000
     file delete $path(script)
     file delete $path(test1)
     set c
@@ -6892,17 +6892,17 @@ test chan-io-53.7 {CopyData: Flooding chan copy from pipe} {stdio openpipe fcopy
     set fcopyTestCount 0
     set f1 [open $path(pipe) w]
     chan puts $f1 {
-	# Write  10 bytes / 10 msec
+	# Write  10 bytes / 1 msec
 	proc Write {count} {
 	    chan puts -nonewline "1234567890"
 	    if {[incr count -1]} {
-	        after 10 [list Write $count]
+	        after 1 [list Write $count]
 	    } else {
 	        set ::ready 1
 	    }
 	}
 	chan configure stdout -buffering none
-	Write 345 ;# 3450 bytes ~3.45 sec
+	Write 345 ;# 3450 bytes ~0.345 sec
 	vwait ready
 	exit 0
     }
@@ -7013,11 +7013,11 @@ test chan-io-53.9 {CopyData: -size and event interaction, Bug 780533} -setup {
     chan puts $pipe {
 	chan configure stdout -translation binary -buffering line
 	chan puts stderr Waiting...
-	after 1000
+	after 100
 	foreach x {a b c} {
 	    chan puts stderr Looping...
 	    chan puts $x
-	    after 500
+	    after 50
 	}
 	proc bye args {
 	    if {[chan gets stdin line]<0} {
-- 
cgit v0.12


From 97b969c05b650e02efd46fb0db7305c847d98230 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:28:17 +0000
Subject: extended performance test-cases (test-nrt-capability): RTS-near
 sleeps with very brief sleep-time.

---
 tests-perf/timer-event.perf.tcl | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests-perf/timer-event.perf.tcl b/tests-perf/timer-event.perf.tcl
index 12b3320..a5ea8e1 100644
--- a/tests-perf/timer-event.perf.tcl
+++ b/tests-perf/timer-event.perf.tcl
@@ -86,6 +86,9 @@ proc test-exec {{reptime 1000}} {
     {update}
     # empty update idle tasks:
     {update idletasks}
+
+    # simple shortest sleep:
+    {after 0}
   }
 }
 
@@ -128,6 +131,15 @@ proc test-nrt-capability {{reptime 1000}} {
     {vwait 0.005 a}
     {vwait 0.001 a}
 
+    # NRT sleep / very brief delays (0.5 - 0.005):
+    {after 0.5}
+    {after 0.05}
+    {after 0.005}
+    # NRT sleep / very brief delays (0.1 - 0.001):
+    {after 0.1}
+    {after 0.01}
+    {after 0.001}
+
     # comparison of update's executing event:
     {after idle {set a 5}; update -idle -timer}
     {after 0 {set a 5}; update -idle -timer}
-- 
cgit v0.12


From 418300bd6d16dcb6a02fad92ce471e69ce17fc7d Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:03 +0000
Subject: interim commit: try to fix time-drift backwards (too long offset
 after calibration? something else?)...

---
 generic/tclInt.h   |   2 +-
 generic/tclTimer.c |  25 +++-
 win/tclWinTime.c   | 376 +++++++++++++++++++++++++++++++++--------------------
 3 files changed, 260 insertions(+), 143 deletions(-)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index f13af82..fad78f2 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2894,8 +2894,8 @@ TclTimeAddMilliseconds(
     timePtr->sec += (long)(ms / 1000);
     timePtr->usec += (((long)ms) % 1000) * 1000 + (((long)(ms*1000)) % 1000);
     if (timePtr->usec > 1000000) {
-	timePtr->sec++;
 	timePtr->usec -= 1000000;
+	timePtr->sec++;
     }
 }
 
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index df974ab..d9e25de 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -108,6 +108,9 @@ static Tcl_ThreadDataKey dataKey;
 #define TCL_TIME_DIFF_MS(t1, t2) \
     (1000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
 	    ((long)(t1).usec - (long)(t2).usec)/1000)
+#define TCL_TIME_DIFF_US(t1, t2) \
+    (1000000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
+	    ((long)(t1).usec - (long)(t2).usec))
 
 /*
  * Prototypes for functions referenced only in this file:
@@ -1382,8 +1385,8 @@ AfterDelay(
 {
     Interp *iPtr = (Interp *) interp;
 
-    Tcl_Time endTime, now;
-    Tcl_WideInt diff;
+    Tcl_Time endTime, now, prevNow;
+    Tcl_WideInt diff, prevUS, nowUS;
 #ifdef TMR_RES_TOLERANCE
     long tolerance;
 #endif
@@ -1399,11 +1402,20 @@ AfterDelay(
     tolerance = ((ms < 1000) ? ms : 1000) * (1000 * TMR_RES_TOLERANCE / 100);
 #endif
 
-    Tcl_GetTime(&endTime);
+    prevUS = TclpGetMicroseconds();
+    Tcl_GetTime(&endTime); now = endTime;
+    prevNow = now;
     TclTimeAddMilliseconds(&endTime, ms);
 
     do {
+    	nowUS = TclpGetMicroseconds();
 	Tcl_GetTime(&now);
+	if (now.sec < prevNow.sec || (now.sec == prevNow.sec && now.usec < prevNow.usec) ) {
+	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!long-diff!!!! %5.3f, prev: %d.%06d - now: %d.%06d (%d usec)\n", ms, prevNow.sec, prevNow.usec, now.sec, now.usec, now.usec - prevNow.usec);
+	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!long-diff!!!! %5.3f, prev: %I64d - now: %I64d (%I64d usec)\n", ms, prevUS, nowUS, nowUS - prevUS);
+	    //Tcl_Panic("Time running backwards!");
+	    //return TCL_ERROR;
+	}
 	if (iPtr->limit.timeEvent != NULL
 	    && TCL_TIME_BEFORE(iPtr->limit.time, now)) {
 	    iPtr->limit.granularityTicker = 0;
@@ -1414,6 +1426,9 @@ AfterDelay(
 	if (iPtr->limit.timeEvent == NULL
 	    || TCL_TIME_BEFORE(endTime, iPtr->limit.time)) {
 	    diff = TCL_TIME_DIFF_MS(endTime, now);
+	    if (TCL_TIME_DIFF_US(endTime, now) > 500 || TCL_TIME_DIFF_US(endTime, now) < -500) {
+		printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!drift!!!! %5.3f, diff: %d -- %d.%06d - %d.%06d (%d usec)\n", ms, (int)diff, endTime.sec, endTime.usec, now.sec, now.usec, TCL_TIME_DIFF_US(endTime, now));
+	    }
 #ifndef TCL_WIDE_INT_IS_LONG
 	    if (diff > LONG_MAX) {
 		diff = LONG_MAX;
@@ -1421,6 +1436,7 @@ AfterDelay(
 #endif
 	    if (diff > 0) {
 		Tcl_Sleep((long)diff);
+		nowUS = TclpGetMicroseconds();
 		Tcl_GetTime(&now);
 	    }
 	} else {
@@ -1432,6 +1448,7 @@ AfterDelay(
 #endif
 	    if (diff > 0) {
 		Tcl_Sleep((long)diff);
+		nowUS = TclpGetMicroseconds();
 		Tcl_GetTime(&now);
 	    }
 	    if (Tcl_LimitCheck(interp) != TCL_OK) {
@@ -1439,6 +1456,8 @@ AfterDelay(
 	    }
 	}
 	/* consider timer resolution tolerance (avoid busy wait) */
+	prevNow = now;
+	prevUS = nowUS;
     #ifdef TMR_RES_TOLERANCE
 	now.usec += tolerance;
 	if (now.usec > 1000000) {
diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index def4548..8576656 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -51,7 +51,7 @@ typedef struct TimeInfo {
 				 * initialized. */
     int perfCounterAvailable;	/* Flag == 1 if the hardware has a performance
 				 * counter. */
-    DWORD calibrationInterv;	/* Calibration interval in seconds (start 1 sec) */
+    Tcl_WideInt calibNextTime;	/* Next time of calibration (in 100-ns ticks) */
     HANDLE calibrationThread;	/* Handle to the thread that keeps the virtual
 				 * clock calibrated. */
     HANDLE readyEvent;		/* System event used to trigger the requesting
@@ -62,20 +62,24 @@ typedef struct TimeInfo {
     LARGE_INTEGER nominalFreq;	/* Nominal frequency of the system performance
 				 * counter, that is, the value returned from
 				 * QueryPerformanceFrequency. */
+    LARGE_INTEGER posixEpoch;	/* Posix epoch expressed as 100-ns ticks since
+				 * the windows epoch. */
     /*
      * The following values are used for calculating virtual time. Virtual
      * time is always equal to:
-     *    lastFileTime + (current perf counter - lastCounter)
-     *				* 10000000 / curCounterFreq
-     * and lastFileTime and lastCounter are updated any time that virtual time
-     * is returned to a caller.
+     *    fileTime + (current perf counter - lastCounter)
+     *				* 10000000 / counterFreq
      */
 
-    ULARGE_INTEGER fileTimeLastCall;
-    LARGE_INTEGER perfCounterLastCall;
-    LARGE_INTEGER curCounterFreq;
-    LARGE_INTEGER posixEpoch;	/* Posix epoch expressed as 100-ns ticks since
-				 * the windows epoch. */
+    struct {
+	ULONGLONG fileTime;
+	volatile		/* used also to compare calibration epoch */
+	LONGLONG perfCounter; 
+	LONGLONG counterFreq;
+    } lastCC;			/* Last data updated in calibration cycle */
+    
+    Tcl_WideInt lastUsedTime;	/* Last known (caller) virtual time in 100-ns
+				 * (used to avoid drifts after calibrate) */
 
     /*
      * Data used in developing the estimate of performance counter frequency
@@ -92,25 +96,25 @@ static TimeInfo timeInfo = {
     { NULL, 0, 0, NULL, NULL, 0 },
     0,
     0,
-    1,
+    (Tcl_WideInt) 0,
     (HANDLE) NULL,
     (HANDLE) NULL,
     (HANDLE) NULL,
 #ifdef HAVE_CAST_TO_UNION
     (LARGE_INTEGER) (Tcl_WideInt) 0,
-    (ULARGE_INTEGER) (DWORDLONG) 0,
-    (LARGE_INTEGER) (Tcl_WideInt) 0,
-    (LARGE_INTEGER) (Tcl_WideInt) 0,
     (LARGE_INTEGER) (Tcl_WideInt) 0,
 #else
     {0, 0},
     {0, 0},
-    {0, 0},
-    {0, 0},
-    {0, 0},
 #endif
-    { 0 },
-    { 0 },
+    {
+	(ULONGLONG) 0,
+	(LONGLONG) 0,
+	(LONGLONG) 0
+    },
+    (Tcl_WideInt) 0,
+    { (Tcl_WideUInt) 0 },
+    { (Tcl_WideInt) 0 },
     0
 };
 
@@ -154,6 +158,50 @@ ClientData tclTimeClientData = NULL;
 /*
  *----------------------------------------------------------------------
  *
+ * NativeCalc100NsTicks --
+ *
+ *	Calculate the current system time in 100-ns ticks since posix epoch,
+ *	for current performance counter (curCounter), using given calibrated values.
+ *
+ * Results:
+ *	Returns the wide integer with number of microseconds from the epoch.
+ *
+ * Side effects:
+ *	None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static inline Tcl_WideInt
+NativeCalc100NsTicks(
+    ULONGLONG ccFileTime,
+    LONGLONG ccPerfCounter,
+    LONGLONG ccCounterFreq,
+    LONGLONG curCounter
+) {
+    return ccFileTime + 
+	((curCounter - ccPerfCounter) * 10000000 / ccCounterFreq);
+}
+
+/*
+ * Representing the number of 100-nanosecond intervals since posix epoch.
+ */
+static inline Tcl_WideInt
+GetSystemTimeAsVirtual(void)
+{
+    FILETIME curSysTime;	/* Current system time. */
+    LARGE_INTEGER curFileTime;
+
+    /* 100-ns ticks since since Jan 1, 1601 (UTC) */
+    GetSystemTimeAsFileTime(&curSysTime);
+    curFileTime.LowPart = curSysTime.dwLowDateTime;
+    curFileTime.HighPart = curSysTime.dwHighDateTime;
+    return (Tcl_WideInt)(curFileTime.QuadPart - timeInfo.posixEpoch.QuadPart);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * TclpGetSeconds --
  *
  *	This procedure returns the number of seconds from the epoch. On most
@@ -331,13 +379,19 @@ TclpWideClickInMicrosec(void)
 Tcl_WideInt 
 TclpGetMicroseconds(void)
 {
+    static Tcl_WideInt prevUS = 0;
+    static Tcl_WideInt fileTimeLastCall, perfCounterLastCall, curCounterFreq;
+    static LARGE_INTEGER prevPerfCounter;
+    LARGE_INTEGER newPerfCounter;
+
     Tcl_WideInt usecSincePosixEpoch;
 
     /* Try to use high resolution timer */
-    if ( tclGetTimeProcPtr == NativeGetTime
-      && (usecSincePosixEpoch = NativeGetMicroseconds())
-    ) {
-	return usecSincePosixEpoch;
+    if (tclGetTimeProcPtr == NativeGetTime) {
+	if ( !(usecSincePosixEpoch = NativeGetMicroseconds()) ) {
+	    usecSincePosixEpoch = GetSystemTimeAsVirtual() / 10; /* in 100-ns */
+	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!no-native-ms!!!!!!!!!!!\n");
+	}
     } else {
 	/*
 	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
@@ -347,8 +401,31 @@ TclpGetMicroseconds(void)
 	Tcl_Time now;
 
 	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
-	return (((Tcl_WideInt)now.sec) * 1000000) + now.usec;
+	usecSincePosixEpoch = (((Tcl_WideInt)now.sec) * 1000000) + now.usec;
+	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!no-native-ms!!!!!!!!!!!\n");
     }
+
+	QueryPerformanceCounter(&newPerfCounter);
+
+    	if (prevUS && usecSincePosixEpoch < prevUS) {
+    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! pre-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", fileTimeLastCall, perfCounterLastCall, prevPerfCounter.QuadPart, curCounterFreq,
+    	    	NativeCalc100NsTicks(fileTimeLastCall,
+		perfCounterLastCall, curCounterFreq,
+		prevPerfCounter.QuadPart));
+    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, newPerfCounter.QuadPart, timeInfo.lastCC.counterFreq,
+    	    	NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
+		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
+		newPerfCounter.QuadPart));
+	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! prev: %I64d - now: %I64d (%I64d usec)\n", prevUS, usecSincePosixEpoch, usecSincePosixEpoch - prevUS);
+	    Tcl_Panic("Time running backwards!!!");
+    	}
+    	prevUS = usecSincePosixEpoch;
+	fileTimeLastCall = timeInfo.lastCC.fileTime;
+	perfCounterLastCall = timeInfo.lastCC.perfCounter;
+	curCounterFreq = timeInfo.lastCC.counterFreq;
+	prevPerfCounter.QuadPart = newPerfCounter.QuadPart;
+
+	return usecSincePosixEpoch;
 }
 
 /*
@@ -469,20 +546,12 @@ NativeScaleTime(
  *----------------------------------------------------------------------
  */
 
-static inline Tcl_WideInt
-NativeCalc100NsTicks(
-    ULONGLONG fileTimeLastCall,
-    LONGLONG perfCounterLastCall,
-    LONGLONG curCounterFreq,
-    LONGLONG curCounter
-) {
-    return fileTimeLastCall + 
-	((curCounter - perfCounterLastCall) * 10000000 / curCounterFreq);
-}
-
 static Tcl_WideInt
 NativeGetMicroseconds(void)
 {
+    Tcl_WideInt curTime;	/* Current time in 100-ns ticks since epoch */
+    Tcl_WideInt lastTime;	/* Used to compare with last known time */
+
     /*
      * Initialize static storage on the first trip through.
      *
@@ -595,42 +664,52 @@ NativeGetMicroseconds(void)
 	TclpInitUnlock();
     }
 
-    if (timeInfo.perfCounterAvailable && timeInfo.curCounterFreq.QuadPart!=0) {
-	/*
-	 * Query the performance counter and use it to calculate the current
-	 * time.
-	 */
+    if (timeInfo.perfCounterAvailable && timeInfo.lastCC.counterFreq!=0) {
 
-	ULONGLONG fileTimeLastCall;
-	LONGLONG perfCounterLastCall, curCounterFreq;
-				/* Copy with current data of calibration cycle */
+	static struct {
+	    ULONGLONG fileTime;
+	    volatile		/* don't optimize */
+	    LONGLONG  perfCounter;
+	    LONGLONG  counterFreq;
+	    Tcl_WideInt calibNextTime;
+	} cc = {0, 0, 0, 0};	/* Copy with current data of calibration cycle */
 
 	LARGE_INTEGER curCounter;
 				/* Current performance counter. */
 
-	QueryPerformanceCounter(&curCounter);
-
 	/*
 	 * Hold time section locked as short as possible
 	 */
-	EnterCriticalSection(&timeInfo.cs);
-
-	fileTimeLastCall = timeInfo.fileTimeLastCall.QuadPart;
-	perfCounterLastCall = timeInfo.perfCounterLastCall.QuadPart;
-	curCounterFreq = timeInfo.curCounterFreq.QuadPart;
-
-	LeaveCriticalSection(&timeInfo.cs);
+	if (cc.perfCounter != timeInfo.lastCC.perfCounter) {
+	    EnterCriticalSection(&timeInfo.cs);
+	    if (cc.perfCounter != timeInfo.lastCC.perfCounter) {
+		cc.perfCounter = timeInfo.lastCC.perfCounter;
+		cc.fileTime = timeInfo.lastCC.fileTime;
+		cc.counterFreq = timeInfo.lastCC.counterFreq;
+		cc.calibNextTime = timeInfo.calibNextTime;
+	    }
+	    LeaveCriticalSection(&timeInfo.cs);
+	}
 
 	/*
-	 * If calibration cycle occurred after we get curCounter
+	 * Query the performance counter and use it to calculate the current
+	 * time.
 	 */
-	if (curCounter.QuadPart <= perfCounterLastCall) {
-	    /* Calibrated file-time is saved from posix in 100-ns ticks */
-	    return fileTimeLastCall / 10;
+	QueryPerformanceCounter(&curCounter);
+
+	/* Calibrated file-time is saved from posix in 100-ns ticks */
+	curTime = NativeCalc100NsTicks(cc.fileTime,
+		cc.perfCounter, cc.counterFreq, curCounter.QuadPart);
+
+	/* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
+	if ( (lastTime = timeInfo.lastUsedTime) && lastTime > curTime
+	  && lastTime - curTime < 1000000 /* bypass time-switch (drifts only) */
+	) {
+	    curTime = timeInfo.lastUsedTime;
 	}
 
 	/*
-	 * If it appears to be more than 1.1 seconds since the last trip
+	 * If it appears to be more than 1.5 seconds since the last trip
 	 * through the calibration loop, the performance counter may have
 	 * jumped forward. (See MSDN Knowledge Base article Q274323 for a
 	 * description of the hardware problem that makes this test
@@ -639,19 +718,26 @@ NativeGetMicroseconds(void)
 	 * loop should recover.
 	 */
 
-	if (curCounter.QuadPart - perfCounterLastCall <
-		11 * curCounterFreq * timeInfo.calibrationInterv / 10
-	) {
-	    /* Calibrated file-time is saved from posix in 100-ns ticks */
-	    return NativeCalc100NsTicks(fileTimeLastCall,
-		perfCounterLastCall, curCounterFreq, curCounter.QuadPart) / 10;
+	if (curTime < cc.calibNextTime + 5000000 /* 500 millisec (in 100-ns ticks). */) {
+	    /* save last used time */
+	    timeInfo.lastUsedTime = curTime;
+	    return curTime / 10;
 	}
+	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!calibration-error!!!! cur: %I64d - call: %I64d (%I64d) -- prev: %I64d - now: %I64d (%I64d)\n", curTime, cc.calibNextTime, cc.calibNextTime - curTime, cc.perfCounter, curCounter.QuadPart, curCounter.QuadPart - cc.perfCounter);
     }
 
     /*
      * High resolution timer is not available.
      */
-    return 0;
+    curTime = GetSystemTimeAsVirtual(); /* in 100-ns ticks */
+    /* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
+    if ( (lastTime = timeInfo.lastUsedTime) && lastTime > curTime
+      && lastTime - curTime < 1000000 /* bypass time-switch (drifts only) */
+    ) {
+	curTime = timeInfo.lastUsedTime;
+    }
+    timeInfo.lastUsedTime = curTime;
+    return curTime / 10;
 }
 
 /*
@@ -1076,30 +1162,32 @@ static DWORD WINAPI
 CalibrationThread(
     LPVOID arg)
 {
-    FILETIME curFileTime;
     DWORD waitResult;
 
     /*
      * Get initial system time and performance counter.
      */
 
-    GetSystemTimeAsFileTime(&curFileTime);
-    QueryPerformanceCounter(&timeInfo.perfCounterLastCall);
-    QueryPerformanceFrequency(&timeInfo.curCounterFreq);
-    timeInfo.fileTimeLastCall.LowPart = curFileTime.dwLowDateTime;
-    timeInfo.fileTimeLastCall.HighPart = curFileTime.dwHighDateTime;
-    /* Calibrated file-time will be saved from posix in 100-ns ticks */
-    timeInfo.fileTimeLastCall.QuadPart -= timeInfo.posixEpoch.QuadPart;
+    LARGE_INTEGER curPerfCounter;
+
+    QueryPerformanceCounter(&curPerfCounter);
+    timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
+    timeInfo.lastCC.counterFreq = timeInfo.nominalFreq.QuadPart;
+    timeInfo.lastCC.fileTime = GetSystemTimeAsVirtual();
 
-    ResetCounterSamples(timeInfo.fileTimeLastCall.QuadPart,
-	    timeInfo.perfCounterLastCall.QuadPart,
-	    timeInfo.curCounterFreq.QuadPart);
+    ResetCounterSamples(timeInfo.lastCC.fileTime,
+	    timeInfo.lastCC.perfCounter,
+	    timeInfo.lastCC.counterFreq);
 
     /*
-     * Wake up the calling thread. When it wakes up, it will release the
-     * initialization lock.
+     * Calibrate first time and wake up the calling thread. 
+     * When it wakes up, it will release the initialization lock.
      */
 
+    if (timeInfo.perfCounterAvailable) {
+	UpdateTimeEachSecond();
+    }
+
     SetEvent(timeInfo.readyEvent);
 
     /*
@@ -1153,13 +1241,13 @@ UpdateTimeEachSecond(void)
     LARGE_INTEGER curPerfCounter;
 				/* Current value returned from
 				 * QueryPerformanceCounter. */
-    FILETIME curSysTime;	/* Current system time. */
-    static LARGE_INTEGER lastFileTime; /* File time of the previous calibration */
-    LARGE_INTEGER curFileTime;	/* File time at the time this callback was
+    static int calibrationInterv = 10000000;
+				/* Calibration interval in 100-ns ticks (starts from 1s) */
+    Tcl_WideInt curFileTime;	/* File time at the time this callback was
 				 * scheduled. */
     Tcl_WideInt estFreq;	/* Estimated perf counter frequency. */
     Tcl_WideInt vt0;		/* Tcl time right now. */
-    Tcl_WideInt vt1;		/* Tcl time one second from now. */
+    Tcl_WideInt vt1, nt0, nt1;	/* Interim virtual time used during adjustments */
     Tcl_WideInt tdiff;		/* Difference between system clock and Tcl
 				 * time. */
     Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
@@ -1169,24 +1257,23 @@ UpdateTimeEachSecond(void)
      * Sample performance counter and system time (from posix epoch).
      */
 
-    GetSystemTimeAsFileTime(&curSysTime);
-    curFileTime.LowPart = curSysTime.dwLowDateTime;
-    curFileTime.HighPart = curSysTime.dwHighDateTime;
-    curFileTime.QuadPart -= timeInfo.posixEpoch.QuadPart;
-    /* If calibration still not needed (check for possible time switch) */
-    if ( curFileTime.QuadPart > lastFileTime.QuadPart
-      && curFileTime.QuadPart < lastFileTime.QuadPart +
-      				    (timeInfo.calibrationInterv * 10000000)
+    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
+    curFileTime = GetSystemTimeAsVirtual();
+    /* 
+     * If calibration still not needed (check for possible time-switch). Note, that
+     * NativeGetMicroseconds checks calibNextTime also, be sure it does not overflow.
+     */
+    if ( curFileTime < timeInfo.calibNextTime - 10000000 /* 1 sec (in 100-ns ticks). */
+      && timeInfo.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between */
     ) {
     	/* again in next one second */
+//    	printf("-------------calibration end, not needed. ------ cur:%I64d - next:%I64d (d: %I64d) ------\n", curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
 	return;
     }
     QueryPerformanceCounter(&curPerfCounter);
     
-    lastFileTime.QuadPart = curFileTime.QuadPart;
-
     /*
-     * We devide by timeInfo.curCounterFreq.QuadPart in several places. That
+     * We devide by timeInfo.lastCC.counterFreq in several places. That
      * value should always be positive on a correctly functioning system. But
      * it is good to be defensive about such matters. So if something goes
      * wrong and the value does goes to zero, we clear the
@@ -1194,7 +1281,7 @@ UpdateTimeEachSecond(void)
      * to shut itself down, then return without additional processing.
      */
 
-    if (timeInfo.curCounterFreq.QuadPart == 0){
+    if (timeInfo.lastCC.counterFreq == 0) {
 	timeInfo.perfCounterAvailable = 0;
 	return;
     }
@@ -1213,16 +1300,15 @@ UpdateTimeEachSecond(void)
      * estimate the performance counter frequency.
      */
 
-     estFreq = AccumulateSample(curPerfCounter.QuadPart,
-	    (Tcl_WideUInt) curFileTime.QuadPart);
+     estFreq = AccumulateSample(curPerfCounter.QuadPart, curFileTime);
 
     /*
      * We want to adjust things so that time appears to be continuous.
      * Virtual file time, right now, is
      *
-     * vt0 = 10000000 * (curPerfCounter - perfCounterLastCall)
-     *	     / curCounterFreq
-     *	     + fileTimeLastCall
+     * vt0 = 10000000 * (curPerfCounter - lastCC.perfCounter)
+     *	     / lastCC.counterFreq
+     *	     + lastCC.fileTime
      *
      * Ideally, we would like to drift the clock into place over a period of 2
      * sec, so that virtual time 2 sec from now will be
@@ -1233,8 +1319,8 @@ UpdateTimeEachSecond(void)
      * is estFreq * 20000000 / (vt1 - vt0)
      */
 
-    vt0 = NativeCalc100NsTicks(timeInfo.fileTimeLastCall.QuadPart,
-	    timeInfo.perfCounterLastCall.QuadPart, timeInfo.curCounterFreq.QuadPart,
+    vt0 = NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
+	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
 	    curPerfCounter.QuadPart);
     /*
      * If we've gotten more than a second away from system time, then drifting
@@ -1242,80 +1328,92 @@ UpdateTimeEachSecond(void)
      * compute the drift frequency and fill in everything.
      */
 
-    tdiff = vt0 - curFileTime.QuadPart;
+    tdiff = vt0 - curFileTime;
     if (tdiff > 10000000 || tdiff < -10000000) {
+    	/* More as a second difference, so could be a time-switch
     	/* jump to current system time, use curent estimated frequency */
-    	vt0 = curFileTime.QuadPart;
+    	vt0 = curFileTime;
+    	timeInfo.lastUsedTime = 0; /* reset last used time */
     } else {
     	/* calculate new frequency and estimate drift to the next second */
-	vt1 = 20000000 + curFileTime.QuadPart;
+	vt1 = 20000000 + curFileTime;
 	driftFreq = (estFreq * 20000000 / (vt1 - vt0));
 	/* 
 	 * Avoid too large drifts (only half of the current difference),
 	 * that allows also be more accurate (aspire to the smallest tdiff),
 	 * so then we can prolong calibration interval by tdiff < 100000
 	 */
-	driftFreq = timeInfo.curCounterFreq.QuadPart +
-		(driftFreq - timeInfo.curCounterFreq.QuadPart) / 2;
+	driftFreq = timeInfo.lastCC.counterFreq +
+		(driftFreq - timeInfo.lastCC.counterFreq) / 2;
 
 	/* 
 	 * Average between estimated, 2 current and 5 drifted frequencies,
 	 * (do the soft drifting as possible)
 	 */
-	estFreq = (estFreq + 2 * timeInfo.curCounterFreq.QuadPart + 5 * driftFreq) / 8;
+	estFreq = (estFreq + 2 * timeInfo.lastCC.counterFreq + 5 * driftFreq) / 8;
     }
     
-    /* Avoid too large discrepancy from nominal frequency */
+    /* 
+     * Avoid too large discrepancy from nominal frequency
+     */
     if (estFreq > 1003*timeInfo.nominalFreq.QuadPart/1000) {
 	estFreq = 1003*timeInfo.nominalFreq.QuadPart/1000;
-	vt0 = curFileTime.QuadPart;
+	vt0 = curFileTime;
     } else if (estFreq < 997*timeInfo.nominalFreq.QuadPart/1000) {
 	estFreq = 997*timeInfo.nominalFreq.QuadPart/1000;
-	vt0 = curFileTime.QuadPart;
-    } else if (vt0 != curFileTime.QuadPart) {
+	vt0 = curFileTime;
+    }
+
+    /* If possible backwards time-drifts */
+    if (estFreq > timeInfo.lastCC.counterFreq) {
 	/* 
+	 * Calculate the time using new calibration values (and compare with old),
+	 * to avoid possible backwards drifts (adjust current base time).
+	 * This should affect at least next 10 ticks.
+	 */
+	vt1 = curPerfCounter.QuadPart + 10;
+	/*
 	 * Be sure the clock ticks never backwards (avoid it by negative drifting)
 	 * just compare native time (in 100-ns) before and hereafter using 
-	 * new calibrated values) and do a small adjustment (short time freeze)
+	 * previous/new calibrated values) and do a small adjustment
 	 */
-	LARGE_INTEGER newPerfCounter;
-	Tcl_WideInt nt0, nt1;
-
-	QueryPerformanceCounter(&newPerfCounter);
-	nt0 = NativeCalc100NsTicks(timeInfo.fileTimeLastCall.QuadPart,
-		timeInfo.perfCounterLastCall.QuadPart, timeInfo.curCounterFreq.QuadPart,
-		newPerfCounter.QuadPart);
-	nt1 = NativeCalc100NsTicks(vt0,
+	nt0 = NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
+		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
+		vt1);
+	nt1 = NativeCalc100NsTicks(curFileTime,
 		curPerfCounter.QuadPart, estFreq,
-		newPerfCounter.QuadPart);
-	if (nt0 > nt1) { /* drifted backwards, try to compensate with new base */
-	    /* first adjust with a micro jump (short frozen time is acceptable) */
-	    vt0 += nt0 - nt1;
-	    /* if drift unavoidable (e. g. we had a time switch), then reset it */
-	    vt1 = vt0 - curFileTime.QuadPart;
-	    if (vt1 > 10000000 || vt1 < -10000000) {
-	    	/* larger jump resp. shift relative new file-time */
-	    	vt0 = curFileTime.QuadPart;
-	    }
+		vt1);
+	vt1 = (nt0 - nt1); /* old time - new time */
+	if (vt1 > 0 && vt1 < 10000000) {
+	    /* base time should jump forwards (the same virtual time using current values) */
+	    vt0 += vt1;
 	}
     }
 
-    /* In lock commit new values to timeInfo (hold lock as short as possible) */
-    EnterCriticalSection(&timeInfo.cs);
-
     /* grow calibration interval up to 10 seconds (if still precise enough) */
     if (tdiff < -100000 || tdiff > 100000) {
-	/* too long drift - reset calibration interval to 1000 second */
-	timeInfo.calibrationInterv = 1;
-    } else if (timeInfo.calibrationInterv < 10) {
-	timeInfo.calibrationInterv++;
+	/* too long drift - reset calibration interval to 1 second */
+	calibrationInterv = 10000000;
+    } else if (calibrationInterv < 10*10000000) {
+	calibrationInterv += 10000000;
     }
 
-    timeInfo.fileTimeLastCall.QuadPart = vt0;
-    timeInfo.curCounterFreq.QuadPart = estFreq;
-    timeInfo.perfCounterLastCall.QuadPart = curPerfCounter.QuadPart;
+    /* In lock commit new values to timeInfo (hold lock as short as possible) */
+    EnterCriticalSection(&timeInfo.cs);
+
+    timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
+    timeInfo.lastCC.fileTime = vt0;
+    timeInfo.lastCC.counterFreq = estFreq;
+
+    timeInfo.calibNextTime = curFileTime + calibrationInterv;
 
     LeaveCriticalSection(&timeInfo.cs);
+#if 1
+    printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
+    printf("-------------calibration end, tdiff %I64d, jump -- vt:%I64d - st:%I64d: %I64d, adj: %I64d\n", tdiff, 
+    	vt0, curFileTime, (vt0 - curFileTime), vt1);
+    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
+#endif
 }
 
 /*
-- 
cgit v0.12


From f1d006af946ed800038bc2babde5d70ce347faab Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:07 +0000
Subject: interim commit: try to fix time-drift backwards (calibration?
 something else?)...

---
 generic/tclInt.h   |   3 ++
 generic/tclTimer.c |   2 +-
 win/tclWinTime.c   | 120 +++++++++++++++++++++++++++++++++--------------------
 3 files changed, 80 insertions(+), 45 deletions(-)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index fad78f2..7576a97 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -4092,6 +4092,9 @@ TclInlLimitExceeded(
 {
     return (((Interp *)interp)->limit.exceeded != 0);
 }
+#ifdef Tcl_LimitExceeded
+#  undef Tcl_LimitExceeded
+#endif
 #define Tcl_LimitExceeded(interp) TclInlLimitExceeded(interp)
 
 #define TclLimitReady(limit)						\
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index d9e25de..a7fd50b 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -1427,7 +1427,7 @@ AfterDelay(
 	    || TCL_TIME_BEFORE(endTime, iPtr->limit.time)) {
 	    diff = TCL_TIME_DIFF_MS(endTime, now);
 	    if (TCL_TIME_DIFF_US(endTime, now) > 500 || TCL_TIME_DIFF_US(endTime, now) < -500) {
-		printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!drift!!!! %5.3f, diff: %d -- %d.%06d - %d.%06d (%d usec)\n", ms, (int)diff, endTime.sec, endTime.usec, now.sec, now.usec, TCL_TIME_DIFF_US(endTime, now));
+		//printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!drift!!!! %5.3f, diff: %d -- %d.%06d - %d.%06d (%d usec)\n", ms, (int)diff, endTime.sec, endTime.usec, now.sec, now.usec, TCL_TIME_DIFF_US(endTime, now));
 	    }
 #ifndef TCL_WIDE_INT_IS_LONG
 	    if (diff > LONG_MAX) {
diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index 8576656..6709335 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -163,6 +163,9 @@ ClientData tclTimeClientData = NULL;
  *	Calculate the current system time in 100-ns ticks since posix epoch,
  *	for current performance counter (curCounter), using given calibrated values.
  *
+ *	vt = lastCC.fileTime + 
+ *	     10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
+ *
  * Results:
  *	Returns the wide integer with number of microseconds from the epoch.
  *
@@ -616,20 +619,32 @@ NativeGetMicroseconds(void)
 		unsigned int regs[4];
 
 		GetSystemInfo(&systemInfo);
+		if (TclWinCPUID(1, regs) == TCL_OK) {
+		printf("********* system pen: %d, hyperthread: %d, cpu-count: %d\n, cpu-num: %d\n", 
+			(regs[0]&0x00000F00) == 0x00000F00 /* Pentium 4 */
+			,((regs[0] & 0x0FF00000)	/* Extended family (bits 20-27) */
+			&& (regs[3] & 0x10000000)),
+			((regs[1]&0x00FF0000) >> 16)/* CPU count */,
+			systemInfo.dwNumberOfProcessors
+		);}
+
 		if (TclWinCPUID(0, regs) == TCL_OK
 			&& regs[1] == 0x756e6547	/* "Genu" */
 			&& regs[3] == 0x49656e69	/* "ineI" */
 			&& regs[2] == 0x6c65746e	/* "ntel" */
 			&& TclWinCPUID(1, regs) == TCL_OK
-			&& ((regs[0]&0x00000F00) == 0x00000F00 /* Pentium 4 */
-			|| ((regs[0] & 0x00F00000)	/* Extended family */
-			&& (regs[3] & 0x10000000)))	/* Hyperthread */
-			&& (((regs[1]&0x00FF0000) >> 16)/* CPU count */
-			    == systemInfo.dwNumberOfProcessors)) {
+			&& (( ((regs[0]&0x00000F00) == 0xF00) /* Pentium 4 */
+			   || ((regs[0]&0x00000F00) == 0x600) ) /* or compatible (VM) */
+			&& ((regs[0] & 0x0FF00000)	/* Extended family (bits 20-27) */
+			|| (regs[3] & 0x10000000)))	/* Hyperthread (bit 28) */
+			|| (((regs[1]&0x00FF0000) >> 16) >= 2 /* CPU count */
+			    || systemInfo.dwNumberOfProcessors >= 2)) {
 		    timeInfo.perfCounterAvailable = TRUE;
 		} else {
 		    timeInfo.perfCounterAvailable = FALSE;
 		}
+		printf("********* available %d\n", timeInfo.perfCounterAvailable);
+
 	    }
 #endif /* above code is Win32 only */
 
@@ -702,14 +717,15 @@ NativeGetMicroseconds(void)
 		cc.perfCounter, cc.counterFreq, curCounter.QuadPart);
 
 	/* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
-	if ( (lastTime = timeInfo.lastUsedTime) && lastTime > curTime
+	if ( (lastTime = timeInfo.lastUsedTime)
+	  && lastTime > curTime
 	  && lastTime - curTime < 1000000 /* bypass time-switch (drifts only) */
 	) {
 	    curTime = timeInfo.lastUsedTime;
 	}
 
 	/*
-	 * If it appears to be more than 1.5 seconds since the last trip
+	 * If it appears to be more than 1 seconds since the last trip
 	 * through the calibration loop, the performance counter may have
 	 * jumped forward. (See MSDN Knowledge Base article Q274323 for a
 	 * description of the hardware problem that makes this test
@@ -718,7 +734,7 @@ NativeGetMicroseconds(void)
 	 * loop should recover.
 	 */
 
-	if (curTime < cc.calibNextTime + 5000000 /* 500 millisec (in 100-ns ticks). */) {
+	if (curTime < cc.calibNextTime + 10000000 /* 1 sec (in 100-ns ticks). */) {
 	    /* save last used time */
 	    timeInfo.lastUsedTime = curTime;
 	    return curTime / 10;
@@ -731,7 +747,8 @@ NativeGetMicroseconds(void)
      */
     curTime = GetSystemTimeAsVirtual(); /* in 100-ns ticks */
     /* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
-    if ( (lastTime = timeInfo.lastUsedTime) && lastTime > curTime
+    if ( (lastTime = timeInfo.lastUsedTime)
+      && lastTime > curTime
       && lastTime - curTime < 1000000 /* bypass time-switch (drifts only) */
     ) {
 	curTime = timeInfo.lastUsedTime;
@@ -1246,31 +1263,43 @@ UpdateTimeEachSecond(void)
     Tcl_WideInt curFileTime;	/* File time at the time this callback was
 				 * scheduled. */
     Tcl_WideInt estFreq;	/* Estimated perf counter frequency. */
+    int		driftBack;	/* Sign the virtual time may drift backwards */
     Tcl_WideInt vt0;		/* Tcl time right now. */
-    Tcl_WideInt vt1, nt0, nt1;	/* Interim virtual time used during adjustments */
+    Tcl_WideInt vt1;		/* Interim virtual time used during adjustments */
     Tcl_WideInt tdiff;		/* Difference between system clock and Tcl
 				 * time. */
-    Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
-				 * step over 1 second. */
 
+    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
     /*
-     * Sample performance counter and system time (from posix epoch).
+     * Sample system time (from posix epoch) and performance counter.
      */
 
-    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
     curFileTime = GetSystemTimeAsVirtual();
+    QueryPerformanceCounter(&curPerfCounter);
+
+    /* 
+     * Current virtual time:
+     * vt0 = lastCC.fileTime +
+     *       10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
+     */
+    vt0 = NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
+	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
+	    curPerfCounter.QuadPart);
+
+    tdiff = vt0 - curFileTime; /* discrepancy between virtual and real-time */
     /* 
      * If calibration still not needed (check for possible time-switch). Note, that
      * NativeGetMicroseconds checks calibNextTime also, be sure it does not overflow.
+     * Calibrate immediately if we've too large discrepancy to the real-time (15.6 ms).
      */
-    if ( curFileTime < timeInfo.calibNextTime - 10000000 /* 1 sec (in 100-ns ticks). */
-      && timeInfo.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between */
+    if ( curFileTime < timeInfo.calibNextTime - (10000000/2) /* 0.5 sec (in 100-ns ticks). */
+      && timeInfo.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between (time-switch?) */
+      && tdiff > -156000 && tdiff < 156000
     ) {
     	/* again in next one second */
 //    	printf("-------------calibration end, not needed. ------ cur:%I64d - next:%I64d (d: %I64d) ------\n", curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
 	return;
     }
-    QueryPerformanceCounter(&curPerfCounter);
     
     /*
      * We devide by timeInfo.lastCC.counterFreq in several places. That
@@ -1299,16 +1328,19 @@ UpdateTimeEachSecond(void)
      * Store the current sample into the circular buffer of samples, and
      * estimate the performance counter frequency.
      */
+#if 0
+    estFreq = AccumulateSample(curPerfCounter.QuadPart, curFileTime);
+#else
+    estFreq = 10000000 * (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter) / (vt0 - timeInfo.lastCC.fileTime);
+    printf("------**-----calibration estimated, tdiff: %I64d, cntrDiff:%I64d\n", tdiff, (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter));
+    printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter.QuadPart, estFreq, estFreq - timeInfo.lastCC.counterFreq);
+#endif
 
-     estFreq = AccumulateSample(curPerfCounter.QuadPart, curFileTime);
+    driftBack = 0;
 
     /*
      * We want to adjust things so that time appears to be continuous.
-     * Virtual file time, right now, is
-     *
-     * vt0 = 10000000 * (curPerfCounter - lastCC.perfCounter)
-     *	     / lastCC.counterFreq
-     *	     + lastCC.fileTime
+     * Virtual file time, right now, is vt0.
      *
      * Ideally, we would like to drift the clock into place over a period of 2
      * sec, so that virtual time 2 sec from now will be
@@ -1317,31 +1349,28 @@ UpdateTimeEachSecond(void)
      *
      * The frequency that we need to use to drift the counter back into place
      * is estFreq * 20000000 / (vt1 - vt0)
-     */
-
-    vt0 = NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
-	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
-	    curPerfCounter.QuadPart);
-    /*
+     *
      * If we've gotten more than a second away from system time, then drifting
      * the clock is going to be pretty hopeless. Just let it jump. Otherwise,
      * compute the drift frequency and fill in everything.
      */
 
-    tdiff = vt0 - curFileTime;
     if (tdiff > 10000000 || tdiff < -10000000) {
     	/* More as a second difference, so could be a time-switch
     	/* jump to current system time, use curent estimated frequency */
     	vt0 = curFileTime;
     	timeInfo.lastUsedTime = 0; /* reset last used time */
     } else {
+	Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
+				 * step over 1 second. */
+
     	/* calculate new frequency and estimate drift to the next second */
 	vt1 = 20000000 + curFileTime;
 	driftFreq = (estFreq * 20000000 / (vt1 - vt0));
 	/* 
 	 * Avoid too large drifts (only half of the current difference),
 	 * that allows also be more accurate (aspire to the smallest tdiff),
-	 * so then we can prolong calibration interval by tdiff < 100000
+	 * so then we can prolong calibration interval in such cases.
 	 */
 	driftFreq = timeInfo.lastCC.counterFreq +
 		(driftFreq - timeInfo.lastCC.counterFreq) / 2;
@@ -1354,18 +1383,20 @@ UpdateTimeEachSecond(void)
     }
     
     /* 
-     * Avoid too large discrepancy from nominal frequency
+     * Avoid too large discrepancy from nominal frequency (0.6 %)
      */
-    if (estFreq > 1003*timeInfo.nominalFreq.QuadPart/1000) {
-	estFreq = 1003*timeInfo.nominalFreq.QuadPart/1000;
-	vt0 = curFileTime;
-    } else if (estFreq < 997*timeInfo.nominalFreq.QuadPart/1000) {
-	estFreq = 997*timeInfo.nominalFreq.QuadPart/1000;
-	vt0 = curFileTime;
+    if ( estFreq > (vt1 = (1000+3)*timeInfo.nominalFreq.QuadPart/1000)
+      || estFreq < (vt1 = (1000-3)*timeInfo.nominalFreq.QuadPart/1000)
+    ) {
+	estFreq = vt1;
+	driftBack = vt0 > curFileTime;
+	vt0 = curFileTime; /* too large - just reset */
     }
 
-    /* If possible backwards time-drifts */
-    if (estFreq > timeInfo.lastCC.counterFreq) {
+    /* If possible backwards time-drifts (larger divider now) */
+    if (driftBack || estFreq > timeInfo.lastCC.counterFreq) {
+	Tcl_WideInt nt0, nt1;
+
 	/* 
 	 * Calculate the time using new calibration values (and compare with old),
 	 * to avoid possible backwards drifts (adjust current base time).
@@ -1384,14 +1415,15 @@ UpdateTimeEachSecond(void)
 		curPerfCounter.QuadPart, estFreq,
 		vt1);
 	vt1 = (nt0 - nt1); /* old time - new time */
-	if (vt1 > 0 && vt1 < 10000000) {
+	if (vt1 > 0 && vt1 < 10000000 /* bypass time-switch */) {
 	    /* base time should jump forwards (the same virtual time using current values) */
 	    vt0 += vt1;
+	    tdiff += vt1;
 	}
     }
 
-    /* grow calibration interval up to 10 seconds (if still precise enough) */
-    if (tdiff < -100000 || tdiff > 100000) {
+    /* if still precise enough, grow calibration interval up to 10 seconds */
+    if (tdiff < -156000 || tdiff > 156000 /* 15.6-ms */) {
 	/* too long drift - reset calibration interval to 1 second */
 	calibrationInterv = 10000000;
     } else if (calibrationInterv < 10*10000000) {
@@ -1409,7 +1441,7 @@ UpdateTimeEachSecond(void)
 
     LeaveCriticalSection(&timeInfo.cs);
 #if 1
-    printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
+    //printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
     printf("-------------calibration end, tdiff %I64d, jump -- vt:%I64d - st:%I64d: %I64d, adj: %I64d\n", tdiff, 
     	vt0, curFileTime, (vt0 - curFileTime), vt1);
     printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
-- 
cgit v0.12


From 68152b9280dd29d5a79dcbd75bd0b1e54998f141 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:12 +0000
Subject: interim commit: time-drift backwards fix...

---
 win/tclWinTime.c | 105 +++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 78 insertions(+), 27 deletions(-)

diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index 6709335..a30a952 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -73,6 +73,7 @@ typedef struct TimeInfo {
 
     struct {
 	ULONGLONG fileTime;
+	ULONGLONG virtTime;
 	volatile		/* used also to compare calibration epoch */
 	LONGLONG perfCounter; 
 	LONGLONG counterFreq;
@@ -109,6 +110,7 @@ static TimeInfo timeInfo = {
 #endif
     {
 	(ULONGLONG) 0,
+	(ULONGLONG) 0,
 	(LONGLONG) 0,
 	(LONGLONG) 0
     },
@@ -163,7 +165,7 @@ ClientData tclTimeClientData = NULL;
  *	Calculate the current system time in 100-ns ticks since posix epoch,
  *	for current performance counter (curCounter), using given calibrated values.
  *
- *	vt = lastCC.fileTime + 
+ *	vt = lastCC.virtTime + 
  *	     10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
  *
  * Results:
@@ -177,12 +179,12 @@ ClientData tclTimeClientData = NULL;
 
 static inline Tcl_WideInt
 NativeCalc100NsTicks(
-    ULONGLONG ccFileTime,
+    ULONGLONG ccVirtTime,
     LONGLONG ccPerfCounter,
     LONGLONG ccCounterFreq,
     LONGLONG curCounter
 ) {
-    return ccFileTime + 
+    return ccVirtTime + 
 	((curCounter - ccPerfCounter) * 10000000 / ccCounterFreq);
 }
 
@@ -415,15 +417,15 @@ TclpGetMicroseconds(void)
     	    	NativeCalc100NsTicks(fileTimeLastCall,
 		perfCounterLastCall, curCounterFreq,
 		prevPerfCounter.QuadPart));
-    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, newPerfCounter.QuadPart, timeInfo.lastCC.counterFreq,
-    	    	NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
+    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, newPerfCounter.QuadPart, timeInfo.lastCC.counterFreq,
+    	    	NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
 		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
 		newPerfCounter.QuadPart));
 	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! prev: %I64d - now: %I64d (%I64d usec)\n", prevUS, usecSincePosixEpoch, usecSincePosixEpoch - prevUS);
 	    Tcl_Panic("Time running backwards!!!");
     	}
     	prevUS = usecSincePosixEpoch;
-	fileTimeLastCall = timeInfo.lastCC.fileTime;
+	fileTimeLastCall = timeInfo.lastCC.virtTime;
 	perfCounterLastCall = timeInfo.lastCC.perfCounter;
 	curCounterFreq = timeInfo.lastCC.counterFreq;
 	prevPerfCounter.QuadPart = newPerfCounter.QuadPart;
@@ -682,7 +684,7 @@ NativeGetMicroseconds(void)
     if (timeInfo.perfCounterAvailable && timeInfo.lastCC.counterFreq!=0) {
 
 	static struct {
-	    ULONGLONG fileTime;
+	    ULONGLONG virtTime;
 	    volatile		/* don't optimize */
 	    LONGLONG  perfCounter;
 	    LONGLONG  counterFreq;
@@ -699,7 +701,7 @@ NativeGetMicroseconds(void)
 	    EnterCriticalSection(&timeInfo.cs);
 	    if (cc.perfCounter != timeInfo.lastCC.perfCounter) {
 		cc.perfCounter = timeInfo.lastCC.perfCounter;
-		cc.fileTime = timeInfo.lastCC.fileTime;
+		cc.virtTime = timeInfo.lastCC.virtTime;
 		cc.counterFreq = timeInfo.lastCC.counterFreq;
 		cc.calibNextTime = timeInfo.calibNextTime;
 	    }
@@ -713,7 +715,7 @@ NativeGetMicroseconds(void)
 	QueryPerformanceCounter(&curCounter);
 
 	/* Calibrated file-time is saved from posix in 100-ns ticks */
-	curTime = NativeCalc100NsTicks(cc.fileTime,
+	curTime = NativeCalc100NsTicks(cc.virtTime,
 		cc.perfCounter, cc.counterFreq, curCounter.QuadPart);
 
 	/* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
@@ -1190,7 +1192,7 @@ CalibrationThread(
     QueryPerformanceCounter(&curPerfCounter);
     timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
     timeInfo.lastCC.counterFreq = timeInfo.nominalFreq.QuadPart;
-    timeInfo.lastCC.fileTime = GetSystemTimeAsVirtual();
+    timeInfo.lastCC.fileTime = timeInfo.lastCC.virtTime = GetSystemTimeAsVirtual();
 
     ResetCounterSamples(timeInfo.lastCC.fileTime,
 	    timeInfo.lastCC.perfCounter,
@@ -1258,6 +1260,9 @@ UpdateTimeEachSecond(void)
     LARGE_INTEGER curPerfCounter;
 				/* Current value returned from
 				 * QueryPerformanceCounter. */
+    static Tcl_WideInt lastDiff = 0;
+    				/* Last difference between system clock and Tcl
+				 * time. */
     static int calibrationInterv = 10000000;
 				/* Calibration interval in 100-ns ticks (starts from 1s) */
     Tcl_WideInt curFileTime;	/* File time at the time this callback was
@@ -1282,25 +1287,31 @@ UpdateTimeEachSecond(void)
      * vt0 = lastCC.fileTime +
      *       10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
      */
-    vt0 = NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
+    vt0 = NativeCalc100NsTicks((timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
 	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
 	    curPerfCounter.QuadPart);
 
     tdiff = vt0 - curFileTime; /* discrepancy between virtual and real-time */
+    if (tdiff >= 10000000 || tdiff <= -10000000) {
+	printf("---!!!!!!!---calibration ERR, tdiff %I64d\n", tdiff);
+    }
     /* 
      * If calibration still not needed (check for possible time-switch). Note, that
      * NativeGetMicroseconds checks calibNextTime also, be sure it does not overflow.
      * Calibrate immediately if we've too large discrepancy to the real-time (15.6 ms).
      */
+#if 0
     if ( curFileTime < timeInfo.calibNextTime - (10000000/2) /* 0.5 sec (in 100-ns ticks). */
       && timeInfo.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between (time-switch?) */
-      && tdiff > -156000 && tdiff < 156000
+      && tdiff > -156000 && tdiff < 156000 /* small discrepancy */
+      && (tdiff >= 0 && tdiff <= lastDiff / 3 * 2 || tdiff < 0 && tdiff >= lastDiff / 3 * 2) /* more precise now */
     ) {
     	/* again in next one second */
-//    	printf("-------------calibration end, not needed. ------ cur:%I64d - next:%I64d (d: %I64d) ------\n", curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
+    	printf("-------------calibration end, tdiff %I64d, *** not needed. (next in: %I64d) ------\n", tdiff, curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
+	lastDiff = tdiff;
 	return;
     }
-    
+#endif
     /*
      * We devide by timeInfo.lastCC.counterFreq in several places. That
      * value should always be positive on a correctly functioning system. But
@@ -1331,9 +1342,26 @@ UpdateTimeEachSecond(void)
 #if 0
     estFreq = AccumulateSample(curPerfCounter.QuadPart, curFileTime);
 #else
-    estFreq = 10000000 * (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter) / (vt0 - timeInfo.lastCC.fileTime);
-    printf("------**-----calibration estimated, tdiff: %I64d, cntrDiff:%I64d\n", tdiff, (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter));
-    printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter.QuadPart, estFreq, estFreq - timeInfo.lastCC.counterFreq);
+    vt1 = curFileTime - timeInfo.lastCC.fileTime;
+    if (vt1) {
+	estFreq = 10000000 * (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter) / vt1;
+#if 1
+	
+	/* 
+	 * Minimize influence of estFreq if tdiff falls (in relation to last difference),
+	 * with dual falling speed. This indicates better choice of lastCC.counterFreq.
+	 */
+	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
+	    printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
+	    estFreq = (estFreq + timeInfo.lastCC.counterFreq * 2) / 3;
+	    printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
+	}
+#endif
+    } else {
+    	estFreq = timeInfo.lastCC.counterFreq;
+    }
+    //printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estFreq > timeInfo.lastCC.counterFreq) ? "^^^" : "vvv", (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter));
+    //printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter.QuadPart, estFreq, estFreq - timeInfo.lastCC.counterFreq);
 #endif
 
     driftBack = 0;
@@ -1360,6 +1388,7 @@ UpdateTimeEachSecond(void)
     	/* jump to current system time, use curent estimated frequency */
     	vt0 = curFileTime;
     	timeInfo.lastUsedTime = 0; /* reset last used time */
+    	estFreq = timeInfo.nominalFreq.QuadPart;
     } else {
 	Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
 				 * step over 1 second. */
@@ -1377,16 +1406,25 @@ UpdateTimeEachSecond(void)
 
 	/* 
 	 * Average between estimated, 2 current and 5 drifted frequencies,
-	 * (do the soft drifting as possible)
+	 * (do the soft drifting as possible).
+	 * Minimize influence if tdiff falls (in relation to last difference)
 	 */
-	estFreq = (estFreq + 2 * timeInfo.lastCC.counterFreq + 5 * driftFreq) / 8;
+#if 0
+	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
+	    estFreq = (1 * estFreq + 2 * timeInfo.lastCC.counterFreq + 5 * driftFreq) / 8;
+	} else {
+	    estFreq = (3 * estFreq + 3 * timeInfo.lastCC.counterFreq + 2 * driftFreq) / 8;
+	}
+#else
+	estFreq = (estFreq + timeInfo.lastCC.counterFreq + driftFreq) / 3;
+#endif
     }
     
     /* 
-     * Avoid too large discrepancy from nominal frequency (0.6 %)
+     * Avoid too large discrepancy from nominal frequency (0.5%)
      */
-    if ( estFreq > (vt1 = (1000+3)*timeInfo.nominalFreq.QuadPart/1000)
-      || estFreq < (vt1 = (1000-3)*timeInfo.nominalFreq.QuadPart/1000)
+    if ( estFreq > (vt1 = (1000+5)*timeInfo.nominalFreq.QuadPart/1000)
+      || estFreq < (vt1 = (1000-5)*timeInfo.nominalFreq.QuadPart/1000)
     ) {
 	estFreq = vt1;
 	driftBack = vt0 > curFileTime;
@@ -1394,7 +1432,8 @@ UpdateTimeEachSecond(void)
     }
 
     /* If possible backwards time-drifts (larger divider now) */
-    if (driftBack || estFreq > timeInfo.lastCC.counterFreq) {
+    vt1 = 0;
+    if (1 || driftBack || estFreq > timeInfo.lastCC.counterFreq) {
 	Tcl_WideInt nt0, nt1;
 
 	/* 
@@ -1408,10 +1447,10 @@ UpdateTimeEachSecond(void)
 	 * just compare native time (in 100-ns) before and hereafter using 
 	 * previous/new calibrated values) and do a small adjustment
 	 */
-	nt0 = NativeCalc100NsTicks(timeInfo.lastCC.fileTime,
+	nt0 = NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
 		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
 		vt1);
-	nt1 = NativeCalc100NsTicks(curFileTime,
+	nt1 = NativeCalc100NsTicks(vt0,
 		curPerfCounter.QuadPart, estFreq,
 		vt1);
 	vt1 = (nt0 - nt1); /* old time - new time */
@@ -1419,6 +1458,7 @@ UpdateTimeEachSecond(void)
 	    /* base time should jump forwards (the same virtual time using current values) */
 	    vt0 += vt1;
 	    tdiff += vt1;
+	    //////////////////////////////////////////estFreq = 10000000 * (vt0 - timeInfo.lastCC.perfCounter) / vt1;
 	}
     }
 
@@ -1430,11 +1470,14 @@ UpdateTimeEachSecond(void)
 	calibrationInterv += 10000000;
     }
 
+    lastDiff = tdiff;
+
     /* In lock commit new values to timeInfo (hold lock as short as possible) */
     EnterCriticalSection(&timeInfo.cs);
 
     timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
-    timeInfo.lastCC.fileTime = vt0;
+    timeInfo.lastCC.fileTime = curFileTime;
+    timeInfo.lastCC.virtTime = vt0;
     timeInfo.lastCC.counterFreq = estFreq;
 
     timeInfo.calibNextTime = curFileTime + calibrationInterv;
@@ -1444,7 +1487,7 @@ UpdateTimeEachSecond(void)
     //printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
     printf("-------------calibration end, tdiff %I64d, jump -- vt:%I64d - st:%I64d: %I64d, adj: %I64d\n", tdiff, 
     	vt0, curFileTime, (vt0 - curFileTime), vt1);
-    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
+    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
 #endif
 }
 
@@ -1545,6 +1588,14 @@ AccumulateSample(
 	    || FTdiff < 9000000 || FTdiff > 11000000) {
 	ResetCounterSamples(fileTime, perfCounter,
 		timeInfo.nominalFreq.QuadPart);
+#if 0
+	FTdiff = fileTime - timeInfo.lastCC.fileTime;
+	if (FTdiff) {
+	    estFreq = 10000000 * (perfCounter - timeInfo.lastCC.perfCounter) / FTdiff;
+	    printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", fileTime, perfCounter, estFreq, estFreq - timeInfo.lastCC.counterFreq);
+	}
+	return (timeInfo.nominalFreq.QuadPart + timeInfo.lastCC.counterFreq) / 2;
+#endif
 	return timeInfo.nominalFreq.QuadPart;
     } else {
 	/*
-- 
cgit v0.12


From 4881937a78ead2f68f732520535e20097b33a4fc Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:16 +0000
Subject: interim commit: time-drift backwards fix... (try to resolve using
 frequency factor)

---
 win/tclWinTime.c | 308 ++++++++++++++++---------------------------------------
 1 file changed, 86 insertions(+), 222 deletions(-)

diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index a30a952..c4206fe 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -17,12 +17,6 @@
 #define SECSPER4YEAR	(SECSPERYEAR * 4L + SECSPERDAY)
 
 /*
- * Number of samples over which to estimate the performance counter.
- */
-
-#define SAMPLES		64
-
-/*
  * The following arrays contain the day of year for the last day of each
  * month, where index 1 is January.
  */
@@ -75,22 +69,15 @@ typedef struct TimeInfo {
 	ULONGLONG fileTime;
 	ULONGLONG virtTime;
 	volatile		/* used also to compare calibration epoch */
-	LONGLONG perfCounter; 
+	LONGLONG perfCounter;
 	LONGLONG counterFreq;
     } lastCC;			/* Last data updated in calibration cycle */
     
+    int freqFactor;		/* Frequency factor (1000 - KHz, 1 - Hz) */
+    
     Tcl_WideInt lastUsedTime;	/* Last known (caller) virtual time in 100-ns
 				 * (used to avoid drifts after calibrate) */
 
-    /*
-     * Data used in developing the estimate of performance counter frequency
-     */
-
-    Tcl_WideUInt fileTimeSample[SAMPLES];
-				/* Last 64 samples of system time. */
-    Tcl_WideInt perfCounterSample[SAMPLES];
-				/* Last 64 samples of performance counter. */
-    int sampleNo;		/* Current sample number. */
 } TimeInfo;
 
 static TimeInfo timeInfo = {
@@ -114,10 +101,8 @@ static TimeInfo timeInfo = {
 	(LONGLONG) 0,
 	(LONGLONG) 0
     },
-    (Tcl_WideInt) 0,
-    { (Tcl_WideUInt) 0 },
-    { (Tcl_WideInt) 0 },
-    0
+    1000, /* KHz */
+    (Tcl_WideInt) 0
 };
 
 /*
@@ -139,10 +124,6 @@ static struct tm *	ComputeGMT(const time_t *tp);
 static void		StopCalibration(ClientData clientData);
 static DWORD WINAPI	CalibrationThread(LPVOID arg);
 static void 		UpdateTimeEachSecond(void);
-static void		ResetCounterSamples(Tcl_WideUInt fileTime,
-			    Tcl_WideInt perfCounter, Tcl_WideInt perfFreq);
-static Tcl_WideInt	AccumulateSample(Tcl_WideInt perfCounter,
-			    Tcl_WideUInt fileTime);
 static void		NativeScaleTime(Tcl_Time* timebuf,
 			    ClientData clientData);
 static Tcl_WideInt	NativeGetMicroseconds(void);
@@ -658,6 +639,12 @@ NativeGetMicroseconds(void)
 	    if (timeInfo.perfCounterAvailable) {
 		DWORD id;
 
+		/* Some systems having frequency in Hz, so save the factor here */
+		if (timeInfo.nominalFreq.QuadPart >= 1000000000) {
+		    /* assume that frequency in Hz, factor used only for tolerance */
+		    timeInfo.freqFactor = 1;
+		}
+
 		InitializeCriticalSection(&timeInfo.cs);
 		timeInfo.readyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 		timeInfo.exitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
@@ -1194,10 +1181,6 @@ CalibrationThread(
     timeInfo.lastCC.counterFreq = timeInfo.nominalFreq.QuadPart;
     timeInfo.lastCC.fileTime = timeInfo.lastCC.virtTime = GetSystemTimeAsVirtual();
 
-    ResetCounterSamples(timeInfo.lastCC.fileTime,
-	    timeInfo.lastCC.perfCounter,
-	    timeInfo.lastCC.counterFreq);
-
     /*
      * Calibrate first time and wake up the calling thread. 
      * When it wakes up, it will release the initialization lock.
@@ -1260,9 +1243,6 @@ UpdateTimeEachSecond(void)
     LARGE_INTEGER curPerfCounter;
 				/* Current value returned from
 				 * QueryPerformanceCounter. */
-    static Tcl_WideInt lastDiff = 0;
-    				/* Last difference between system clock and Tcl
-				 * time. */
     static int calibrationInterv = 10000000;
 				/* Calibration interval in 100-ns ticks (starts from 1s) */
     Tcl_WideInt curFileTime;	/* File time at the time this callback was
@@ -1271,27 +1251,30 @@ UpdateTimeEachSecond(void)
     int		driftBack;	/* Sign the virtual time may drift backwards */
     Tcl_WideInt vt0;		/* Tcl time right now. */
     Tcl_WideInt vt1;		/* Interim virtual time used during adjustments */
-    Tcl_WideInt tdiff;		/* Difference between system clock and Tcl
-				 * time. */
+    Tcl_WideInt tdiff,		/* Difference between system clock and Tcl time. */
+		lastDiff;	/* Difference of last calibration. */
 
-    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
     /*
      * Sample system time (from posix epoch) and performance counter.
      */
 
     curFileTime = GetSystemTimeAsVirtual();
     QueryPerformanceCounter(&curPerfCounter);
+    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d, pc-diff: %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq, curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter);
 
     /* 
-     * Current virtual time:
-     * vt0 = lastCC.fileTime +
+     * Current virtual time (using average between fileTime and virtTime):
+     * vt0 = (lastCC.fileTime + lastCC.virtTime) / 2 +
      *       10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
      */
-    vt0 = NativeCalc100NsTicks((timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
+    vt0 = NativeCalc100NsTicks(
+	    (timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
 	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
 	    curPerfCounter.QuadPart);
 
-    tdiff = vt0 - curFileTime; /* discrepancy between virtual and real-time */
+    /* Differences between virtual and real-time */
+    tdiff = vt0 - curFileTime;
+    lastDiff = timeInfo.lastCC.virtTime - timeInfo.lastCC.fileTime;
     if (tdiff >= 10000000 || tdiff <= -10000000) {
 	printf("---!!!!!!!---calibration ERR, tdiff %I64d\n", tdiff);
     }
@@ -1300,14 +1283,13 @@ UpdateTimeEachSecond(void)
      * NativeGetMicroseconds checks calibNextTime also, be sure it does not overflow.
      * Calibrate immediately if we've too large discrepancy to the real-time (15.6 ms).
      */
-#if 0
+#if 1
     if ( curFileTime < timeInfo.calibNextTime - (10000000/2) /* 0.5 sec (in 100-ns ticks). */
       && timeInfo.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between (time-switch?) */
-      && tdiff > -156000 && tdiff < 156000 /* small discrepancy */
-      && (tdiff >= 0 && tdiff <= lastDiff / 3 * 2 || tdiff < 0 && tdiff >= lastDiff / 3 * 2) /* more precise now */
+      && tdiff > -10000 && tdiff < 10000 /* very small discrepancy (1ms) */
     ) {
     	/* again in next one second */
-    	printf("-------------calibration end, tdiff %I64d, *** not needed. (next in: %I64d) ------\n", tdiff, curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
+    	//printf("-------------calibration end, tdiff %I64d, *** not needed. (next in: %I64d) ------\n", tdiff, curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
 	lastDiff = tdiff;
 	return;
     }
@@ -1330,39 +1312,7 @@ UpdateTimeEachSecond(void)
      * Several things may have gone wrong here that have to be checked for.
      *  (1) The performance counter may have jumped.
      *  (2) The system clock may have been reset.
-     *
-     * In either case, we'll need to reinitialize the circular buffer with
-     * samples relative to the current system time and the NOMINAL performance
-     * frequency (not the actual, because the actual has probably run slow in
-     * the first case). Our estimated frequency will be the nominal frequency.
-     *
-     * Store the current sample into the circular buffer of samples, and
-     * estimate the performance counter frequency.
      */
-#if 0
-    estFreq = AccumulateSample(curPerfCounter.QuadPart, curFileTime);
-#else
-    vt1 = curFileTime - timeInfo.lastCC.fileTime;
-    if (vt1) {
-	estFreq = 10000000 * (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter) / vt1;
-#if 1
-	
-	/* 
-	 * Minimize influence of estFreq if tdiff falls (in relation to last difference),
-	 * with dual falling speed. This indicates better choice of lastCC.counterFreq.
-	 */
-	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
-	    printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
-	    estFreq = (estFreq + timeInfo.lastCC.counterFreq * 2) / 3;
-	    printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
-	}
-#endif
-    } else {
-    	estFreq = timeInfo.lastCC.counterFreq;
-    }
-    //printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estFreq > timeInfo.lastCC.counterFreq) ? "^^^" : "vvv", (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter));
-    //printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter.QuadPart, estFreq, estFreq - timeInfo.lastCC.counterFreq);
-#endif
 
     driftBack = 0;
 
@@ -1373,10 +1323,10 @@ UpdateTimeEachSecond(void)
      * Ideally, we would like to drift the clock into place over a period of 2
      * sec, so that virtual time 2 sec from now will be
      *
-     * vt1 = 20000000 + curFileTime
+     * vt1 = 10000000 + curFileTime
      *
      * The frequency that we need to use to drift the counter back into place
-     * is estFreq * 20000000 / (vt1 - vt0)
+     * is estFreq * 10000000 / (vt1 - vt0)
      *
      * If we've gotten more than a second away from system time, then drifting
      * the clock is going to be pretty hopeless. Just let it jump. Otherwise,
@@ -1384,18 +1334,47 @@ UpdateTimeEachSecond(void)
      */
 
     if (tdiff > 10000000 || tdiff < -10000000) {
-    	/* More as a second difference, so could be a time-switch
+    	/* More as a second difference, so could be a time-switch (reset)
     	/* jump to current system time, use curent estimated frequency */
     	vt0 = curFileTime;
     	timeInfo.lastUsedTime = 0; /* reset last used time */
     	estFreq = timeInfo.nominalFreq.QuadPart;
     } else {
+
 	Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
 				 * step over 1 second. */
 
-    	/* calculate new frequency and estimate drift to the next second */
-	vt1 = 20000000 + curFileTime;
-	driftFreq = (estFreq * 20000000 / (vt1 - vt0));
+	/*
+	 * Estimate current frequency corresponding current time / counter.
+	 */
+
+	vt1 = curFileTime - timeInfo.lastCC.fileTime;
+	if (vt1 > 0) {
+	    estFreq = (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter) * 10000000 / vt1;
+
+	    /* 
+	     * Minimize influence of estFreq if tdiff falls (in relation to 
+	     * last difference), with dual falling speed. This indicates better
+	     * choice of lastCC.counterFreq.
+	     */
+	    if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
+		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
+		estFreq = (estFreq + timeInfo.lastCC.counterFreq * 2) / 3;
+		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
+	    }
+	} else {
+	    estFreq = timeInfo.lastCC.counterFreq;
+	}
+	printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estFreq > timeInfo.lastCC.counterFreq) ? "^^^" : "vvv", (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter));
+	printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d, to-nomin: %I64d\n", curFileTime, curPerfCounter.QuadPart, estFreq, estFreq - timeInfo.lastCC.counterFreq, estFreq - timeInfo.nominalFreq.QuadPart);
+
+#if 1
+    	/*
+    	 * Calculate new frequency and estimate drift to the next second
+    	 */
+
+	vt1 = 10000000 + curFileTime;
+	driftFreq = estFreq * 10000000 / (vt1 - vt0);
 	/* 
 	 * Avoid too large drifts (only half of the current difference),
 	 * that allows also be more accurate (aspire to the smallest tdiff),
@@ -1404,6 +1383,10 @@ UpdateTimeEachSecond(void)
 	driftFreq = timeInfo.lastCC.counterFreq +
 		(driftFreq - timeInfo.lastCC.counterFreq) / 2;
 
+	printf("------**-----calibration lastFreq: %I64d\n", timeInfo.lastCC.counterFreq);
+	printf("------**-----calibration estFreq:  %I64d\n", estFreq);
+	printf("------**-----calibration driftFreq:%I64d\n", driftFreq);
+
 	/* 
 	 * Average between estimated, 2 current and 5 drifted frequencies,
 	 * (do the soft drifting as possible).
@@ -1418,6 +1401,10 @@ UpdateTimeEachSecond(void)
 #else
 	estFreq = (estFreq + timeInfo.lastCC.counterFreq + driftFreq) / 3;
 #endif
+
+#else
+	estFreq = (estFreq + timeInfo.lastCC.counterFreq) / 2;
+#endif
     }
     
     /* 
@@ -1426,14 +1413,22 @@ UpdateTimeEachSecond(void)
     if ( estFreq > (vt1 = (1000+5)*timeInfo.nominalFreq.QuadPart/1000)
       || estFreq < (vt1 = (1000-5)*timeInfo.nominalFreq.QuadPart/1000)
     ) {
-	estFreq = vt1;
-	driftBack = vt0 > curFileTime;
-	vt0 = curFileTime; /* too large - just reset */
+	/* Some systems having frequency in Hz, so fewer tolerant (1.5%) */
+	if ( timeInfo.freqFactor == 1000 /* frequency in KHz */
+	  || ( estFreq > (vt1 = (1000+15)*timeInfo.nominalFreq.QuadPart/1000)
+	    || estFreq < (vt1 = (1000-15)*timeInfo.nominalFreq.QuadPart/1000)
+	  )
+	) {
+	    estFreq = vt1;
+	    driftBack = vt0 > curFileTime;
+	    vt0 = curFileTime; /* too large - just reset */
+	    printf("************ too large: %I64d\n", estFreq);
+	}
     }
 
     /* If possible backwards time-drifts (larger divider now) */
     vt1 = 0;
-    if (1 || driftBack || estFreq > timeInfo.lastCC.counterFreq) {
+    if (driftBack || estFreq > timeInfo.lastCC.counterFreq) {
 	Tcl_WideInt nt0, nt1;
 
 	/* 
@@ -1463,15 +1458,14 @@ UpdateTimeEachSecond(void)
     }
 
     /* if still precise enough, grow calibration interval up to 10 seconds */
-    if (tdiff < -156000 || tdiff > 156000 /* 15.6-ms */) {
-	/* too long drift - reset calibration interval to 1 second */
-	calibrationInterv = 10000000;
-    } else if (calibrationInterv < 10*10000000) {
-	calibrationInterv += 10000000;
+    if ( timeInfo.freqFactor == 1000 ) { /* frequency in KHz */
+	if (tdiff < -100000 || tdiff > 100000 /* 10-ms */) {
+	    /* too long drift - reset calibration interval to 1 second */
+	    calibrationInterv = 10000000;
+	} else if (calibrationInterv < 10*10000000) {
+	    calibrationInterv += 10000000;
+	}
     }
-
-    lastDiff = tdiff;
-
     /* In lock commit new values to timeInfo (hold lock as short as possible) */
     EnterCriticalSection(&timeInfo.cs);
 
@@ -1494,136 +1488,6 @@ UpdateTimeEachSecond(void)
 /*
  *----------------------------------------------------------------------
  *
- * ResetCounterSamples --
- *
- *	Fills the sample arrays in 'timeInfo' with dummy values that will
- *	yield the current performance counter and frequency.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The array of samples is filled in so that it appears that there are
- *	SAMPLES samples at one-second intervals, separated by precisely the
- *	given frequency.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-ResetCounterSamples(
-    Tcl_WideUInt fileTime,	/* Current file time */
-    Tcl_WideInt perfCounter,	/* Current performance counter */
-    Tcl_WideInt perfFreq)	/* Target performance frequency */
-{
-    int i;
-    for (i=SAMPLES-1 ; i>=0 ; --i) {
-	timeInfo.perfCounterSample[i] = perfCounter;
-	timeInfo.fileTimeSample[i] = fileTime;
-	perfCounter -= perfFreq;
-	fileTime -= 10000000;
-    }
-    timeInfo.sampleNo = 0;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * AccumulateSample --
- *
- *	Updates the circular buffer of performance counter and system time
- *	samples with a new data point.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The new data point replaces the oldest point in the circular buffer,
- *	and the descriptive statistics are updated to accumulate the new
- *	point.
- *
- * Several things may have gone wrong here that have to be checked for.
- *  (1) The performance counter may have jumped.
- *  (2) The system clock may have been reset.
- *
- * In either case, we'll need to reinitialize the circular buffer with samples
- * relative to the current system time and the NOMINAL performance frequency
- * (not the actual, because the actual has probably run slow in the first
- * case).
- */
-
-static Tcl_WideInt
-AccumulateSample(
-    Tcl_WideInt perfCounter,
-    Tcl_WideUInt fileTime)
-{
-    Tcl_WideUInt workFTSample;	/* File time sample being removed from or
-				 * added to the circular buffer. */
-    Tcl_WideInt workPCSample;	/* Performance counter sample being removed
-				 * from or added to the circular buffer. */
-    Tcl_WideUInt lastFTSample;	/* Last file time sample recorded */
-    Tcl_WideInt lastPCSample;	/* Last performance counter sample recorded */
-    Tcl_WideInt FTdiff;		/* Difference between last FT and current */
-    Tcl_WideInt PCdiff;		/* Difference between last PC and current */
-    Tcl_WideInt estFreq;	/* Estimated performance counter frequency */
-
-    /*
-     * Test for jumps and reset the samples if we have one.
-     */
-
-    if (timeInfo.sampleNo == 0) {
-	lastPCSample =
-		timeInfo.perfCounterSample[timeInfo.sampleNo + SAMPLES - 1];
-	lastFTSample =
-		timeInfo.fileTimeSample[timeInfo.sampleNo + SAMPLES - 1];
-    } else {
-	lastPCSample = timeInfo.perfCounterSample[timeInfo.sampleNo - 1];
-	lastFTSample = timeInfo.fileTimeSample[timeInfo.sampleNo - 1];
-    }
-
-    PCdiff = perfCounter - lastPCSample;
-    FTdiff = fileTime - lastFTSample;
-    if (PCdiff < timeInfo.nominalFreq.QuadPart * 9 / 10
-	    || PCdiff > timeInfo.nominalFreq.QuadPart * 11 / 10
-	    || FTdiff < 9000000 || FTdiff > 11000000) {
-	ResetCounterSamples(fileTime, perfCounter,
-		timeInfo.nominalFreq.QuadPart);
-#if 0
-	FTdiff = fileTime - timeInfo.lastCC.fileTime;
-	if (FTdiff) {
-	    estFreq = 10000000 * (perfCounter - timeInfo.lastCC.perfCounter) / FTdiff;
-	    printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", fileTime, perfCounter, estFreq, estFreq - timeInfo.lastCC.counterFreq);
-	}
-	return (timeInfo.nominalFreq.QuadPart + timeInfo.lastCC.counterFreq) / 2;
-#endif
-	return timeInfo.nominalFreq.QuadPart;
-    } else {
-	/*
-	 * Estimate the frequency.
-	 */
-
-	workPCSample = timeInfo.perfCounterSample[timeInfo.sampleNo];
-	workFTSample = timeInfo.fileTimeSample[timeInfo.sampleNo];
-	estFreq = 10000000 * (perfCounter - workPCSample)
-		/ (fileTime - workFTSample);
-	timeInfo.perfCounterSample[timeInfo.sampleNo] = perfCounter;
-	timeInfo.fileTimeSample[timeInfo.sampleNo] = (Tcl_WideInt) fileTime;
-
-	/*
-	 * Advance the sample number.
-	 */
-
-	if (++timeInfo.sampleNo >= SAMPLES) {
-	    timeInfo.sampleNo = 0;
-	}
-
-	return estFreq;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * TclpGmtime --
  *
  *	Wrapper around the 'gmtime' library function to make it thread safe.
-- 
cgit v0.12


From 91fe05d17b9acc7c807e3fdd32e068aa24426817 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:20 +0000
Subject: interim commit: time-drift backwards fix... (try to resolve using
 counter variance + frequency factor)

---
 win/tclWinTime.c | 355 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 187 insertions(+), 168 deletions(-)

diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index c4206fe..f8b0712 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -36,6 +36,20 @@ typedef struct ThreadSpecificData {
 static Tcl_ThreadDataKey dataKey;
 
 /*
+ * The following values are used for calculating virtual time. Virtual
+ * time is always equal to:
+ *    virtTime + (currentPerfCounter - perfCounter + cntrVariance)
+ *			* 10000000 / nominalFreq
+ */
+typedef struct TimeCalibInfo {
+    ULONGLONG fileTime;		/* Last real time (in 100-ns) */
+    ULONGLONG virtTime;		/* Last virtual time (in 100-ns) */
+    LONGLONG perfCounter;	/* QPC value of last calibration time */
+    LONGLONG cntrVariance;	/* Current calculated deviation (compensation) */
+    Tcl_WideInt calibNextTime;	/* Next time of calibration (in 100-ns ticks) */
+} TimeCalibInfo;
+
+/*
  * Data for managing high-resolution timers.
  */
 
@@ -45,7 +59,6 @@ typedef struct TimeInfo {
 				 * initialized. */
     int perfCounterAvailable;	/* Flag == 1 if the hardware has a performance
 				 * counter. */
-    Tcl_WideInt calibNextTime;	/* Next time of calibration (in 100-ns ticks) */
     HANDLE calibrationThread;	/* Handle to the thread that keeps the virtual
 				 * clock calibrated. */
     HANDLE readyEvent;		/* System event used to trigger the requesting
@@ -53,27 +66,21 @@ typedef struct TimeInfo {
 				 * is initialized for the first time. */
     HANDLE exitEvent; 		/* Event to signal out of an exit handler to
 				 * tell the calibration loop to terminate. */
-    LARGE_INTEGER nominalFreq;	/* Nominal frequency of the system performance
+    LONGLONG nominalFreq;	/* Nominal frequency of the system performance
 				 * counter, that is, the value returned from
 				 * QueryPerformanceFrequency. */
+    int	freqFactor;		/* Frequency factor (1 - KHz, 1000 - Hz) */
     LARGE_INTEGER posixEpoch;	/* Posix epoch expressed as 100-ns ticks since
 				 * the windows epoch. */
     /*
      * The following values are used for calculating virtual time. Virtual
      * time is always equal to:
-     *    fileTime + (current perf counter - lastCounter)
-     *				* 10000000 / counterFreq
+     *    virtTime + ( (currentPerfCounter - perfCounter) * 10000000
+     *				+ cntrVariance) / nominalFreq
      */
 
-    struct {
-	ULONGLONG fileTime;
-	ULONGLONG virtTime;
-	volatile		/* used also to compare calibration epoch */
-	LONGLONG perfCounter;
-	LONGLONG counterFreq;
-    } lastCC;			/* Last data updated in calibration cycle */
-    
-    int freqFactor;		/* Frequency factor (1000 - KHz, 1 - Hz) */
+    TimeCalibInfo lastCC;	/* Last data updated in calibration cycle */
+    volatile LONG calibEpoch;	/* Calibration epoch */
     
     Tcl_WideInt lastUsedTime;	/* Last known (caller) virtual time in 100-ns
 				 * (used to avoid drifts after calibrate) */
@@ -84,24 +91,24 @@ static TimeInfo timeInfo = {
     { NULL, 0, 0, NULL, NULL, 0 },
     0,
     0,
-    (Tcl_WideInt) 0,
     (HANDLE) NULL,
     (HANDLE) NULL,
     (HANDLE) NULL,
+    (LONGLONG) 0,
+    1, /* for frequency in KHz */
 #ifdef HAVE_CAST_TO_UNION
     (LARGE_INTEGER) (Tcl_WideInt) 0,
-    (LARGE_INTEGER) (Tcl_WideInt) 0,
 #else
     {0, 0},
-    {0, 0},
 #endif
     {
+	(Tcl_WideInt) 0,
 	(ULONGLONG) 0,
 	(ULONGLONG) 0,
 	(LONGLONG) 0,
 	(LONGLONG) 0
     },
-    1000, /* KHz */
+    (LONG) 0,
     (Tcl_WideInt) 0
 };
 
@@ -141,16 +148,36 @@ ClientData tclTimeClientData = NULL;
 /*
  *----------------------------------------------------------------------
  *
+ * NativePerformanceCounter --
+ *
+ *	Used instead of QueryPerformanceCounter to consider frequency factor.
+ *
+ * Results:
+ *	Returns QPC corresponding current frequency factor.
+ *
+ *----------------------------------------------------------------------
+ */
+static inline LONGLONG
+NativePerformanceCounter(void) {
+    LARGE_INTEGER curCounter;
+    QueryPerformanceCounter(&curCounter);
+    return (curCounter.QuadPart / timeInfo.freqFactor);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * NativeCalc100NsTicks --
  *
  *	Calculate the current system time in 100-ns ticks since posix epoch,
  *	for current performance counter (curCounter), using given calibrated values.
  *
- *	vt = lastCC.virtTime + 
- *	     10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
+ *	vt = lastCC.virtTime 
+ *		+ ( (curPerfCounter - lastCC.perfCounter) * 10000000
+ * 			+ lastCC.cntrVariance ) / nominalFreq
  *
  * Results:
- *	Returns the wide integer with number of microseconds from the epoch.
+ *	Returns the wide integer with number of 100-ns ticks from the epoch.
  *
  * Side effects:
  *	None
@@ -162,11 +189,11 @@ static inline Tcl_WideInt
 NativeCalc100NsTicks(
     ULONGLONG ccVirtTime,
     LONGLONG ccPerfCounter,
-    LONGLONG ccCounterFreq,
+    LONGLONG ccCntrVariance,
     LONGLONG curCounter
 ) {
-    return ccVirtTime + 
-	((curCounter - ccPerfCounter) * 10000000 / ccCounterFreq);
+    return ccVirtTime + ( (curCounter - ccPerfCounter) * 10000000
+				+ ccCntrVariance ) / timeInfo.nominalFreq;
 }
 
 /*
@@ -366,9 +393,9 @@ Tcl_WideInt
 TclpGetMicroseconds(void)
 {
     static Tcl_WideInt prevUS = 0;
-    static Tcl_WideInt fileTimeLastCall, perfCounterLastCall, curCounterFreq;
-    static LARGE_INTEGER prevPerfCounter;
-    LARGE_INTEGER newPerfCounter;
+    static Tcl_WideInt fileTimeLastCall, perfCounterLastCall, curCntrVariance;
+    static LONGLONG prevPerfCounter;
+    LONGLONG newPerfCounter;
 
     Tcl_WideInt usecSincePosixEpoch;
 
@@ -391,25 +418,25 @@ TclpGetMicroseconds(void)
 	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!no-native-ms!!!!!!!!!!!\n");
     }
 
-	QueryPerformanceCounter(&newPerfCounter);
+	newPerfCounter = NativePerformanceCounter();
 
     	if (prevUS && usecSincePosixEpoch < prevUS) {
-    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! pre-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", fileTimeLastCall, perfCounterLastCall, prevPerfCounter.QuadPart, curCounterFreq,
+    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! pre-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", fileTimeLastCall, perfCounterLastCall, prevPerfCounter, curCntrVariance,
     	    	NativeCalc100NsTicks(fileTimeLastCall,
-		perfCounterLastCall, curCounterFreq,
-		prevPerfCounter.QuadPart));
-    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, newPerfCounter.QuadPart, timeInfo.lastCC.counterFreq,
+		perfCounterLastCall, curCntrVariance,
+		prevPerfCounter));
+    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, newPerfCounter, timeInfo.lastCC.cntrVariance,
     	    	NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
-		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
-		newPerfCounter.QuadPart));
+		timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
+		newPerfCounter));
 	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! prev: %I64d - now: %I64d (%I64d usec)\n", prevUS, usecSincePosixEpoch, usecSincePosixEpoch - prevUS);
 	    Tcl_Panic("Time running backwards!!!");
     	}
     	prevUS = usecSincePosixEpoch;
 	fileTimeLastCall = timeInfo.lastCC.virtTime;
 	perfCounterLastCall = timeInfo.lastCC.perfCounter;
-	curCounterFreq = timeInfo.lastCC.counterFreq;
-	prevPerfCounter.QuadPart = newPerfCounter.QuadPart;
+	curCntrVariance = timeInfo.lastCC.cntrVariance;
+	prevPerfCounter = newPerfCounter;
 
 	return usecSincePosixEpoch;
 }
@@ -546,14 +573,32 @@ NativeGetMicroseconds(void)
      */
 
     if (!timeInfo.initialized) {
+    	LARGE_INTEGER nominalFreq;
 	TclpInitLock();
 	if (!timeInfo.initialized) {
 
 	    timeInfo.posixEpoch.LowPart = 0xD53E8000;
 	    timeInfo.posixEpoch.HighPart = 0x019DB1DE;
 
-	    timeInfo.perfCounterAvailable =
-		    QueryPerformanceFrequency(&timeInfo.nominalFreq);
+	    if ((timeInfo.perfCounterAvailable =
+		    QueryPerformanceFrequency(&nominalFreq))
+	    ) {
+		timeInfo.nominalFreq = nominalFreq.QuadPart;
+
+		/*
+		 * We devide by timeInfo.nominalFreq in several places.
+		 */
+		if (timeInfo.nominalFreq == 0) {
+		    timeInfo.perfCounterAvailable = FALSE;
+		}
+		/* Some systems having frequency in Hz, so save the factor here */
+		if (timeInfo.nominalFreq >= 1000000000 
+			&& (timeInfo.nominalFreq % 1000) == 0) {
+		    timeInfo.nominalFreq /= 1000;
+		    /* assume that frequency in Hz, factor used only for tolerance */
+		    timeInfo.freqFactor = 1000;
+		}
+	    }
 
 	    /*
 	     * Some hardware abstraction layers use the CPU clock in place of
@@ -587,10 +632,10 @@ NativeGetMicroseconds(void)
 		    /*
 		     * The following lines would do an exact match on crystal
 		     * frequency:
-		     * && timeInfo.nominalFreq.QuadPart != (Tcl_WideInt)1193182
-		     * && timeInfo.nominalFreq.QuadPart != (Tcl_WideInt)3579545
+		     * && timeInfo.nominalFreq != 1193182
+		     * && timeInfo.nominalFreq != 3579545
 		     */
-		    && timeInfo.nominalFreq.QuadPart > (Tcl_WideInt) 15000000){
+		    && timeInfo.nominalFreq > 15000000){
 		/*
 		 * As an exception, if every logical processor on the system
 		 * is on the same chip, we use the performance counter anyway,
@@ -639,12 +684,6 @@ NativeGetMicroseconds(void)
 	    if (timeInfo.perfCounterAvailable) {
 		DWORD id;
 
-		/* Some systems having frequency in Hz, so save the factor here */
-		if (timeInfo.nominalFreq.QuadPart >= 1000000000) {
-		    /* assume that frequency in Hz, factor used only for tolerance */
-		    timeInfo.freqFactor = 1;
-		}
-
 		InitializeCriticalSection(&timeInfo.cs);
 		timeInfo.readyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 		timeInfo.exitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
@@ -668,42 +707,47 @@ NativeGetMicroseconds(void)
 	TclpInitUnlock();
     }
 
-    if (timeInfo.perfCounterAvailable && timeInfo.lastCC.counterFreq!=0) {
+    if (timeInfo.perfCounterAvailable) {
 
-	static struct {
-	    ULONGLONG virtTime;
-	    volatile		/* don't optimize */
-	    LONGLONG  perfCounter;
-	    LONGLONG  counterFreq;
-	    Tcl_WideInt calibNextTime;
-	} cc = {0, 0, 0, 0};	/* Copy with current data of calibration cycle */
+	/* Copies with current data of calibration cycle */
+	static TimeCalibInfo commonCC;
+	static volatile LONG calibEpoch;
+	TimeCalibInfo cc;
+	volatile LONG ccEpoch;
 
-	LARGE_INTEGER curCounter;
-				/* Current performance counter. */
+	LONGLONG curCounter;	/* Current performance counter. */
 
 	/*
-	 * Hold time section locked as short as possible
+	 * Try to acquire data without lock (same epoch at end of copy process).
 	 */
-	if (cc.perfCounter != timeInfo.lastCC.perfCounter) {
-	    EnterCriticalSection(&timeInfo.cs);
-	    if (cc.perfCounter != timeInfo.lastCC.perfCounter) {
-		cc.perfCounter = timeInfo.lastCC.perfCounter;
-		cc.virtTime = timeInfo.lastCC.virtTime;
-		cc.counterFreq = timeInfo.lastCC.counterFreq;
-		cc.calibNextTime = timeInfo.calibNextTime;
+	do {
+	    ccEpoch = calibEpoch;
+	    memcpy(&cc, &commonCC, sizeof(cc));
+	    /*
+	     * Hold time section locked as short as possible
+	     */
+	    if (InterlockedCompareExchange(&timeInfo.calibEpoch, 
+				calibEpoch, calibEpoch) != calibEpoch) {
+		EnterCriticalSection(&timeInfo.cs);
+		if (calibEpoch != timeInfo.calibEpoch) {
+		    memcpy(&commonCC, &timeInfo.lastCC, sizeof(commonCC));
+		}
+		calibEpoch = timeInfo.calibEpoch;
+		LeaveCriticalSection(&timeInfo.cs);
 	    }
-	    LeaveCriticalSection(&timeInfo.cs);
-	}
+
+	} while (InterlockedCompareExchange(&timeInfo.calibEpoch, 
+			ccEpoch, ccEpoch) != ccEpoch);
 
 	/*
 	 * Query the performance counter and use it to calculate the current
 	 * time.
 	 */
-	QueryPerformanceCounter(&curCounter);
+	curCounter = NativePerformanceCounter();
 
 	/* Calibrated file-time is saved from posix in 100-ns ticks */
 	curTime = NativeCalc100NsTicks(cc.virtTime,
-		cc.perfCounter, cc.counterFreq, curCounter.QuadPart);
+		cc.perfCounter, cc.cntrVariance, curCounter);
 
 	/* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
 	if ( (lastTime = timeInfo.lastUsedTime)
@@ -728,7 +772,7 @@ NativeGetMicroseconds(void)
 	    timeInfo.lastUsedTime = curTime;
 	    return curTime / 10;
 	}
-	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!calibration-error!!!! cur: %I64d - call: %I64d (%I64d) -- prev: %I64d - now: %I64d (%I64d)\n", curTime, cc.calibNextTime, cc.calibNextTime - curTime, cc.perfCounter, curCounter.QuadPart, curCounter.QuadPart - cc.perfCounter);
+	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!calibration-error!!!! cur: %I64d - call: %I64d (%I64d) -- prev: %I64d - now: %I64d (%I64d)\n", curTime, cc.calibNextTime, cc.calibNextTime - curTime, cc.perfCounter, curCounter, curCounter - cc.perfCounter);
     }
 
     /*
@@ -1174,11 +1218,7 @@ CalibrationThread(
      * Get initial system time and performance counter.
      */
 
-    LARGE_INTEGER curPerfCounter;
-
-    QueryPerformanceCounter(&curPerfCounter);
-    timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
-    timeInfo.lastCC.counterFreq = timeInfo.nominalFreq.QuadPart;
+    timeInfo.lastCC.perfCounter = NativePerformanceCounter();
     timeInfo.lastCC.fileTime = timeInfo.lastCC.virtTime = GetSystemTimeAsVirtual();
 
     /*
@@ -1240,15 +1280,15 @@ CalibrationThread(
 static void
 UpdateTimeEachSecond(void)
 {
-    LARGE_INTEGER curPerfCounter;
+    LONGLONG curPerfCounter;
 				/* Current value returned from
-				 * QueryPerformanceCounter. */
+				 * NativePerformanceCounter. */
     static int calibrationInterv = 10000000;
 				/* Calibration interval in 100-ns ticks (starts from 1s) */
     Tcl_WideInt curFileTime;	/* File time at the time this callback was
 				 * scheduled. */
-    Tcl_WideInt estFreq;	/* Estimated perf counter frequency. */
-    int		driftBack;	/* Sign the virtual time may drift backwards */
+    LONGLONG	estVariance,	/* Estimated variance to compensate ipmact of */
+		driftVariance;	/* deviations of perfomance counters. */
     Tcl_WideInt vt0;		/* Tcl time right now. */
     Tcl_WideInt vt1;		/* Interim virtual time used during adjustments */
     Tcl_WideInt tdiff,		/* Difference between system clock and Tcl time. */
@@ -1259,18 +1299,19 @@ UpdateTimeEachSecond(void)
      */
 
     curFileTime = GetSystemTimeAsVirtual();
-    QueryPerformanceCounter(&curPerfCounter);
-    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d, pc-diff: %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq, curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter);
+    curPerfCounter = NativePerformanceCounter();
+    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d / %I64d, pc-diff: %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.nominalFreq, curPerfCounter - timeInfo.lastCC.perfCounter);
 
     /* 
-     * Current virtual time (using average between fileTime and virtTime):
-     * vt0 = (lastCC.fileTime + lastCC.virtTime) / 2 +
-     *       10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
+     * Current virtual time (using average between last fileTime and virtTime):
+     * vt0 = (lastCC.fileTime + lastCC.virtTime) / 2
+     *		+ ( (curPerfCounter - lastCC.perfCounter) * 10000000 
+     *			+ lastCC.cntrVariance) / nominalFreq
      */
     vt0 = NativeCalc100NsTicks(
 	    (timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
-	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
-	    curPerfCounter.QuadPart);
+	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
+	    curPerfCounter);
 
     /* Differences between virtual and real-time */
     tdiff = vt0 - curFileTime;
@@ -1284,29 +1325,16 @@ UpdateTimeEachSecond(void)
      * Calibrate immediately if we've too large discrepancy to the real-time (15.6 ms).
      */
 #if 1
-    if ( curFileTime < timeInfo.calibNextTime - (10000000/2) /* 0.5 sec (in 100-ns ticks). */
-      && timeInfo.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between (time-switch?) */
+    if ( curFileTime < timeInfo.lastCC.calibNextTime - (10000000/2) /* 0.5 sec (in 100-ns ticks). */
+      && timeInfo.lastCC.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between (time-switch?) */
       && tdiff > -10000 && tdiff < 10000 /* very small discrepancy (1ms) */
     ) {
     	/* again in next one second */
-    	//printf("-------------calibration end, tdiff %I64d, *** not needed. (next in: %I64d) ------\n", tdiff, curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
+    	printf("-------------calibration end, tdiff %I64d, *** not needed. (next in: %I64d) ------\n", tdiff, curFileTime, timeInfo.lastCC.calibNextTime, timeInfo.lastCC.calibNextTime - curFileTime);
 	lastDiff = tdiff;
 	return;
     }
 #endif
-    /*
-     * We devide by timeInfo.lastCC.counterFreq in several places. That
-     * value should always be positive on a correctly functioning system. But
-     * it is good to be defensive about such matters. So if something goes
-     * wrong and the value does goes to zero, we clear the
-     * timeInfo.perfCounterAvailable in order to cause the calibration thread
-     * to shut itself down, then return without additional processing.
-     */
-
-    if (timeInfo.lastCC.counterFreq == 0) {
-	timeInfo.perfCounterAvailable = 0;
-	return;
-    }
 
     /*
      * Several things may have gone wrong here that have to be checked for.
@@ -1314,8 +1342,6 @@ UpdateTimeEachSecond(void)
      *  (2) The system clock may have been reset.
      */
 
-    driftBack = 0;
-
     /*
      * We want to adjust things so that time appears to be continuous.
      * Virtual file time, right now, is vt0.
@@ -1338,54 +1364,66 @@ UpdateTimeEachSecond(void)
     	/* jump to current system time, use curent estimated frequency */
     	vt0 = curFileTime;
     	timeInfo.lastUsedTime = 0; /* reset last used time */
-    	estFreq = timeInfo.nominalFreq.QuadPart;
+    	estVariance = 0;
     } else {
 
-	Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
-				 * step over 1 second. */
-
 	/*
 	 * Estimate current frequency corresponding current time / counter.
 	 */
 
-	vt1 = curFileTime - timeInfo.lastCC.fileTime;
-	if (vt1 > 0) {
-	    estFreq = (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter) * 10000000 / vt1;
-
-	    /* 
-	     * Minimize influence of estFreq if tdiff falls (in relation to 
-	     * last difference), with dual falling speed. This indicates better
-	     * choice of lastCC.counterFreq.
-	     */
-	    if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
-		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
-		estFreq = (estFreq + timeInfo.lastCC.counterFreq * 2) / 3;
-		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
-	    }
+	if ((curFileTime - timeInfo.lastCC.fileTime) > (10000000 / 2)) {
+	    estVariance = (curFileTime - timeInfo.lastCC.fileTime) 
+		* timeInfo.nominalFreq
+		- (curPerfCounter- timeInfo.lastCC.perfCounter) * 10000000;
 	} else {
-	    estFreq = timeInfo.lastCC.counterFreq;
+	    estVariance = timeInfo.lastCC.cntrVariance;
 	}
-	printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estFreq > timeInfo.lastCC.counterFreq) ? "^^^" : "vvv", (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter));
-	printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d, to-nomin: %I64d\n", curFileTime, curPerfCounter.QuadPart, estFreq, estFreq - timeInfo.lastCC.counterFreq, estFreq - timeInfo.nominalFreq.QuadPart);
+
+	/* 
+	 * Minimize influence of estVariance if tdiff falls (in relation to
+	 * last difference), with dual falling speed. This indicates better
+	 * choice of lastCC.cntrVariance.
+	 */
+	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
+	    //printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
+	    estVariance = (estVariance + timeInfo.lastCC.cntrVariance) / 2;
+	    //printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
+	}
+	printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estVariance > timeInfo.lastCC.cntrVariance) ? "^^^" : "vvv", (curPerfCounter - timeInfo.lastCC.perfCounter));
+	printf("------**-----calibration estimated %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter, estVariance, estVariance - timeInfo.lastCC.cntrVariance);
 
 #if 1
     	/*
-    	 * Calculate new frequency and estimate drift to the next second
+    	 * Calculate new estimate drift variance to the next second
     	 */
 
-	vt1 = 10000000 + curFileTime;
-	driftFreq = estFreq * 10000000 / (vt1 - vt0);
+	vt1 = vt0 - timeInfo.lastCC.virtTime;
+	if (vt1 > (10000000 / 2)) {
+	    
+	    LONGLONG driftPerfCounter = curPerfCounter + 
+		    + (curPerfCounter - timeInfo.lastCC.perfCounter)
+			/ vt1 * (vt1 + 10000000);
+
+	    vt1 = NativeCalc100NsTicks(curFileTime,
+		curPerfCounter, estVariance,
+		driftPerfCounter);
+	    driftVariance = (vt1 - vt0) * timeInfo.nominalFreq
+		//- estVariance
+		- (driftPerfCounter - curPerfCounter) * 10000000;
+	} else {
+	    driftVariance = estVariance * 2;
+	}
 	/* 
 	 * Avoid too large drifts (only half of the current difference),
 	 * that allows also be more accurate (aspire to the smallest tdiff),
 	 * so then we can prolong calibration interval in such cases.
 	 */
-	driftFreq = timeInfo.lastCC.counterFreq +
-		(driftFreq - timeInfo.lastCC.counterFreq) / 2;
+	driftVariance = timeInfo.lastCC.cntrVariance +
+		(driftVariance - timeInfo.lastCC.cntrVariance) / 2;
 
-	printf("------**-----calibration lastFreq: %I64d\n", timeInfo.lastCC.counterFreq);
-	printf("------**-----calibration estFreq:  %I64d\n", estFreq);
-	printf("------**-----calibration driftFreq:%I64d\n", driftFreq);
+	printf("------**-----calibration cntrVariance: %I64d\n", timeInfo.lastCC.cntrVariance);
+	printf("------**-----calibration estVariance:  %I64d\n", estVariance);
+	printf("------**-----calibration driftVariance:%I64d\n", driftVariance);
 
 	/* 
 	 * Average between estimated, 2 current and 5 drifted frequencies,
@@ -1399,36 +1437,17 @@ UpdateTimeEachSecond(void)
 	    estFreq = (3 * estFreq + 3 * timeInfo.lastCC.counterFreq + 2 * driftFreq) / 8;
 	}
 #else
-	estFreq = (estFreq + timeInfo.lastCC.counterFreq + driftFreq) / 3;
+	estVariance = (estVariance + timeInfo.lastCC.cntrVariance + driftVariance) / 3;
 #endif
 
 #else
-	estFreq = (estFreq + timeInfo.lastCC.counterFreq) / 2;
+	estVariance = (estVariance + timeInfo.lastCC.cntrVariance) / 2;
 #endif
     }
     
-    /* 
-     * Avoid too large discrepancy from nominal frequency (0.5%)
-     */
-    if ( estFreq > (vt1 = (1000+5)*timeInfo.nominalFreq.QuadPart/1000)
-      || estFreq < (vt1 = (1000-5)*timeInfo.nominalFreq.QuadPart/1000)
-    ) {
-	/* Some systems having frequency in Hz, so fewer tolerant (1.5%) */
-	if ( timeInfo.freqFactor == 1000 /* frequency in KHz */
-	  || ( estFreq > (vt1 = (1000+15)*timeInfo.nominalFreq.QuadPart/1000)
-	    || estFreq < (vt1 = (1000-15)*timeInfo.nominalFreq.QuadPart/1000)
-	  )
-	) {
-	    estFreq = vt1;
-	    driftBack = vt0 > curFileTime;
-	    vt0 = curFileTime; /* too large - just reset */
-	    printf("************ too large: %I64d\n", estFreq);
-	}
-    }
-
     /* If possible backwards time-drifts (larger divider now) */
     vt1 = 0;
-    if (driftBack || estFreq > timeInfo.lastCC.counterFreq) {
+    if (estVariance < timeInfo.lastCC.cntrVariance) {
 	Tcl_WideInt nt0, nt1;
 
 	/* 
@@ -1436,17 +1455,17 @@ UpdateTimeEachSecond(void)
 	 * to avoid possible backwards drifts (adjust current base time).
 	 * This should affect at least next 10 ticks.
 	 */
-	vt1 = curPerfCounter.QuadPart + 10;
+	vt1 = curPerfCounter + 10;
 	/*
 	 * Be sure the clock ticks never backwards (avoid it by negative drifting)
 	 * just compare native time (in 100-ns) before and hereafter using 
 	 * previous/new calibrated values) and do a small adjustment
 	 */
 	nt0 = NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
-		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
+		timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
 		vt1);
 	nt1 = NativeCalc100NsTicks(vt0,
-		curPerfCounter.QuadPart, estFreq,
+		curPerfCounter, estVariance,
 		vt1);
 	vt1 = (nt0 - nt1); /* old time - new time */
 	if (vt1 > 0 && vt1 < 10000000 /* bypass time-switch */) {
@@ -1458,30 +1477,30 @@ UpdateTimeEachSecond(void)
     }
 
     /* if still precise enough, grow calibration interval up to 10 seconds */
-    if ( timeInfo.freqFactor == 1000 ) { /* frequency in KHz */
-	if (tdiff < -100000 || tdiff > 100000 /* 10-ms */) {
-	    /* too long drift - reset calibration interval to 1 second */
-	    calibrationInterv = 10000000;
-	} else if (calibrationInterv < 10*10000000) {
-	    calibrationInterv += 10000000;
-	}
+    if (tdiff < -100000 || tdiff > 100000 /* 10-ms */) {
+	/* too long drift - reset calibration interval to 1 second */
+	calibrationInterv = 10000000;
+    } else if (calibrationInterv < 10*10000000) {
+	calibrationInterv += 10000000;
     }
+
     /* In lock commit new values to timeInfo (hold lock as short as possible) */
     EnterCriticalSection(&timeInfo.cs);
 
-    timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
+    timeInfo.lastCC.perfCounter = curPerfCounter;
     timeInfo.lastCC.fileTime = curFileTime;
     timeInfo.lastCC.virtTime = vt0;
-    timeInfo.lastCC.counterFreq = estFreq;
+    timeInfo.lastCC.cntrVariance = estVariance;
+    timeInfo.lastCC.calibNextTime = curFileTime + calibrationInterv;
 
-    timeInfo.calibNextTime = curFileTime + calibrationInterv;
+    InterlockedIncrement(&timeInfo.calibEpoch);
 
     LeaveCriticalSection(&timeInfo.cs);
 #if 1
     //printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
     printf("-------------calibration end, tdiff %I64d, jump -- vt:%I64d - st:%I64d: %I64d, adj: %I64d\n", tdiff, 
     	vt0, curFileTime, (vt0 - curFileTime), vt1);
-    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
+    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d / %I64d\n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.nominalFreq);
 #endif
 }
 
-- 
cgit v0.12


From 27392e7566cec8dc9ae2695644c153c55d565b08 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:24 +0000
Subject: interim commit: amend with optimization

---
 win/tclWinTime.c | 212 +++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 159 insertions(+), 53 deletions(-)

diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index f8b0712..e956175 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -46,6 +46,7 @@ typedef struct TimeCalibInfo {
     ULONGLONG virtTime;		/* Last virtual time (in 100-ns) */
     LONGLONG perfCounter;	/* QPC value of last calibration time */
     LONGLONG cntrVariance;	/* Current calculated deviation (compensation) */
+    LONGLONG estFrequency;	/* Current estimated frequency */
     Tcl_WideInt calibNextTime;	/* Next time of calibration (in 100-ns ticks) */
 } TimeCalibInfo;
 
@@ -190,10 +191,11 @@ NativeCalc100NsTicks(
     ULONGLONG ccVirtTime,
     LONGLONG ccPerfCounter,
     LONGLONG ccCntrVariance,
+    LONGLONG ccEstFrequency,
     LONGLONG curCounter
 ) {
     return ccVirtTime + ( (curCounter - ccPerfCounter) * 10000000
-				+ ccCntrVariance ) / timeInfo.nominalFreq;
+				+ ccCntrVariance ) / ccEstFrequency;
 }
 
 /*
@@ -393,7 +395,7 @@ Tcl_WideInt
 TclpGetMicroseconds(void)
 {
     static Tcl_WideInt prevUS = 0;
-    static Tcl_WideInt fileTimeLastCall, perfCounterLastCall, curCntrVariance;
+    static Tcl_WideInt fileTimeLastCall, perfCounterLastCall, curCntrVariance, prevEstFrequency;
     static LONGLONG prevPerfCounter;
     LONGLONG newPerfCounter;
 
@@ -423,11 +425,11 @@ TclpGetMicroseconds(void)
     	if (prevUS && usecSincePosixEpoch < prevUS) {
     	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! pre-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", fileTimeLastCall, perfCounterLastCall, prevPerfCounter, curCntrVariance,
     	    	NativeCalc100NsTicks(fileTimeLastCall,
-		perfCounterLastCall, curCntrVariance,
+		perfCounterLastCall, curCntrVariance, prevEstFrequency,
 		prevPerfCounter));
     	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, newPerfCounter, timeInfo.lastCC.cntrVariance,
     	    	NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
-		timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
+		timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.lastCC.estFrequency,
 		newPerfCounter));
 	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! prev: %I64d - now: %I64d (%I64d usec)\n", prevUS, usecSincePosixEpoch, usecSincePosixEpoch - prevUS);
 	    Tcl_Panic("Time running backwards!!!");
@@ -436,6 +438,7 @@ TclpGetMicroseconds(void)
 	fileTimeLastCall = timeInfo.lastCC.virtTime;
 	perfCounterLastCall = timeInfo.lastCC.perfCounter;
 	curCntrVariance = timeInfo.lastCC.cntrVariance;
+	prevEstFrequency = timeInfo.lastCC.estFrequency;
 	prevPerfCounter = newPerfCounter;
 
 	return usecSincePosixEpoch;
@@ -747,7 +750,7 @@ NativeGetMicroseconds(void)
 
 	/* Calibrated file-time is saved from posix in 100-ns ticks */
 	curTime = NativeCalc100NsTicks(cc.virtTime,
-		cc.perfCounter, cc.cntrVariance, curCounter);
+		cc.perfCounter, cc.cntrVariance, cc.estFrequency, curCounter);
 
 	/* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
 	if ( (lastTime = timeInfo.lastUsedTime)
@@ -767,6 +770,9 @@ NativeGetMicroseconds(void)
 	 * loop should recover.
 	 */
 
+	
+	printf("********* %I64d\n", GetSystemTimeAsVirtual()); /* in 100-ns ticks */
+
 	if (curTime < cc.calibNextTime + 10000000 /* 1 sec (in 100-ns ticks). */) {
 	    /* save last used time */
 	    timeInfo.lastUsedTime = curTime;
@@ -1220,6 +1226,7 @@ CalibrationThread(
 
     timeInfo.lastCC.perfCounter = NativePerformanceCounter();
     timeInfo.lastCC.fileTime = timeInfo.lastCC.virtTime = GetSystemTimeAsVirtual();
+    timeInfo.lastCC.estFrequency = timeInfo.nominalFreq;
 
     /*
      * Calibrate first time and wake up the calling thread. 
@@ -1288,7 +1295,8 @@ UpdateTimeEachSecond(void)
     Tcl_WideInt curFileTime;	/* File time at the time this callback was
 				 * scheduled. */
     LONGLONG	estVariance,	/* Estimated variance to compensate ipmact of */
-		driftVariance;	/* deviations of perfomance counters. */
+		driftVariance,	/* deviations of perfomance counters. */
+		estFreq;	/* Estimated frequency */
     Tcl_WideInt vt0;		/* Tcl time right now. */
     Tcl_WideInt vt1;		/* Interim virtual time used during adjustments */
     Tcl_WideInt tdiff,		/* Difference between system clock and Tcl time. */
@@ -1300,18 +1308,24 @@ UpdateTimeEachSecond(void)
 
     curFileTime = GetSystemTimeAsVirtual();
     curPerfCounter = NativePerformanceCounter();
-    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d / %I64d, pc-diff: %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.nominalFreq, curPerfCounter - timeInfo.lastCC.perfCounter);
+    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d / %I64d, pc-diff: %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.lastCC.estFrequency, curPerfCounter - timeInfo.lastCC.perfCounter);
 
     /* 
      * Current virtual time (using average between last fileTime and virtTime):
      * vt0 = (lastCC.fileTime + lastCC.virtTime) / 2
      *		+ ( (curPerfCounter - lastCC.perfCounter) * 10000000 
-     *			+ lastCC.cntrVariance) / nominalFreq
+     *			+ lastCC.cntrVariance) / lastCC.estFrequency
+     * vt1 = the same with nominalFreq
      */
     vt0 = NativeCalc100NsTicks(
 	    (timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
 	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
-	    curPerfCounter);
+	    timeInfo.lastCC.estFrequency, curPerfCounter);
+
+    vt1 = NativeCalc100NsTicks(
+	    (timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
+	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
+	    timeInfo.nominalFreq, curPerfCounter);
 
     /* Differences between virtual and real-time */
     tdiff = vt0 - curFileTime;
@@ -1339,44 +1353,60 @@ UpdateTimeEachSecond(void)
     /*
      * Several things may have gone wrong here that have to be checked for.
      *  (1) The performance counter may have jumped.
-     *  (2) The system clock may have been reset.
-     */
-
-    /*
-     * We want to adjust things so that time appears to be continuous.
-     * Virtual file time, right now, is vt0.
-     *
-     * Ideally, we would like to drift the clock into place over a period of 2
-     * sec, so that virtual time 2 sec from now will be
-     *
-     * vt1 = 10000000 + curFileTime
-     *
-     * The frequency that we need to use to drift the counter back into place
-     * is estFreq * 10000000 / (vt1 - vt0)
-     *
-     * If we've gotten more than a second away from system time, then drifting
-     * the clock is going to be pretty hopeless. Just let it jump. Otherwise,
-     * compute the drift frequency and fill in everything.
+     *  (2) The system clock may have been reset. Try to compensate rather
+     *	    with adjustment of variance as of frequency.
      */
 
     if (tdiff > 10000000 || tdiff < -10000000) {
     	/* More as a second difference, so could be a time-switch (reset)
     	/* jump to current system time, use curent estimated frequency */
-    	vt0 = curFileTime;
     	timeInfo.lastUsedTime = 0; /* reset last used time */
+	estFreq = timeInfo.nominalFreq;
     	estVariance = 0;
+    	vt0 = curFileTime;
     } else {
 
+    	int repeatCnt = 2;
+
+	estVariance = timeInfo.lastCC.cntrVariance;
+	estFreq = timeInfo.lastCC.estFrequency;
+
+	/* Check nominal frequency would be better choice (nearby to curFileTime) */
+	if ((tdiff >= 0 && vt1 < vt0) || (tdiff < 0 && vt1 > vt0)) {
+	    estFreq = (estFreq + timeInfo.nominalFreq * 3) / 4;
+	}
+
+	/* We want reduce tdiff, so slow drift to the time between vt0 and curFileTime */
+	vt0 -= tdiff * 2 / 3;
+
+
 	/*
-	 * Estimate current frequency corresponding current time / counter.
+	 * We want to adjust things so that time appears to be continuous.
+	 * Virtual file time, right now, is vt0.
+	 *
+	 * Ideally, we would like to drift the clock into place over a period of 2
+	 * sec, so that virtual time 2 sec from now will be
+	 *
+	 * vt1 = 10000000 + curFileTime
+	 *
+	 * The frequency that we need to use to drift the counter back into place
+	 * is estFreq * 10000000 / (vt1 - vt0)
+	 *
+	 * If we've gotten more than a second away from system time, then drifting
+	 * the clock is going to be pretty hopeless. Just let it jump. Otherwise,
+	 * compute the drift frequency and fill in everything.
+	 */
+
+    repeatEstimate:
+
+	/*
+	 * Estimate current variance corresponding current time / counter.
 	 */
 
-	if ((curFileTime - timeInfo.lastCC.fileTime) > (10000000 / 2)) {
-	    estVariance = (curFileTime - timeInfo.lastCC.fileTime) 
-		* timeInfo.nominalFreq
+	vt1 = vt0 - timeInfo.lastCC.virtTime; /* time since last calibration */
+	if (vt1 > (10000000 / 2)) {
+	    estVariance = vt1 * estFreq
 		- (curPerfCounter- timeInfo.lastCC.perfCounter) * 10000000;
-	} else {
-	    estVariance = timeInfo.lastCC.cntrVariance;
 	}
 
 	/* 
@@ -1384,47 +1414,101 @@ UpdateTimeEachSecond(void)
 	 * last difference), with dual falling speed. This indicates better
 	 * choice of lastCC.cntrVariance.
 	 */
+#if 1
+	if (lastDiff / tdiff >= 2 || lastDiff / tdiff <= -2) {
+	    estVariance = timeInfo.lastCC.cntrVariance +
+		(estVariance - timeInfo.lastCC.cntrVariance) / 2;
+	}
+#else
 	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
 	    //printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
-	    estVariance = (estVariance + timeInfo.lastCC.cntrVariance) / 2;
+	    estVariance = (estVariance + timeInfo.lastCC.cntrVariance * 3) / 2;
 	    //printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
 	}
+#endif
+
 	printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estVariance > timeInfo.lastCC.cntrVariance) ? "^^^" : "vvv", (curPerfCounter - timeInfo.lastCC.perfCounter));
 	printf("------**-----calibration estimated %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter, estVariance, estVariance - timeInfo.lastCC.cntrVariance);
 
 #if 1
     	/*
-    	 * Calculate new estimate drift variance to the next second
+    	 * Calculate new estimate drift variance to the next second using new
+    	 * estimated values and approximated counter driftPerfCounter.
     	 */
 
+	driftVariance = estVariance * 2;
 	vt1 = vt0 - timeInfo.lastCC.virtTime;
 	if (vt1 > (10000000 / 2)) {
 	    
-	    LONGLONG driftPerfCounter = curPerfCounter + 
+	    /* approximated counter in 1s from now */
+	    LONGLONG driftPerfCounter = curPerfCounter
 		    + (curPerfCounter - timeInfo.lastCC.perfCounter)
 			/ vt1 * (vt1 + 10000000);
 
-	    vt1 = NativeCalc100NsTicks(curFileTime,
+	    /* virtual time in 1s from now */
+	    vt1 = NativeCalc100NsTicks(vt0,
 		curPerfCounter, estVariance,
-		driftPerfCounter);
-	    driftVariance = (vt1 - vt0) * timeInfo.nominalFreq
-		//- estVariance
+		estFreq, driftPerfCounter);
+	    /* new value of variance for this time */
+	    driftVariance = (vt1 - vt0) * estFreq
 		- (driftPerfCounter - curPerfCounter) * 10000000;
-	} else {
-	    driftVariance = estVariance * 2;
 	}
 	/* 
 	 * Avoid too large drifts (only half of the current difference),
 	 * that allows also be more accurate (aspire to the smallest tdiff),
 	 * so then we can prolong calibration interval in such cases.
 	 */
-	driftVariance = timeInfo.lastCC.cntrVariance +
-		(driftVariance - timeInfo.lastCC.cntrVariance) / 2;
+	driftVariance = estVariance +
+		(driftVariance - estVariance) / 2;
 
 	printf("------**-----calibration cntrVariance: %I64d\n", timeInfo.lastCC.cntrVariance);
 	printf("------**-----calibration estVariance:  %I64d\n", estVariance);
 	printf("------**-----calibration driftVariance:%I64d\n", driftVariance);
 
+
+	/* 
+	 * Average between estimated, current and drifted variance,
+	 * (do the soft drifting as possible).
+	 */
+
+	if (repeatCnt != 1 && tdiff > -10000000 && tdiff < 10000000) { /* bypass time-switch */
+	    estVariance = (estVariance * 2 + timeInfo.lastCC.cntrVariance + driftVariance) / 4;
+	} else {
+	    estVariance = (estVariance + driftVariance) / 2;
+	}
+
+
+	if (repeatCnt != 1) {
+	/*
+	 * Estimate current frequency corresponding current time / counter.
+	 */
+
+#if 1
+	vt1 = vt0 - timeInfo.lastCC.virtTime;
+#else
+	vt1 = ((curFileTime - timeInfo.lastCC.fileTime) / 2
+		+ (vt0 - timeInfo.lastCC.virtTime) / 2);
+#endif
+	printf("------**-----calibration vt1:  %I64d, estFrequency:  %I64d\n", vt1, estFreq);
+	if (vt1 > (10000000 / 2)) {
+	    estFreq = ( (curPerfCounter - timeInfo.lastCC.perfCounter) * 10000000
+			    + estVariance ) / vt1;
+
+	    /* 
+	     * Minimize influence of estFreq if tdiff falls (in relation to 
+	     * last difference), with dual falling speed. This indicates better
+	     * choice of lastCC.estFrequency.
+	     */
+	    if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
+		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
+		estFreq = (estFreq + timeInfo.lastCC.estFrequency * 2) / 3;
+		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
+	    }
+	} else {
+	    estFreq = timeInfo.lastCC.estFrequency;
+	}
+	printf("------**-----calibration estVariance:  %I64d, estFrequency:  %I64d\n", estVariance, estFreq);
+
 	/* 
 	 * Average between estimated, 2 current and 5 drifted frequencies,
 	 * (do the soft drifting as possible).
@@ -1432,22 +1516,43 @@ UpdateTimeEachSecond(void)
 	 */
 #if 0
 	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
-	    estFreq = (1 * estFreq + 2 * timeInfo.lastCC.counterFreq + 5 * driftFreq) / 8;
+	    estFreq = (1 * estFreq + 2 * timeInfo.lastCC.estFrequency + 5 * driftFreq) / 8;
 	} else {
-	    estFreq = (3 * estFreq + 3 * timeInfo.lastCC.counterFreq + 2 * driftFreq) / 8;
+	    estFreq = (3 * estFreq + 3 * timeInfo.lastCC.estFrequency + 2 * driftFreq) / 8;
 	}
 #else
-	estVariance = (estVariance + timeInfo.lastCC.cntrVariance + driftVariance) / 3;
+	estFreq = (estFreq + timeInfo.lastCC.estFrequency * 2) / 3;
 #endif
 
 #else
-	estVariance = (estVariance + timeInfo.lastCC.cntrVariance) / 2;
+	if (tdiff > -10000000 && tdiff < 10000000) { /* bypass time-switch */
+	    estVariance = (estVariance + timeInfo.lastCC.cntrVariance) / 2;
+	}
 #endif
+
+	printf("------**-----calibration estVariance:  %I64d, estFrequency:  %I64d\n", estVariance, estFreq);
+    
+	/* 
+	* Avoid too large discrepancy from nominal frequency (0.5%)
+	*/
+	if ( estFreq > (vt1 = (1000+5)*timeInfo.nominalFreq/1000)
+	|| estFreq < (vt1 = (1000-5)*timeInfo.nominalFreq/1000)
+	) {
+	    /* too different */
+	    estFreq = vt1; 
+	    printf("************ too large: %I64d\n", estFreq);
+	}
+
+        }
+
+	if (--repeatCnt) {
+	    goto repeatEstimate;
+	}
     }
     
     /* If possible backwards time-drifts (larger divider now) */
     vt1 = 0;
-    if (estVariance < timeInfo.lastCC.cntrVariance) {
+    if (estVariance < timeInfo.lastCC.cntrVariance || estFreq > timeInfo.lastCC.estFrequency) {
 	Tcl_WideInt nt0, nt1;
 
 	/* 
@@ -1463,10 +1568,10 @@ UpdateTimeEachSecond(void)
 	 */
 	nt0 = NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
 		timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
-		vt1);
+		timeInfo.lastCC.estFrequency, vt1);
 	nt1 = NativeCalc100NsTicks(vt0,
 		curPerfCounter, estVariance,
-		vt1);
+		estFreq, vt1);
 	vt1 = (nt0 - nt1); /* old time - new time */
 	if (vt1 > 0 && vt1 < 10000000 /* bypass time-switch */) {
 	    /* base time should jump forwards (the same virtual time using current values) */
@@ -1491,6 +1596,7 @@ UpdateTimeEachSecond(void)
     timeInfo.lastCC.fileTime = curFileTime;
     timeInfo.lastCC.virtTime = vt0;
     timeInfo.lastCC.cntrVariance = estVariance;
+    timeInfo.lastCC.estFrequency = estFreq;
     timeInfo.lastCC.calibNextTime = curFileTime + calibrationInterv;
 
     InterlockedIncrement(&timeInfo.calibEpoch);
@@ -1500,7 +1606,7 @@ UpdateTimeEachSecond(void)
     //printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
     printf("-------------calibration end, tdiff %I64d, jump -- vt:%I64d - st:%I64d: %I64d, adj: %I64d\n", tdiff, 
     	vt0, curFileTime, (vt0 - curFileTime), vt1);
-    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d / %I64d\n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.nominalFreq);
+    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d / %I64d\n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.lastCC.estFrequency);
 #endif
 }
 
-- 
cgit v0.12


From 40b1d707436dba5c7e8fbcb877cd213d2eb509d0 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:29 +0000
Subject: win: calibration cycle completely rewritten (no calibration thread
 needed, soft drifts within 250ms intervals, fewer discrepancy and fewer
 virtual time gradation, etc). todo: implement resetting timer-resolution to
 original value (without calibration thread now).

---
 win/tclWinNotify.c |   2 +-
 win/tclWinTime.c   | 833 ++++++++++++++---------------------------------------
 2 files changed, 222 insertions(+), 613 deletions(-)

diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index f92fe2f..04d32a3 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -890,7 +890,7 @@ Tcl_Sleep(
 
     for (;;) {
 	
-	(*tclScaleTimeProcPtr) (&vdelay, tclTimeClientData);
+	tclScaleTimeProcPtr(&vdelay, tclTimeClientData);
 
 	/* No wait if sleep time too small (because windows may wait too long) */
 	if (!vdelay.sec && vdelay.usec < (long)timerResolution.minDelay) {
diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index e956175..3a2ba8d 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -36,22 +36,51 @@ typedef struct ThreadSpecificData {
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * The following values are used for calculating virtual time. Virtual
+ * The following structure used for calculating virtual time. Virtual
  * time is always equal to:
- *    virtTime + (currentPerfCounter - perfCounter + cntrVariance)
+ *    virtTimeBase + (currentPerfCounter - perfCounter)
  *			* 10000000 / nominalFreq
  */
 typedef struct TimeCalibInfo {
-    ULONGLONG fileTime;		/* Last real time (in 100-ns) */
-    ULONGLONG virtTime;		/* Last virtual time (in 100-ns) */
-    LONGLONG perfCounter;	/* QPC value of last calibration time */
-    LONGLONG cntrVariance;	/* Current calculated deviation (compensation) */
-    LONGLONG estFrequency;	/* Current estimated frequency */
-    Tcl_WideInt calibNextTime;	/* Next time of calibration (in 100-ns ticks) */
+    LONGLONG perfCounter;	/* QPC value of last calibrated virtual time */
+    Tcl_WideInt virtTimeBase;	/* Last virtual time base (in 100-ns) */
+    Tcl_WideInt sysTime;	/* Last real system time (in 100-ns),
+    				   truncated to VT_SYSTMR_DIST (100ms) */
 } TimeCalibInfo;
 
+/* Milliseconds <-> 100-ns ticks */
+#define MsToT100ns(ms)   (ms * 10000)
+#define T100nsToMs(ms)   (ms / 10000)
+/* Microseconds <-> 100-ns ticks */
+#define UsToT100ns(ms)   (ms * 10)
+#define T100nsToUs(ms)   (ms / 10)
+
+
 /*
- * Data for managing high-resolution timers.
+ * Use factor 1000 for the frequencies of QPC if it ascertained in Hz:
+ *   frequency = nominal frequency / 1000
+ *   native perf-counter = original perf-counter * 1000
+ */
+#ifndef TCL_VT_FREQ_FACTOR
+#   define TCL_VT_FREQ_FACTOR 1
+#endif
+
+/* Distance in ms to obtain system timer (avoids unneeded syscalls). */
+#define VT_SYSTMR_MIN_DIST	50
+/* Resolution distance of the system-timer in milliseconds, 
+ * should be greater as real resolution (normally 15.6ms) to make more 
+ * accurate approximated part of virtual time */
+#define VT_SYSTMR_DIST		250
+/* Max discrepancy of virtual time to system time. Time can slow drift
+ * to the drift distance (+/-5ms), if reached this distance relative
+ * current system time.
+ * Note: it should be greater as real timer-resolution (> 15.6ms). */
+#define VT_MAX_DISCREPANCY	20
+/* Max virtual time drift to shorten current distance */
+#define VT_MAX_DRIFT_TIME	4
+
+/*
+ * Data for managing high-resolution timers (virtual time).
  */
 
 typedef struct TimeInfo {
@@ -60,31 +89,20 @@ typedef struct TimeInfo {
 				 * initialized. */
     int perfCounterAvailable;	/* Flag == 1 if the hardware has a performance
 				 * counter. */
-    HANDLE calibrationThread;	/* Handle to the thread that keeps the virtual
-				 * clock calibrated. */
-    HANDLE readyEvent;		/* System event used to trigger the requesting
-				 * thread when the clock calibration procedure
-				 * is initialized for the first time. */
-    HANDLE exitEvent; 		/* Event to signal out of an exit handler to
-				 * tell the calibration loop to terminate. */
     LONGLONG nominalFreq;	/* Nominal frequency of the system performance
 				 * counter, that is, the value returned from
 				 * QueryPerformanceFrequency. */
+#if TCL_VT_FREQ_FACTOR
     int	freqFactor;		/* Frequency factor (1 - KHz, 1000 - Hz) */
+#endif
     LARGE_INTEGER posixEpoch;	/* Posix epoch expressed as 100-ns ticks since
 				 * the windows epoch. */
-    /*
-     * The following values are used for calculating virtual time. Virtual
-     * time is always equal to:
-     *    virtTime + ( (currentPerfCounter - perfCounter) * 10000000
-     *				+ cntrVariance) / nominalFreq
-     */
-
-    TimeCalibInfo lastCC;	/* Last data updated in calibration cycle */
-    volatile LONG calibEpoch;	/* Calibration epoch */
+    TimeCalibInfo lastCI;	/* Last virtual timer-data updated in the
+				 * calibration process. */
+    volatile LONG lastCIEpoch;	/* Calibration epoch (increased each 100ms) */
     
-    Tcl_WideInt lastUsedTime;	/* Last known (caller) virtual time in 100-ns
-				 * (used to avoid drifts after calibrate) */
+    size_t lastUsedTime;	/* Last known (caller) offset to virtual time
+				 * (used to avoid back-drifts after calibrate) */
 
 } TimeInfo;
 
@@ -92,22 +110,19 @@ static TimeInfo timeInfo = {
     { NULL, 0, 0, NULL, NULL, 0 },
     0,
     0,
-    (HANDLE) NULL,
-    (HANDLE) NULL,
-    (HANDLE) NULL,
     (LONGLONG) 0,
+#if TCL_VT_FREQ_FACTOR
     1, /* for frequency in KHz */
+#endif
 #ifdef HAVE_CAST_TO_UNION
     (LARGE_INTEGER) (Tcl_WideInt) 0,
 #else
     {0, 0},
 #endif
     {
-	(Tcl_WideInt) 0,
-	(ULONGLONG) 0,
-	(ULONGLONG) 0,
 	(LONGLONG) 0,
-	(LONGLONG) 0
+	(Tcl_WideInt) 0,
+	(Tcl_WideInt) 0,
     },
     (LONG) 0,
     (Tcl_WideInt) 0
@@ -129,9 +144,6 @@ static struct {
  */
 
 static struct tm *	ComputeGMT(const time_t *tp);
-static void		StopCalibration(ClientData clientData);
-static DWORD WINAPI	CalibrationThread(LPVOID arg);
-static void 		UpdateTimeEachSecond(void);
 static void		NativeScaleTime(Tcl_Time* timebuf,
 			    ClientData clientData);
 static Tcl_WideInt	NativeGetMicroseconds(void);
@@ -162,7 +174,15 @@ static inline LONGLONG
 NativePerformanceCounter(void) {
     LARGE_INTEGER curCounter;
     QueryPerformanceCounter(&curCounter);
-    return (curCounter.QuadPart / timeInfo.freqFactor);
+#if TCL_VT_FREQ_FACTOR
+    if (timeInfo.freqFactor == 1) {
+    	return curCounter.QuadPart; /* no factor */
+    }
+    /* defactoring counter */
+    return curCounter.QuadPart / timeInfo.freqFactor;
+#else
+    return curCounter.QuadPart; /* no factor configured */
+#endif
 }
 
 /*
@@ -173,9 +193,8 @@ NativePerformanceCounter(void) {
  *	Calculate the current system time in 100-ns ticks since posix epoch,
  *	for current performance counter (curCounter), using given calibrated values.
  *
- *	vt = lastCC.virtTime 
- *		+ ( (curPerfCounter - lastCC.perfCounter) * 10000000
- * 			+ lastCC.cntrVariance ) / nominalFreq
+ *	vt = lastCI.virtTimeBase
+ *		+ (curCounter - lastCI.perfCounter) * 10000000 / nominalFreq
  *
  * Results:
  *	Returns the wide integer with number of 100-ns ticks from the epoch.
@@ -188,14 +207,16 @@ NativePerformanceCounter(void) {
 
 static inline Tcl_WideInt
 NativeCalc100NsTicks(
-    ULONGLONG ccVirtTime,
-    LONGLONG ccPerfCounter,
-    LONGLONG ccCntrVariance,
-    LONGLONG ccEstFrequency,
+    ULONGLONG ciVirtTimeBase,
+    LONGLONG ciPerfCounter,
     LONGLONG curCounter
 ) {
-    return ccVirtTime + ( (curCounter - ccPerfCounter) * 10000000
-				+ ccCntrVariance ) / ccEstFrequency;
+    curCounter -= ciPerfCounter; /* current distance */
+    if (!curCounter) {
+    	return ciVirtTimeBase; /* virtual time without offset */
+    }
+    /* virtual time with offset */
+    return ciVirtTimeBase + curCounter * 10000000 / timeInfo.nominalFreq;
 }
 
 /*
@@ -394,10 +415,24 @@ TclpWideClickInMicrosec(void)
 Tcl_WideInt 
 TclpGetMicroseconds(void)
 {
+#if 0
+    /* Use high resolution timer if possible */
+    if (tclGetTimeProcPtr == NativeGetTime) {
+    	return NativeGetMicroseconds();
+    } else {
+	/*
+	 * Use the Tcl_GetTime abstraction to get the time in microseconds, as
+	 * nearly as we can, and return it.
+	 */
+
+	Tcl_Time now;
+
+	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
+	return (((Tcl_WideInt)now.sec) * 1000000) + now.usec;
+    }
+
+#else
     static Tcl_WideInt prevUS = 0;
-    static Tcl_WideInt fileTimeLastCall, perfCounterLastCall, curCntrVariance, prevEstFrequency;
-    static LONGLONG prevPerfCounter;
-    LONGLONG newPerfCounter;
 
     Tcl_WideInt usecSincePosixEpoch;
 
@@ -409,9 +444,9 @@ TclpGetMicroseconds(void)
 	}
     } else {
 	/*
-	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
-	* nearly as we can, and return it.
-	*/
+	 * Use the Tcl_GetTime abstraction to get the time in microseconds, as
+	 * nearly as we can, and return it.
+	 */
 
 	Tcl_Time now;
 
@@ -420,28 +455,14 @@ TclpGetMicroseconds(void)
 	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!no-native-ms!!!!!!!!!!!\n");
     }
 
-	newPerfCounter = NativePerformanceCounter();
-
     	if (prevUS && usecSincePosixEpoch < prevUS) {
-    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! pre-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", fileTimeLastCall, perfCounterLastCall, prevPerfCounter, curCntrVariance,
-    	    	NativeCalc100NsTicks(fileTimeLastCall,
-		perfCounterLastCall, curCntrVariance, prevEstFrequency,
-		prevPerfCounter));
-    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, newPerfCounter, timeInfo.lastCC.cntrVariance,
-    	    	NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
-		timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.lastCC.estFrequency,
-		newPerfCounter));
 	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! prev: %I64d - now: %I64d (%I64d usec)\n", prevUS, usecSincePosixEpoch, usecSincePosixEpoch - prevUS);
 	    Tcl_Panic("Time running backwards!!!");
     	}
     	prevUS = usecSincePosixEpoch;
-	fileTimeLastCall = timeInfo.lastCC.virtTime;
-	perfCounterLastCall = timeInfo.lastCC.perfCounter;
-	curCntrVariance = timeInfo.lastCC.cntrVariance;
-	prevEstFrequency = timeInfo.lastCC.estFrequency;
-	prevPerfCounter = newPerfCounter;
 
 	return usecSincePosixEpoch;
+#endif
 }
 
 /*
@@ -565,8 +586,10 @@ NativeScaleTime(
 static Tcl_WideInt
 NativeGetMicroseconds(void)
 {
+    static size_t nomObtainSTPerfCntrDist = 0;
+				/* Nominal distance in perf-counter ticks to
+				 * obtain system timer (avoids unneeded syscalls). */
     Tcl_WideInt curTime;	/* Current time in 100-ns ticks since epoch */
-    Tcl_WideInt lastTime;	/* Used to compare with last known time */
 
     /*
      * Initialize static storage on the first trip through.
@@ -594,13 +617,19 @@ NativeGetMicroseconds(void)
 		if (timeInfo.nominalFreq == 0) {
 		    timeInfo.perfCounterAvailable = FALSE;
 		}
+#if TCL_VT_FREQ_FACTOR
 		/* Some systems having frequency in Hz, so save the factor here */
 		if (timeInfo.nominalFreq >= 1000000000 
 			&& (timeInfo.nominalFreq % 1000) == 0) {
-		    timeInfo.nominalFreq /= 1000;
 		    /* assume that frequency in Hz, factor used only for tolerance */
 		    timeInfo.freqFactor = 1000;
+		    timeInfo.nominalFreq /= timeInfo.freqFactor;
 		}
+#endif
+		/* Distance in perf-counter ticks for VT_SYSTMR_MIN_DIST (ms) */
+		nomObtainSTPerfCntrDist = (size_t)
+			(timeInfo.nominalFreq * MsToT100ns(VT_SYSTMR_MIN_DIST))
+			    / 10000000;
 	    }
 
 	    /*
@@ -680,30 +709,17 @@ NativeGetMicroseconds(void)
 #endif /* above code is Win32 only */
 
 	    /*
-	     * If the performance counter is available, start a thread to
-	     * calibrate it.
+	     * If the performance counter is available, initialize
 	     */
 
 	    if (timeInfo.perfCounterAvailable) {
-		DWORD id;
-
 		InitializeCriticalSection(&timeInfo.cs);
-		timeInfo.readyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
-		timeInfo.exitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
-		timeInfo.calibrationThread = CreateThread(NULL, 256,
-			CalibrationThread, (LPVOID) NULL, 0, &id);
-		SetThreadPriority(timeInfo.calibrationThread,
-			THREAD_PRIORITY_HIGHEST);
 
-		/*
-		 * Wait for the thread just launched to start running, and
-		 * create an exit handler that kills it so that it doesn't
-		 * outlive unloading tclXX.dll
-		 */
+		timeInfo.lastCI.perfCounter = NativePerformanceCounter();
+		timeInfo.lastCI.sysTime =
+		    timeInfo.lastCI.virtTimeBase = GetSystemTimeAsVirtual();
+
 
-		WaitForSingleObject(timeInfo.readyEvent, INFINITE);
-		CloseHandle(timeInfo.readyEvent);
-		Tcl_CreateExitHandler(StopCalibration, (ClientData) NULL);
 	    }
 	    timeInfo.initialized = TRUE;
 	}
@@ -712,88 +728,144 @@ NativeGetMicroseconds(void)
 
     if (timeInfo.perfCounterAvailable) {
 
-	/* Copies with current data of calibration cycle */
-	static TimeCalibInfo commonCC;
-	static volatile LONG calibEpoch;
-	TimeCalibInfo cc;
-	volatile LONG ccEpoch;
-
-	LONGLONG curCounter;	/* Current performance counter. */
+	static LONGLONG lastObtainSTPerfCntr = 0; 
+				/* Last perf-counter system timer was obtained. */
+	TimeCalibInfo ci;	/* Copy of common base/offset used to calc VT. */
+	volatile LONG ciEpoch;	/* Epoch of "ci", protecting this structure. */
+	Tcl_WideInt sysTime, trSysTime;
+				/* System time and truncated (rounded) time. */
+	LONGLONG curCounter;	/* Current value of native QPC. */
 
 	/*
 	 * Try to acquire data without lock (same epoch at end of copy process).
 	 */
-	do {
-	    ccEpoch = calibEpoch;
-	    memcpy(&cc, &commonCC, sizeof(cc));
-	    /*
-	     * Hold time section locked as short as possible
-	     */
-	    if (InterlockedCompareExchange(&timeInfo.calibEpoch, 
-				calibEpoch, calibEpoch) != calibEpoch) {
-		EnterCriticalSection(&timeInfo.cs);
-		if (calibEpoch != timeInfo.calibEpoch) {
-		    memcpy(&commonCC, &timeInfo.lastCC, sizeof(commonCC));
-		}
-		calibEpoch = timeInfo.calibEpoch;
-		LeaveCriticalSection(&timeInfo.cs);
-	    }
-
-	} while (InterlockedCompareExchange(&timeInfo.calibEpoch, 
-			ccEpoch, ccEpoch) != ccEpoch);
-
+	ciEpoch = timeInfo.lastCIEpoch;
+	memcpy(&ci, &timeInfo.lastCI, sizeof(ci));
 	/*
-	 * Query the performance counter and use it to calculate the current
-	 * time.
+	 * Lock on demand and hold time section locked as short as possible.
 	 */
-	curCounter = NativePerformanceCounter();
-
-	/* Calibrated file-time is saved from posix in 100-ns ticks */
-	curTime = NativeCalc100NsTicks(cc.virtTime,
-		cc.perfCounter, cc.cntrVariance, cc.estFrequency, curCounter);
+	if (InterlockedCompareExchange(&timeInfo.lastCIEpoch, 
+				ciEpoch, ciEpoch) != ciEpoch) {
+	    printf("**** not equal: %d != %d\n", ciEpoch, timeInfo.lastCIEpoch);
+	    EnterCriticalSection(&timeInfo.cs);
+	    if (ciEpoch != timeInfo.lastCIEpoch) {
+		memcpy(&ci, &timeInfo.lastCI, sizeof(ci));
+		ciEpoch = timeInfo.lastCIEpoch;
+	    }
+	    LeaveCriticalSection(&timeInfo.cs);
+	}
 
-	/* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
-	if ( (lastTime = timeInfo.lastUsedTime)
-	  && lastTime > curTime
-	  && lastTime - curTime < 1000000 /* bypass time-switch (drifts only) */
+	/* Query current performance counter. */
+	curCounter = NativePerformanceCounter();
+	
+	/* Avoid doing unneeded syscall too often */
+	if ( curCounter >= lastObtainSTPerfCntr
+	  && curCounter < lastObtainSTPerfCntr + nomObtainSTPerfCntrDist
 	) {
-	    curTime = timeInfo.lastUsedTime;
+	    goto calcVT; /* don't check system time (curCounter precise enough) */
 	}
+	lastObtainSTPerfCntr = curCounter;
 
+	/* Query non-precise system time */
+	sysTime = GetSystemTimeAsVirtual();
 	/*
-	 * If it appears to be more than 1 seconds since the last trip
-	 * through the calibration loop, the performance counter may have
-	 * jumped forward. (See MSDN Knowledge Base article Q274323 for a
-	 * description of the hardware problem that makes this test
-	 * necessary.) If the counter jumps, we don't want to use it directly.
-	 * Instead, we must return system time. Eventually, the calibration
-	 * loop should recover.
+	 * Truncate non-precise part of the system time (to VT_SYSTMR_DIST ms)
 	 */
+	trSysTime = sysTime;
+	trSysTime /= MsToT100ns(VT_SYSTMR_DIST); /* VT_SYSTMR_DIST ms (in 100ns)*/
+	trSysTime *= MsToT100ns(VT_SYSTMR_DIST);
+
+	/*
+	 * If rounded system time is changed - recalibrate offsets/base values
+	 */ 
+	if (ci.sysTime != trSysTime) { /* next interval VT_SYSTMR_DIST ms */
+	  EnterCriticalSection(&timeInfo.cs);
+	  if (ci.sysTime != trSysTime) { /* again in lock (done in other thread) */
+
+	    /*
+	     * Recalibration / Adjustment of base values.
+	     */
+
+	    Tcl_WideInt vt0;		/* Desired virtual time */
+	    Tcl_WideInt tdiff;		/* Time difference to the system time */
+	    Tcl_WideInt lastTime;	/* Used to compare with last known time */
+
+	    /* New desired virtual time using current base values */
+	    vt0 = NativeCalc100NsTicks(ci.virtTimeBase, ci.perfCounter, curCounter);
+
+	    tdiff = vt0 - sysTime;
+	    /* If we can adjust offsets (not a jump to new system time) */
+	    if (MsToT100ns(-800) < tdiff && tdiff < MsToT100ns(800)) {
+
+		/* Allow small drift if discrepancy larger as expected */
+//!!!		printf("************* tdiff: %I64d\n", tdiff);
+		if (tdiff <= MsToT100ns(-VT_MAX_DISCREPANCY)) {
+		   vt0 += MsToT100ns(VT_MAX_DRIFT_TIME);
+		}
+		else
+		if (tdiff >= MsToT100ns(VT_MAX_DISCREPANCY)) {
+		   vt0 -= MsToT100ns(VT_MAX_DRIFT_TIME);
+		}
+		
+		/*
+		 * Be sure the clock ticks never backwards (avoid backwards 
+		 * time-drifts). If time-reset (< 800ms) just use curent time
+		 * (avoid time correction in such case).
+		 */
+		if ( (lastTime = (ci.virtTimeBase + timeInfo.lastUsedTime))
+		  && (lastTime -= vt0) > 0 /* offset to vt0 */
+		  && lastTime < MsToT100ns(800) /* bypass time-switch (drifts only) */
+		) {
+//!!!		    printf("************* forwards 1: %I64d, last-time: %I64d, distance: %I64d\n", lastTime, vt0, (vt0 - trSysTime));
+		    vt0 += lastTime; /* hold on the time a bit */
+//!!!		    printf("************* forwards 1: %I64d, last-time: %I64d, distance: %I64d\n", lastTime, ci.virtTimeBase, (vt0 - trSysTime));
+		}
 
+	    } else {
+		/* 
+		 * The time-jump (reset or initial), we should use system time
+		 * instead of virtual to recalibrate offsets (let the time jump).
+		 */
+		vt0 = sysTime;
+//!!!		printf("************* reset time: %I64d *****************\n", vt0);
+	    }
+
+	    /* 
+	     * Adjustment of current base for virtual time. This will also
+	     * prevent too large counter difference (resp. max distance ~ 100ms).
+	     */
+	    ci.virtTimeBase = vt0;
+	    ci.perfCounter = curCounter;
+	    ci.sysTime = trSysTime;
+	    /* base adjusted, so reset also last known offset */
+	    timeInfo.lastUsedTime = 0;
+
+	    /* Update global structure lastCI with new values */
+	    memcpy(&timeInfo.lastCI, &ci, sizeof(ci));
+	    /* Increase epoch, to inform all other threads about new data */
+	    InterlockedIncrement(&timeInfo.lastCIEpoch);
+
+//!!!	    printf("************* recalibrated: %I64d, %I64d adj. %I64d, distance: %I64d\n", vt0, ci.virtTimeBase, ci.perfCounter, (vt0 - trSysTime));
+	  
+	  } /* end lock */
+	  LeaveCriticalSection(&timeInfo.cs);
+	} /* common info lastCI contains actual data */
 	
-	printf("********* %I64d\n", GetSystemTimeAsVirtual()); /* in 100-ns ticks */
+    calcVT:	
+	/* Calculate actual virtual time now using performance counter */
+	curTime = NativeCalc100NsTicks(ci.virtTimeBase, ci.perfCounter, curCounter);
 
-	if (curTime < cc.calibNextTime + 10000000 /* 1 sec (in 100-ns ticks). */) {
-	    /* save last used time */
-	    timeInfo.lastUsedTime = curTime;
-	    return curTime / 10;
-	}
-	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!calibration-error!!!! cur: %I64d - call: %I64d (%I64d) -- prev: %I64d - now: %I64d (%I64d)\n", curTime, cc.calibNextTime, cc.calibNextTime - curTime, cc.perfCounter, curCounter, curCounter - cc.perfCounter);
+	/* Save last used time (offset) and return virtual time */
+	timeInfo.lastUsedTime = (size_t)(curTime - ci.virtTimeBase);
+	return T100nsToUs(curTime); /* 100-ns to microseconds */
     }
 
     /*
      * High resolution timer is not available.
      */
+
     curTime = GetSystemTimeAsVirtual(); /* in 100-ns ticks */
-    /* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
-    if ( (lastTime = timeInfo.lastUsedTime)
-      && lastTime > curTime
-      && lastTime - curTime < 1000000 /* bypass time-switch (drifts only) */
-    ) {
-	curTime = timeInfo.lastUsedTime;
-    }
-    timeInfo.lastUsedTime = curTime;
-    return curTime / 10;
+    return T100nsToUs(curTime); /* 100-ns to microseconds */
 }
 
 /*
@@ -842,47 +914,6 @@ NativeGetTime(
 /*
  *----------------------------------------------------------------------
  *
- * StopCalibration --
- *
- *	Turns off the calibration thread in preparation for exiting the
- *	process.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Sets the 'exitEvent' event in the 'timeInfo' structure to ask the
- *	thread in question to exit, and waits for it to do so.
- *
- *----------------------------------------------------------------------
- */
-
-void TclWinResetTimerResolution(void);
-
-static void
-StopCalibration(
-    ClientData unused)		/* Client data is unused */
-{
-    SetEvent(timeInfo.exitEvent);
-
-    /*
-     * If Tcl_Finalize was called from DllMain, the calibration thread is in a
-     * paused state so we need to timeout and continue.
-     */
-
-    WaitForSingleObject(timeInfo.calibrationThread, 100);
-    CloseHandle(timeInfo.exitEvent);
-    CloseHandle(timeInfo.calibrationThread);
-
-    /*
-     * Reset timer resolution (shutdown case)
-     */
-    (void)TclWinResetTimerResolution();
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * TclpGetTZName --
  *
  *	Gets the current timezone string.
@@ -1191,428 +1222,6 @@ ComputeGMT(
 /*
  *----------------------------------------------------------------------
  *
- * CalibrationThread --
- *
- *	Thread that manages calibration of the hi-resolution time derived from
- *	the performance counter, to keep it synchronized with the system
- *	clock.
- *
- * Parameters:
- *	arg - Client data from the CreateThread call. This parameter points to
- *	      the static TimeInfo structure.
- *
- * Return value:
- *	None. This thread embeds an infinite loop.
- *
- * Side effects:
- *	At an interval of 1s, this thread performs virtual time discipline.
- *
- * Note: When this thread is entered, TclpInitLock has been called to
- * safeguard the static storage. There is therefore no synchronization in the
- * body of this procedure.
- *
- *----------------------------------------------------------------------
- */
-
-static DWORD WINAPI
-CalibrationThread(
-    LPVOID arg)
-{
-    DWORD waitResult;
-
-    /*
-     * Get initial system time and performance counter.
-     */
-
-    timeInfo.lastCC.perfCounter = NativePerformanceCounter();
-    timeInfo.lastCC.fileTime = timeInfo.lastCC.virtTime = GetSystemTimeAsVirtual();
-    timeInfo.lastCC.estFrequency = timeInfo.nominalFreq;
-
-    /*
-     * Calibrate first time and wake up the calling thread. 
-     * When it wakes up, it will release the initialization lock.
-     */
-
-    if (timeInfo.perfCounterAvailable) {
-	UpdateTimeEachSecond();
-    }
-
-    SetEvent(timeInfo.readyEvent);
-
-    /*
-     * Run the calibration once a second.
-     */
-
-    while (timeInfo.perfCounterAvailable) {
-	/*
-	 * If the exitEvent is set, break out of the loop.
-	 */
-
-	waitResult = WaitForSingleObjectEx(timeInfo.exitEvent, 1000, FALSE);
-	if (waitResult == WAIT_OBJECT_0) {
-	    break;
-	}
-	UpdateTimeEachSecond();
-
-	/*
-	* Reset timer resolution if expected (check waiter count once per second)
-	*/
-	(void)TclWinResetTimerResolution();
-    }
-
-    /* lint */
-    return (DWORD) 0;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * UpdateTimeEachSecond --
- *
- *	Callback from the waitable timer in the clock calibration thread that
- *	updates system time.
- *
- * Parameters:
- *	info - Pointer to the static TimeInfo structure
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Performs virtual time calibration discipline.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-UpdateTimeEachSecond(void)
-{
-    LONGLONG curPerfCounter;
-				/* Current value returned from
-				 * NativePerformanceCounter. */
-    static int calibrationInterv = 10000000;
-				/* Calibration interval in 100-ns ticks (starts from 1s) */
-    Tcl_WideInt curFileTime;	/* File time at the time this callback was
-				 * scheduled. */
-    LONGLONG	estVariance,	/* Estimated variance to compensate ipmact of */
-		driftVariance,	/* deviations of perfomance counters. */
-		estFreq;	/* Estimated frequency */
-    Tcl_WideInt vt0;		/* Tcl time right now. */
-    Tcl_WideInt vt1;		/* Interim virtual time used during adjustments */
-    Tcl_WideInt tdiff,		/* Difference between system clock and Tcl time. */
-		lastDiff;	/* Difference of last calibration. */
-
-    /*
-     * Sample system time (from posix epoch) and performance counter.
-     */
-
-    curFileTime = GetSystemTimeAsVirtual();
-    curPerfCounter = NativePerformanceCounter();
-    printf("-------------calibration start, prev-struct: %I64d, %I64d, %I64d / %I64d, pc-diff: %I64d\n", timeInfo.lastCC.fileTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.lastCC.estFrequency, curPerfCounter - timeInfo.lastCC.perfCounter);
-
-    /* 
-     * Current virtual time (using average between last fileTime and virtTime):
-     * vt0 = (lastCC.fileTime + lastCC.virtTime) / 2
-     *		+ ( (curPerfCounter - lastCC.perfCounter) * 10000000 
-     *			+ lastCC.cntrVariance) / lastCC.estFrequency
-     * vt1 = the same with nominalFreq
-     */
-    vt0 = NativeCalc100NsTicks(
-	    (timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
-	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
-	    timeInfo.lastCC.estFrequency, curPerfCounter);
-
-    vt1 = NativeCalc100NsTicks(
-	    (timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
-	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
-	    timeInfo.nominalFreq, curPerfCounter);
-
-    /* Differences between virtual and real-time */
-    tdiff = vt0 - curFileTime;
-    lastDiff = timeInfo.lastCC.virtTime - timeInfo.lastCC.fileTime;
-    if (tdiff >= 10000000 || tdiff <= -10000000) {
-	printf("---!!!!!!!---calibration ERR, tdiff %I64d\n", tdiff);
-    }
-    /* 
-     * If calibration still not needed (check for possible time-switch). Note, that
-     * NativeGetMicroseconds checks calibNextTime also, be sure it does not overflow.
-     * Calibrate immediately if we've too large discrepancy to the real-time (15.6 ms).
-     */
-#if 1
-    if ( curFileTime < timeInfo.lastCC.calibNextTime - (10000000/2) /* 0.5 sec (in 100-ns ticks). */
-      && timeInfo.lastCC.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between (time-switch?) */
-      && tdiff > -10000 && tdiff < 10000 /* very small discrepancy (1ms) */
-    ) {
-    	/* again in next one second */
-    	printf("-------------calibration end, tdiff %I64d, *** not needed. (next in: %I64d) ------\n", tdiff, curFileTime, timeInfo.lastCC.calibNextTime, timeInfo.lastCC.calibNextTime - curFileTime);
-	lastDiff = tdiff;
-	return;
-    }
-#endif
-
-    /*
-     * Several things may have gone wrong here that have to be checked for.
-     *  (1) The performance counter may have jumped.
-     *  (2) The system clock may have been reset. Try to compensate rather
-     *	    with adjustment of variance as of frequency.
-     */
-
-    if (tdiff > 10000000 || tdiff < -10000000) {
-    	/* More as a second difference, so could be a time-switch (reset)
-    	/* jump to current system time, use curent estimated frequency */
-    	timeInfo.lastUsedTime = 0; /* reset last used time */
-	estFreq = timeInfo.nominalFreq;
-    	estVariance = 0;
-    	vt0 = curFileTime;
-    } else {
-
-    	int repeatCnt = 2;
-
-	estVariance = timeInfo.lastCC.cntrVariance;
-	estFreq = timeInfo.lastCC.estFrequency;
-
-	/* Check nominal frequency would be better choice (nearby to curFileTime) */
-	if ((tdiff >= 0 && vt1 < vt0) || (tdiff < 0 && vt1 > vt0)) {
-	    estFreq = (estFreq + timeInfo.nominalFreq * 3) / 4;
-	}
-
-	/* We want reduce tdiff, so slow drift to the time between vt0 and curFileTime */
-	vt0 -= tdiff * 2 / 3;
-
-
-	/*
-	 * We want to adjust things so that time appears to be continuous.
-	 * Virtual file time, right now, is vt0.
-	 *
-	 * Ideally, we would like to drift the clock into place over a period of 2
-	 * sec, so that virtual time 2 sec from now will be
-	 *
-	 * vt1 = 10000000 + curFileTime
-	 *
-	 * The frequency that we need to use to drift the counter back into place
-	 * is estFreq * 10000000 / (vt1 - vt0)
-	 *
-	 * If we've gotten more than a second away from system time, then drifting
-	 * the clock is going to be pretty hopeless. Just let it jump. Otherwise,
-	 * compute the drift frequency and fill in everything.
-	 */
-
-    repeatEstimate:
-
-	/*
-	 * Estimate current variance corresponding current time / counter.
-	 */
-
-	vt1 = vt0 - timeInfo.lastCC.virtTime; /* time since last calibration */
-	if (vt1 > (10000000 / 2)) {
-	    estVariance = vt1 * estFreq
-		- (curPerfCounter- timeInfo.lastCC.perfCounter) * 10000000;
-	}
-
-	/* 
-	 * Minimize influence of estVariance if tdiff falls (in relation to
-	 * last difference), with dual falling speed. This indicates better
-	 * choice of lastCC.cntrVariance.
-	 */
-#if 1
-	if (lastDiff / tdiff >= 2 || lastDiff / tdiff <= -2) {
-	    estVariance = timeInfo.lastCC.cntrVariance +
-		(estVariance - timeInfo.lastCC.cntrVariance) / 2;
-	}
-#else
-	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
-	    //printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
-	    estVariance = (estVariance + timeInfo.lastCC.cntrVariance * 3) / 2;
-	    //printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
-	}
-#endif
-
-	printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estVariance > timeInfo.lastCC.cntrVariance) ? "^^^" : "vvv", (curPerfCounter - timeInfo.lastCC.perfCounter));
-	printf("------**-----calibration estimated %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter, estVariance, estVariance - timeInfo.lastCC.cntrVariance);
-
-#if 1
-    	/*
-    	 * Calculate new estimate drift variance to the next second using new
-    	 * estimated values and approximated counter driftPerfCounter.
-    	 */
-
-	driftVariance = estVariance * 2;
-	vt1 = vt0 - timeInfo.lastCC.virtTime;
-	if (vt1 > (10000000 / 2)) {
-	    
-	    /* approximated counter in 1s from now */
-	    LONGLONG driftPerfCounter = curPerfCounter
-		    + (curPerfCounter - timeInfo.lastCC.perfCounter)
-			/ vt1 * (vt1 + 10000000);
-
-	    /* virtual time in 1s from now */
-	    vt1 = NativeCalc100NsTicks(vt0,
-		curPerfCounter, estVariance,
-		estFreq, driftPerfCounter);
-	    /* new value of variance for this time */
-	    driftVariance = (vt1 - vt0) * estFreq
-		- (driftPerfCounter - curPerfCounter) * 10000000;
-	}
-	/* 
-	 * Avoid too large drifts (only half of the current difference),
-	 * that allows also be more accurate (aspire to the smallest tdiff),
-	 * so then we can prolong calibration interval in such cases.
-	 */
-	driftVariance = estVariance +
-		(driftVariance - estVariance) / 2;
-
-	printf("------**-----calibration cntrVariance: %I64d\n", timeInfo.lastCC.cntrVariance);
-	printf("------**-----calibration estVariance:  %I64d\n", estVariance);
-	printf("------**-----calibration driftVariance:%I64d\n", driftVariance);
-
-
-	/* 
-	 * Average between estimated, current and drifted variance,
-	 * (do the soft drifting as possible).
-	 */
-
-	if (repeatCnt != 1 && tdiff > -10000000 && tdiff < 10000000) { /* bypass time-switch */
-	    estVariance = (estVariance * 2 + timeInfo.lastCC.cntrVariance + driftVariance) / 4;
-	} else {
-	    estVariance = (estVariance + driftVariance) / 2;
-	}
-
-
-	if (repeatCnt != 1) {
-	/*
-	 * Estimate current frequency corresponding current time / counter.
-	 */
-
-#if 1
-	vt1 = vt0 - timeInfo.lastCC.virtTime;
-#else
-	vt1 = ((curFileTime - timeInfo.lastCC.fileTime) / 2
-		+ (vt0 - timeInfo.lastCC.virtTime) / 2);
-#endif
-	printf("------**-----calibration vt1:  %I64d, estFrequency:  %I64d\n", vt1, estFreq);
-	if (vt1 > (10000000 / 2)) {
-	    estFreq = ( (curPerfCounter - timeInfo.lastCC.perfCounter) * 10000000
-			    + estVariance ) / vt1;
-
-	    /* 
-	     * Minimize influence of estFreq if tdiff falls (in relation to 
-	     * last difference), with dual falling speed. This indicates better
-	     * choice of lastCC.estFrequency.
-	     */
-	    if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
-		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
-		estFreq = (estFreq + timeInfo.lastCC.estFrequency * 2) / 3;
-		//printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
-	    }
-	} else {
-	    estFreq = timeInfo.lastCC.estFrequency;
-	}
-	printf("------**-----calibration estVariance:  %I64d, estFrequency:  %I64d\n", estVariance, estFreq);
-
-	/* 
-	 * Average between estimated, 2 current and 5 drifted frequencies,
-	 * (do the soft drifting as possible).
-	 * Minimize influence if tdiff falls (in relation to last difference)
-	 */
-#if 0
-	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
-	    estFreq = (1 * estFreq + 2 * timeInfo.lastCC.estFrequency + 5 * driftFreq) / 8;
-	} else {
-	    estFreq = (3 * estFreq + 3 * timeInfo.lastCC.estFrequency + 2 * driftFreq) / 8;
-	}
-#else
-	estFreq = (estFreq + timeInfo.lastCC.estFrequency * 2) / 3;
-#endif
-
-#else
-	if (tdiff > -10000000 && tdiff < 10000000) { /* bypass time-switch */
-	    estVariance = (estVariance + timeInfo.lastCC.cntrVariance) / 2;
-	}
-#endif
-
-	printf("------**-----calibration estVariance:  %I64d, estFrequency:  %I64d\n", estVariance, estFreq);
-    
-	/* 
-	* Avoid too large discrepancy from nominal frequency (0.5%)
-	*/
-	if ( estFreq > (vt1 = (1000+5)*timeInfo.nominalFreq/1000)
-	|| estFreq < (vt1 = (1000-5)*timeInfo.nominalFreq/1000)
-	) {
-	    /* too different */
-	    estFreq = vt1; 
-	    printf("************ too large: %I64d\n", estFreq);
-	}
-
-        }
-
-	if (--repeatCnt) {
-	    goto repeatEstimate;
-	}
-    }
-    
-    /* If possible backwards time-drifts (larger divider now) */
-    vt1 = 0;
-    if (estVariance < timeInfo.lastCC.cntrVariance || estFreq > timeInfo.lastCC.estFrequency) {
-	Tcl_WideInt nt0, nt1;
-
-	/* 
-	 * Calculate the time using new calibration values (and compare with old),
-	 * to avoid possible backwards drifts (adjust current base time).
-	 * This should affect at least next 10 ticks.
-	 */
-	vt1 = curPerfCounter + 10;
-	/*
-	 * Be sure the clock ticks never backwards (avoid it by negative drifting)
-	 * just compare native time (in 100-ns) before and hereafter using 
-	 * previous/new calibrated values) and do a small adjustment
-	 */
-	nt0 = NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
-		timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance,
-		timeInfo.lastCC.estFrequency, vt1);
-	nt1 = NativeCalc100NsTicks(vt0,
-		curPerfCounter, estVariance,
-		estFreq, vt1);
-	vt1 = (nt0 - nt1); /* old time - new time */
-	if (vt1 > 0 && vt1 < 10000000 /* bypass time-switch */) {
-	    /* base time should jump forwards (the same virtual time using current values) */
-	    vt0 += vt1;
-	    tdiff += vt1;
-	    //////////////////////////////////////////estFreq = 10000000 * (vt0 - timeInfo.lastCC.perfCounter) / vt1;
-	}
-    }
-
-    /* if still precise enough, grow calibration interval up to 10 seconds */
-    if (tdiff < -100000 || tdiff > 100000 /* 10-ms */) {
-	/* too long drift - reset calibration interval to 1 second */
-	calibrationInterv = 10000000;
-    } else if (calibrationInterv < 10*10000000) {
-	calibrationInterv += 10000000;
-    }
-
-    /* In lock commit new values to timeInfo (hold lock as short as possible) */
-    EnterCriticalSection(&timeInfo.cs);
-
-    timeInfo.lastCC.perfCounter = curPerfCounter;
-    timeInfo.lastCC.fileTime = curFileTime;
-    timeInfo.lastCC.virtTime = vt0;
-    timeInfo.lastCC.cntrVariance = estVariance;
-    timeInfo.lastCC.estFrequency = estFreq;
-    timeInfo.lastCC.calibNextTime = curFileTime + calibrationInterv;
-
-    InterlockedIncrement(&timeInfo.calibEpoch);
-
-    LeaveCriticalSection(&timeInfo.cs);
-#if 1
-    //printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
-    printf("-------------calibration end, tdiff %I64d, jump -- vt:%I64d - st:%I64d: %I64d, adj: %I64d\n", tdiff, 
-    	vt0, curFileTime, (vt0 - curFileTime), vt1);
-    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d / %I64d\n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.cntrVariance, timeInfo.lastCC.estFrequency);
-#endif
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * TclpGmtime --
  *
  *	Wrapper around the 'gmtime' library function to make it thread safe.
-- 
cgit v0.12


From 913dc38311eb8c0ecbf81444db4d7d0a9276c4e5 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:33 +0000
Subject: call TclWinResetTimerResolution at end of sleep resp. wait for event
 (no calibration thread anymore)

---
 win/tclWinNotify.c | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index 04d32a3..6c7b3b7 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -417,13 +417,15 @@ static struct {
     LONG  minDelay;		/* Lowest delay by max resolution (in microsecs) */
     LONG  maxDelay;		/* Highest delay by min resolution (in microsecs) */
     size_t count;		/* Waiter count (used to restore the resolution) */
+    Tcl_WideInt timeToReset;	/* Time to reset resolution (typically now + 5s) */
     CRITICAL_SECTION cs;	/* Mutex guarding this structure. */
 } timerResolution = {
     -1,
     15600 * TMR_RES_MICROSEC, 500 * TMR_RES_MICROSEC, 
     15600 * TMR_RES_MICROSEC, 0,
     500, 15600,
-    0
+    0,
+    (Tcl_WideInt)0x7FFFFFFFFFFFFFFFL
 };
 
 /*
@@ -532,7 +534,7 @@ SetTimerResolution(
     /* resolution unchanged (and counter not increased) */
     return 0;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -560,22 +562,21 @@ RestoreTimerResolution(
     if (timerResolution.available > 0 && newResolution) {
 	EnterCriticalSection(&timerResolution.cs);
 	if (timerResolution.count-- <= 1) {
-	    if (newResolution > timerResolution.resRes) {
-	    	timerResolution.resRes = newResolution;
-	    };
+	    timerResolution.resRes = newResolution;
+	    /* prolong time to reset resolution */
+	    timerResolution.timeToReset = TclpGetMicroseconds() + 1000000;
 	}
 	LeaveCriticalSection(&timerResolution.cs);
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * TclWinResetTimerResolution --
  *
- *	This is called by CalibrationThread to delayed reset of the timer
- *	resolution (once per second), if no more waiting workers using 
- *	precise timer resolution.
+ *	This is called to delayed reset (after 1 second) of the timer resolution
+ *	to original value, if no more waiting workers using precise resolution.
  *
  * Results:
  *	None.
@@ -591,6 +592,7 @@ TclWinResetTimerResolution(void)
 {
     if ( timerResolution.available > 0
       && timerResolution.count == 0 && timerResolution.resRes > timerResolution.curRes
+      && TclpGetMicroseconds() >= timerResolution.timeToReset
     ) {
 	EnterCriticalSection(&timerResolution.cs);
 	if (timerResolution.count == 0 && timerResolution.resRes > timerResolution.curRes) {
@@ -598,6 +600,7 @@ TclWinResetTimerResolution(void)
 	    if (NtSetTimerResolution(timerResolution.resRes, TRUE, &curRes) == 0) {
 		timerResolution.curRes = curRes;
 	    };
+	    timerResolution.timeToReset = 0x7FFFFFFFFFFFFFFFL;
 	}
 	LeaveCriticalSection(&timerResolution.cs);
     }
@@ -692,6 +695,7 @@ Tcl_WaitForEvent(
 	    	timeout = 0;
 		goto wait;
 	    }
+	    Sleep(0);
 	    goto peek;
 	}
 	
@@ -810,8 +814,10 @@ Tcl_WaitForEvent(
 
     /* restore timer resolution */
     if (actualResolution) {
-	RestoreTimerResolution(actualResolution); 
+	RestoreTimerResolution(actualResolution);
     }
+    /* todo: move it to the service-thread (if available at some point) */
+    TclWinResetTimerResolution();
     return status;
 }
 
@@ -945,6 +951,8 @@ Tcl_Sleep(
     if (actualResolution) {
 	RestoreTimerResolution(actualResolution); 
     }
+    /* todo: move it to the service-thread (if available at some point) */
+    TclWinResetTimerResolution();
 }
 
 /*
-- 
cgit v0.12


From 62e00681cf398709d6a32eaa1ae0ccae3a5da9ef Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:42 +0000
Subject: interim commit: trying to resolve time-freezes with new facilities
 timeJump/timeJumpEpoch

---
 generic/tclEvent.c  |  22 ++-
 generic/tclInt.h    |  49 ++++-
 generic/tclInterp.c |   4 +-
 generic/tclTimer.c  | 512 +++++++++++++++++++++++++++++++++++-----------------
 win/tclWinNotify.c  |  61 +++++--
 5 files changed, 454 insertions(+), 194 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 05e3109..53668d0 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1385,7 +1385,7 @@ Tcl_VwaitObjCmd(
     char *nameString;
     int optc = objc - 2; /* options count without cmd and varname */
     double ms = -1;
-    Tcl_Time wakeup;
+    Tcl_Time lastNow, wakeup;
     long tolerance = 0;
 
     if (objc < 2) {
@@ -1416,7 +1416,8 @@ Tcl_VwaitObjCmd(
     /* if timeout specified - create timer event or no-wait by 0ms */
     if (ms != -1) {
 	if (ms > 0) {
-	    Tcl_GetTime(&wakeup);
+	    Tcl_GetTime(&lastNow);
+	    wakeup = lastNow;
 	    TclTimeAddMilliseconds(&wakeup, ms);
 	#ifdef TMR_RES_TOLERANCE
 	    tolerance = (ms < 1000 ? ms : 1000) *
@@ -1439,11 +1440,26 @@ Tcl_VwaitObjCmd(
 	if (ms > 0) {
 	    Tcl_Time blockTime;
 	    Tcl_GetTime(&blockTime);
+	    /* 
+	     * Note time can be switched backwards, certainly adjust end-time
+	     * by possible time-jumps back.
+	     */
+	    if (TCL_TIME_BEFORE(blockTime, lastNow)) {
+		/* backwards time-jump - simply shift wakeup-time */
+		wakeup.sec -= (lastNow.sec - blockTime.sec);
+		wakeup.usec -= (lastNow.usec - blockTime.usec);
+		if (wakeup.usec < 0) {
+		    wakeup.usec += 1000000;
+		    wakeup.sec--;
+		}
+	    }
+	    /* calculate blocking time */
+	    lastNow = blockTime;
 	    blockTime.sec = wakeup.sec - blockTime.sec;
 	    blockTime.usec = wakeup.usec - blockTime.usec;
 	    if (blockTime.usec < 0) {
-		blockTime.sec--;
 		blockTime.usec += 1000000;
+		blockTime.sec--;
 	    }
 	    /* be sure process at least one event */
 	    if (  blockTime.sec < 0 
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 7576a97..d270042 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -144,10 +144,12 @@ typedef int ptrdiff_t;
  */
 
 #define TCL_PROMPT_EVENT (1 << 0)	/* Mark immediate event */
+#define TCL_ABSTMR_EVENT (1 << 1)	/* Mark absolute timer event (the time 
+					 * of TimerHandler is absolute). */
 #define TCL_IDLE_EVENT   (1 << 5)	/* Mark idle event */
 
 /*
- * This structure used for handling of prompt timer events (without time to 
+ * This structure used for handling of timer events (with or without time to 
  * invoke, e. g. created with "after 0") or declared in a call to Tcl_DoWhenIdle
  * (created with "after idle"). All of the currently-active handlers are linked
  * together into corresponding list.
@@ -173,7 +175,7 @@ typedef struct TimerEntry {
 
 				 
 typedef struct TimerHandler {
-    Tcl_Time		time;	/* When timer is to fire (if timer event). */
+    Tcl_WideInt		time;	/* When timer is to fire (absolute/relative). */
     Tcl_TimerToken	token;	/* Identifies handler so it can be deleted. */
     struct TimerEntry	entry;
 /*  ExtraData	 */
@@ -2886,6 +2888,38 @@ MODULE_SCOPE double	TclpWideClickInMicrosec(void);
 #endif
 MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
 
+/*
+ * Helper macros for working with times. TCL_TIME_BEFORE encodes how to write
+ * the ordering relation on (normalized) times, and TCL_TIME_DIFF_MS resp. 
+ * TCL_TIME_DIFF_US compute the number of milliseconds or microseconds difference
+ * between two times. Both macros use both of their arguments multiple times,
+ * so make sure they are cheap and side-effect free. 
+ * The "prototypes" for these macros are:
+ *
+ * static int		TCL_TIME_BEFORE(Tcl_Time t1, Tcl_Time t2);
+ * static Tcl_WideInt	TCL_TIME_DIFF_MS(Tcl_Time t1, Tcl_Time t2);
+ * static Tcl_WideInt	TCL_TIME_DIFF_US(Tcl_Time t1, Tcl_Time t2);
+ */
+
+#define TCL_TIME_BEFORE(t1, t2) \
+    (((t1).sec<(t2).sec) || ((t1).sec==(t2).sec && (t1).usec<(t2).usec))
+
+#define TCL_TIME_DIFF_MS(t1, t2) \
+    (1000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
+	    ((long)(t1).usec - (long)(t2).usec)/1000)
+#define TCL_TIME_DIFF_US(t1, t2) \
+    (1000000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
+	    ((long)(t1).usec - (long)(t2).usec))
+
+static inline void
+TclTimeSetMilliseconds(
+    register Tcl_Time *timePtr,
+    register double ms
+) {
+    timePtr->sec = (long)(ms / 1000);
+    timePtr->usec = (((long)ms) % 1000) * 1000 + (((long)(ms*1000)) % 1000);
+}
+
 static inline void
 TclTimeAddMilliseconds(
     register Tcl_Time *timePtr,
@@ -2958,13 +2992,16 @@ MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 MODULE_SCOPE void	TclSetTimerEventMarker(int head);
 MODULE_SCOPE int	TclServiceTimerEvents(void);
 MODULE_SCOPE int	TclServiceIdleEx(int flags, int count);
+MODULE_SCOPE TimerEntry* TclpCreateTimerHandlerEx(
+			    Tcl_WideInt usec,
+			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
+			    size_t extraDataSize, int flags);
+MODULE_SCOPE Tcl_TimerToken TclCreateRelativeTimerHandler(
+			    Tcl_Time *timeOffsPtr, Tcl_TimerProc *proc,
+			    ClientData clientData);
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
 			    ClientData clientData);
-MODULE_SCOPE TimerEntry* TclCreateAbsoluteTimerHandlerEx(
-			    Tcl_Time *timePtr,
-			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
-			    size_t extraDataSize);
 MODULE_SCOPE TimerEntry* TclCreateTimerEntryEx(
 			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
 			    size_t extraDataSize, int flags);
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index 5f1b958..b461f40 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -3730,8 +3730,8 @@ Tcl_LimitSetTime(
 	nextMoment.sec++;
 	nextMoment.usec -= 1000000;
     }
-    iPtr->limit.timeEvent = TclCreateAbsoluteTimerHandlerEx(&nextMoment,
-	    TimeLimitCallback, TimeLimitDeleteCallback, 0);
+    iPtr->limit.timeEvent = TclCreateTimerHandlerEx(&nextMoment,
+	    TimeLimitCallback, TimeLimitDeleteCallback, 0, TCL_ABSTMR_EVENT);
     iPtr->limit.timeEvent->clientData = interp;
     iPtr->limit.exceeded &= ~TCL_LIMIT_TIME;
 }
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index a7fd50b..9eaf944 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -60,17 +60,22 @@ typedef struct AfterAssocData {
  */
 
 typedef struct {
-    TimerEntry *timerList;	/* First event in queue. */
-    TimerEntry *lastTimerPtr;	/* Last event in queue. */
+    Tcl_WideInt relTimerBase;	/* Time base (offset) of the last known relative,
+				 * timer, used to revert all events to the new
+				 * base after possible time-jump (adjustment).*/
+    TimerEntry *relTimerList;	/* First event in queue of relative timers. */
+    TimerEntry *relTimerTail;	/* Last event in queue of relative timers. */
     TimerEntry *promptList;	/* First immediate event in queue. */
-    TimerEntry *lastPromptPtr;	/* Last immediate event in queue. */
+    TimerEntry *promptTail;	/* Last immediate event in queue. */
+    TimerEntry *absTimerList;	/* First event in queue of absolute timers. */
+    TimerEntry *absTimerTail;	/* Last event in queue of absolute timers. */
     size_t timerListEpoch;	/* Used for safe process of event queue (stop
     				 * the cycle after modifying of event queue) */
     int lastTimerId;		/* Timer identifier of most recently created
-				 * timer. */
+				 * timer event. */
     int timerPending;		/* 1 if a timer event is in the queue. */
     TimerEntry *idleList;	/* First in list of all idle handlers. */
-    TimerEntry *lastIdlePtr;	/* Last in list (or NULL for empty list). */
+    TimerEntry *idleTail;	/* Last in list (or NULL for empty list). */
     size_t timerGeneration;	/* Used to fill in the "generation" fields of */
     size_t idleGeneration;	/* timer or idle structures. Increments each
 				 * time we place a new handler to queue inside,
@@ -92,27 +97,6 @@ static Tcl_ThreadDataKey dataKey;
 	    ClientData2TimerEntry(ptr)
 
 /*
- * Helper macros for working with times. TCL_TIME_BEFORE encodes how to write
- * the ordering relation on (normalized) times, and TCL_TIME_DIFF_MS computes
- * the number of milliseconds difference between two times. Both macros use
- * both of their arguments multiple times, so make sure they are cheap and
- * side-effect free. The "prototypes" for these macros are:
- *
- * static int	TCL_TIME_BEFORE(Tcl_Time t1, Tcl_Time t2);
- * static long	TCL_TIME_DIFF_MS(Tcl_Time t1, Tcl_Time t2);
- */
-
-#define TCL_TIME_BEFORE(t1, t2) \
-    (((t1).sec<(t2).sec) || ((t1).sec==(t2).sec && (t1).usec<(t2).usec))
-
-#define TCL_TIME_DIFF_MS(t1, t2) \
-    (1000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
-	    ((long)(t1).usec - (long)(t2).usec)/1000)
-#define TCL_TIME_DIFF_US(t1, t2) \
-    (1000000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
-	    ((long)(t1).usec - (long)(t2).usec))
-
-/*
  * Prototypes for functions referenced only in this file:
  */
 
@@ -295,14 +279,14 @@ TimerExitProc(
     if (tsdPtr != NULL) {
 	Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
 
-	while ((tsdPtr->lastPromptPtr) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->lastPromptPtr);
+	while ((tsdPtr->promptTail) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->promptTail);
 	}
-	while ((tsdPtr->lastTimerPtr) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->lastTimerPtr);
+	while ((tsdPtr->absTimerTail) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->absTimerTail);
 	}
-	while ((tsdPtr->lastIdlePtr) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->lastIdlePtr);
+	while ((tsdPtr->idleTail) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->idleTail);
 	}
     }
 }
@@ -333,21 +317,19 @@ Tcl_CreateTimerHandler(
     ClientData clientData)	/* Arbitrary data to pass to proc. */
 {
     register TimerEntry *entryPtr;
-    Tcl_Time time;
+    Tcl_WideInt usec;
 
     /*
-     * Compute when the event should fire.
+     * Compute when the event should fire (avoid overflow).
      */
 
-    Tcl_GetTime(&time);
-    time.sec += milliseconds/1000;
-    time.usec += (milliseconds%1000)*1000;
-    if (time.usec >= 1000000) {
-	time.usec -= 1000000;
-	time.sec += 1;
+    if (milliseconds < 0x7FFFFFFFFFFFFFFFL / 1000) {
+	usec = (Tcl_WideInt)milliseconds*1000;
+    } else {
+	usec = 0x7FFFFFFFFFFFFFFFL;
     }
 
-    entryPtr = TclCreateAbsoluteTimerHandlerEx(&time, proc, NULL, 0);
+    entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, 0);
     if (entryPtr == NULL) {
     	return NULL;
     }
@@ -359,31 +341,32 @@ Tcl_CreateTimerHandler(
 /*
  *--------------------------------------------------------------
  *
- * TclCreateAbsoluteTimerHandlerEx -- , TclCreateAbsoluteTimerHandler --
+ * TclpCreateTimerHandlerEx --
  *
- *	Arrange for a given function to be invoked at a particular time in the
- *	future.
+ *	Arrange for a given function to be invoked at or in a particular time
+ *	in the future (microseconds).
  *
  * Results:
- *	The return value is a handler entry or token of the timer event, which
- *	may be used to delete the event before it fires.
+ *	The return value is a handler entry of the timer event, which may be
+ *	used to access the event entry, e. g. delete the event before it fires.
  *
  * Side effects:
- *	When the time in timePtr has been reached, proc will be invoked
+ *	When the time or offset in timePtr has been reached, proc will be invoked
  *	exactly once.
  *
  *--------------------------------------------------------------
  */
 
 TimerEntry*
-TclCreateAbsoluteTimerHandlerEx(
-    Tcl_Time *timePtr,			/* Time to be invoked */
-    Tcl_TimerProc *proc,		/* Function to invoke */
-    Tcl_TimerDeleteProc *deleteProc,	/* Function to cleanup */
-    size_t extraDataSize)
+TclpCreateTimerHandlerEx(
+    Tcl_WideInt usec,		/* Time to be invoked (absolute/relative) */
+    Tcl_TimerProc *proc,	/* Function to invoke */
+    Tcl_TimerDeleteProc *deleteProc,/* Function to cleanup */
+    size_t extraDataSize,	/* Size of extra data to allocate */
+    int flags)			/* If TCL_ABSTMR_EVENT, time is absolute */
 {
     register TimerEntry *entryPtr, *entryPtrPos;
-    register TimerHandler *timerPtr;
+    register TimerHandler *timerPtr, **tmrList, **tmrTail;
     ThreadSpecificData *tsdPtr;
 
     tsdPtr = InitTimer();
@@ -397,35 +380,49 @@ TclCreateAbsoluteTimerHandlerEx(
      * Fill in fields for the event.
      */
 
-    memcpy((void *)&(timerPtr->time), (void *)timePtr, sizeof(*timePtr));
     entryPtr->proc = proc;
     entryPtr->deleteProc = deleteProc;
     entryPtr->clientData = TimerEntry2ClientData(entryPtr);
-    entryPtr->flags = 0;
+    entryPtr->flags = flags & TCL_ABSTMR_EVENT;
     entryPtr->generation = tsdPtr->timerGeneration;
     tsdPtr->timerListEpoch++; /* signal-timer list was changed */
     tsdPtr->lastTimerId++;
     timerPtr->token = (Tcl_TimerToken) INT2PTR(tsdPtr->lastTimerId);
 
+    if (flags & TCL_ABSTMR_EVENT) {
+	tmrList = &tsdPtr->absTimerList;
+	tmrTail = &tsdPte->absTimerTail;
+    } else {
+	Tcl_WideInt now = TclpGetMicroseconds();
+
+    	tmrList = &tsdPtr->relTimerList;
+    	tmrTail = &tsdPtr->relTimerTail;
+    	if (tsdPtr->relTimerList) {
+    	    /* usec is relative current base (to now) */
+	    usec -= now - tsdPtr->relTimerBase;
+    	} else {
+	    tsdPtr->relTimerBase = now;
+    	}
+    }
+
+    timerPtr->time = usec;
+
     /*
      * Add the event to the queue in the correct position
      * (ordered by event firing time).
      */
 
     /* if before current first (e. g. "after 0" before first "after 1000") */
-    if ( !(entryPtrPos = tsdPtr->timerList)
-      || TCL_TIME_BEFORE(timerPtr->time, 
-	    TimerEntry2TimerHandler(entryPtrPos)->time)
+    if ( !(entryPtrPos = *tmrList)
+      || usec < TimerEntry2TimerHandler(entryPtrPos)->time
     ) {
     	/* splice to the head */
-	TclSpliceInEx(entryPtr, 
-		tsdPtr->timerList, tsdPtr->lastTimerPtr);
+	TclSpliceInEx(entryPtr, *tmrList, *tmrTail);
     } else {
     	/* search from end as long as one with time before not found */
-	for (entryPtrPos = tsdPtr->lastTimerPtr; entryPtrPos != NULL;
+	for (entryPtrPos = *tmrTail; entryPtrPos != NULL;
 	    entryPtrPos = entryPtrPos->prevPtr) {
-	    if (!TCL_TIME_BEFORE(timerPtr->time,
-		    TimerEntry2TimerHandler(entryPtrPos)->time)) {
+	    if (usec >= TimerEntry2TimerHandler(entryPtrPos)->time) {
 		break;
 	    }
 	}
@@ -436,19 +433,38 @@ TclCreateAbsoluteTimerHandlerEx(
 	    if ((entryPtr->nextPtr = entryPtrPos->nextPtr)) {
 		entryPtrPos->nextPtr->prevPtr = entryPtr;
 	    } else {
-		tsdPtr->lastTimerPtr = entryPtr;
+		*tmrTail = entryPtr;
 	    }
 	    entryPtrPos->nextPtr = entryPtr;
 	} else {
 	    /* unexpected case, but ... splice to the head */
-	    TclSpliceInEx(entryPtr, 
-		tsdPtr->timerList, tsdPtr->lastTimerPtr);
+	    TclSpliceInEx(entryPtr, *tmrList, *tmrTail);
 	}
     }
 
     return entryPtr;
 }
 
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TclCreateAbsoluteTimerHandler --
+ *
+ *	Arrange for a given function to be invoked at a particular time in the
+ *	future.
+ *
+ * Results:
+ *	The return value is a token of the timer event, which
+ *	may be used to delete the event before it fires.
+ *
+ * Side effects:
+ *	When the time in timePtr has been reached, proc will be invoked
+ *	exactly once.
+ *
+ *--------------------------------------------------------------
+ */
+
 Tcl_TimerToken
 TclCreateAbsoluteTimerHandler(
     Tcl_Time *timePtr,
@@ -456,8 +472,65 @@ TclCreateAbsoluteTimerHandler(
     ClientData clientData)
 {
     register TimerEntry *entryPtr;
+    Tcl_WideInt usec;
+
+    /*
+     * Compute when the event should fire (avoid overflow).
+     */
 
-    entryPtr = TclCreateAbsoluteTimerHandlerEx(timePtr, proc, NULL, 0);
+    if (timePtr->sec < 0x7FFFFFFFFFFFFFFFL / 1000000) {
+	usec = (((Tcl_WideInt)timePtr->sec) * 1000000) + timePtr->usec;
+    } else {
+	usec = 0x7FFFFFFFFFFFFFFFL;
+    }
+
+    entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, TCL_ABSTMR_EVENT);
+    if (entryPtr == NULL) {
+    	return NULL;
+    }
+    entryPtr->clientData = clientData;
+
+    return TimerEntry2TimerHandler(entryPtr)->token;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TclCreateRelativeTimerHandler --
+ *
+ *	Arrange for a given function to be invoked in a particular time offset
+ *	in the future.
+ *
+ * Results:
+ *	The return value is token of the timer event, which
+ *	may be used to delete the event before it fires.
+ *
+ * Side effects:
+ *	In contrary to absolute timer functions operate on relative time.
+ *
+ *--------------------------------------------------------------
+ */
+
+Tcl_TimerToken
+TclCreateRelativeTimerHandler(
+    Tcl_Time *timePtr,
+    Tcl_TimerProc *proc,
+    ClientData clientData)
+{
+    register TimerEntry *entryPtr;
+    Tcl_WideInt usec;
+
+    /*
+     * Compute when the event should fire (avoid overflow).
+     */
+
+    if (timePtr->sec < 0x7FFFFFFFFFFFFFFFL / 1000000) {
+	usec = (((Tcl_WideInt)timePtr->sec) * 1000000) + timePtr->usec;
+    } else {
+	usec = 0x7FFFFFFFFFFFFFFFL;
+    }
+
+    entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, TCL_ABSTMR_EVENT);
     if (entryPtr == NULL) {
     	return NULL;
     }
@@ -496,7 +569,7 @@ Tcl_DeleteTimerHandler(
 	return;
     }
 
-    for (entryPtr = tsdPtr->lastTimerPtr;
+    for (entryPtr = tsdPtr->absTimerTail;
 	entryPtr != NULL;
 	entryPtr = entryPtr->prevPtr
     ) {
@@ -531,7 +604,8 @@ Tcl_DeleteTimerHandler(
 void
 TclDeleteTimerEntry(
     TimerEntry *entryPtr)	/* Result previously returned by */
-	/* TclCreateAbsoluteTimerHandlerEx or TclCreateTimerEntryEx. */
+	/* TclCreateRelativeTimerHandlerEx, TclCreateAbsoluteTimerHandlerEx
+	 * or TclCreateTimerEntryEx. */
 {
     ThreadSpecificData *tsdPtr;
 
@@ -542,15 +616,19 @@ TclDeleteTimerEntry(
     tsdPtr = InitTimer();
 
     if (entryPtr->flags & TCL_PROMPT_EVENT) {
-    	/* prompt handler */
-	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
+	/* prompt handler */
+	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
     } else if (entryPtr->flags & TCL_IDLE_EVENT) {
-    	/* idle handler */
-	TclSpliceOutEx(entryPtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+	/* idle handler */
+	TclSpliceOutEx(entryPtr, tsdPtr->idleList, tsdPtr->idleTail);
     } else {
-    	/* timer event-handler */
+	/* timer event-handler */
 	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
-	TclSpliceOutEx(entryPtr, tsdPtr->timerList, tsdPtr->lastTimerPtr);
+	if (entryPtr->flags & TCL_ABSTMR_EVENT) {
+	    TclSpliceOutEx(entryPtr, tsdPtr->absTimerList, tsdPtr->absTimerTail);
+	} else e
+	    TclSpliceOutEx(entryPtr, tsdPtr->relTimerList, tsdPtr->relTimerTail);
+	}
     }
 
     /* free it via deleteProc or ckfree */
@@ -559,13 +637,45 @@ TclDeleteTimerEntry(
     }
 
     if (entryPtr->flags & (TCL_PROMPT_EVENT|TCL_IDLE_EVENT)) {
-    	ckfree((char *)entryPtr);
+	ckfree((char *)entryPtr);
     } else {
-    	/* shift to the allocated pointer */
-    	ckfree((char *)TimerEntry2TimerHandler(entryPtr));
+	/* shift to the allocated pointer */
+	ckfree((char *)TimerEntry2TimerHandler(entryPtr));
     }
 }
 
+static Tcl_WideInt
+TimerGetFirstTimeOffs(
+    ThreadSpecificData *tsdPtr,
+    TimerEntry **entryPtr)
+{
+    Tcl_WideInt firstTime = -0x7FFFFFFFFFFFFFFFL;
+    Tcl_WideInt now = TclpGetMicroseconds();
+
+    /* consider time-jump back */
+    if (tsdPtr->relTimerList) {
+	if (now < tsdPtr->relTimerBase) { /* switched back */
+	    /* 
+	     * Because the real jump is unknown (resp. too complex to retrieve
+	     * accross all threads), we simply accept possible small increment
+	     * of the real wait-time.
+	     */
+	    tsdPtr->relTimerBase = now; /* just shift the base back */
+	}
+	firstTime = tsdPtr->relTimerBase
+	    + TimerEntry2TimerHandler(tsdPtr->absTimerList)->time;
+        if (entryPtr) { *entryPtr = tsdPtr->relTimerBase; }
+    }
+
+    if ( tsdPtr->absTimerList
+      && firstTime < TimerEntry2TimerHandler(tsdPtr->absTimerList)->time
+    ) {
+	firstTime = TimerEntry2TimerHandler(tsdPtr->absTimerList)->time;
+        if (entryPtr) { *entryPtr = tsdPtr->absTimerList; }
+    }
+
+    return firstTime - now;
+}
 /*
  *----------------------------------------------------------------------
  *
@@ -589,7 +699,7 @@ TimerSetupProc(
     ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_Time blockTime, *firstTime;
+    Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
     long tolerance = 0;
 
@@ -605,33 +715,34 @@ TimerSetupProc(
 	blockTime.sec = 0;
 	blockTime.usec = 0;
 
-    } else if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerList) {
+    } else if (
+	   (flags & TCL_TIMER_EVENTS) 
+	&& (tsdPtr->relTimerList || tsdPtr->absTimerList)
+    ) {
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
 
-	Tcl_GetTime(&blockTime);
-	firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
-	blockTime.sec = firstTime->sec - blockTime.sec;
-	blockTime.usec = firstTime->usec - blockTime.usec;
-	if (blockTime.usec < 0) {
-	    blockTime.sec--;
-	    blockTime.usec += 1000000;
-	}
-	if (blockTime.sec < 0) {
+	Tcl_WideInt timeOffs = TimerGetFirstTimeOffs(tsdPtr, NULL);
+
+	if (timeOffs > 0) {
+	    blockTime.sec = (long) (timeOffs / 1000000);
+	    blockTime.usec = (unsigned long) (timeOffs % 1000000);
+
+	#ifdef TMR_RES_TOLERANCE
+	    /* consider timer resolution tolerance (avoid busy wait) */
+	    tolerance = ((timeOffs <= 1000000) ? timeOffs : 1000000) *
+				TMR_RES_TOLERANCE / 100;
+	#endif
+	} else {
 	    blockTime.sec = 0;
 	    blockTime.usec = 0;
 	}
 	
-    #ifdef TMR_RES_TOLERANCE
-	/* consider timer resolution tolerance (avoid busy wait) */
-	tolerance = ((blockTime.sec <= 0) ? blockTime.usec : 1000000) *
-				(TMR_RES_TOLERANCE / 100);
-    #endif
 	/*
 	* If the first timer has expired, stick an event on the queue right now.
 	*/
-	if (!tsdPtr->timerPending && blockTime.sec == 0 && blockTime.usec <= tolerance) {
+	if (!tsdPtr->timerPending && timeOffs <= tolerance) {
 	    TclSetTimerEventMarker(0);
 	    tsdPtr->timerPending = 1;
 	}
@@ -665,8 +776,9 @@ TimerCheckProc(
     ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_Time blockTime, *firstTime;
+    Tcl_WideInt timeOffs;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
+    long tolerance = 0;
 
     if (!(flags & TCL_TIMER_EVENTS)) {
     	return;
@@ -675,26 +787,25 @@ TimerCheckProc(
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
     /* If already pending (or no timer-events) */
-    if (tsdPtr->timerPending || !tsdPtr->timerList) {
+    if (tsdPtr->timerPending || !(tsdPtr->relTimerList || tsdPtr->absTimerList)) {
     	return;
     }
 
     /*
      * Verify the first timer on the queue.
      */
-    Tcl_GetTime(&blockTime);
-    firstTime = &(TimerEntry2TimerHandler(tsdPtr->timerList)->time);
-    blockTime.sec = firstTime->sec - blockTime.sec;
-    blockTime.usec = firstTime->usec - blockTime.usec;
-    if (blockTime.usec < 0) {
-        blockTime.sec--;
-        blockTime.usec += 1000000;
-    }
-    
+    timeOffs = TimerGetFirstTimeOffs(tsdPtr, NULL);
+
+#ifdef TMR_RES_TOLERANCE
+    /* consider timer resolution tolerance (avoid busy wait) */
+    tolerance = ((timeOffs <= 1000000) ? timeOffs : 1000000) *
+			TMR_RES_TOLERANCE / 100;
+#endif
+   
     /*
     * If the first timer has expired, stick an event on the queue.
     */
-    if (blockTime.sec < 0 || (blockTime.sec == 0 && blockTime.usec <= 0)) {
+    if (timeOffs <= tolerance) {
 	TclSetTimerEventMarker(0);
 	tsdPtr->timerPending = 1;
     }
@@ -765,7 +876,7 @@ TclServiceTimerEvents(void)
 	&& entryPtr->generation <= currentGeneration
     ) {
 	/* detach entry from the owner's list */
-	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
+	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
 
 	/* reset current timer pending (correct process nested wait event) */
 	prevTmrPending = tsdPtr->timerPending;
@@ -790,12 +901,12 @@ TclServiceTimerEvents(void)
     }
 
     /* Hereafter all timer events with time before now */
-    if (!tsdPtr->timerList) {
+    if (!tsdPtr->absTimerList) {
     	goto done;
     }
     Tcl_GetTime(&time);
-    for (entryPtr = tsdPtr->timerList;
-	 entryPtr != NULL;
+    for (entryPtr = tsdPtr->absTimerList;
+	 entryPtr != NULLe
 	 entryPtr = nextPtr
     ) {
     	nextPtr = entryPtr->nextPtr;
@@ -831,7 +942,7 @@ TclServiceTimerEvents(void)
 	 */
 
 	TclSpliceOutEx(entryPtr, 
-	    tsdPtr->timerList, tsdPtr->lastTimerPtr);
+	    tsdPtr->absTimerLise, tsdPtr->absTimerTail);
 
 	currentEpoch = tsdPtr->timerListEpoch;
 
@@ -867,8 +978,8 @@ done:
     }
 
     /* Reset generation if both timer queue are empty */
-    if (!tsdPtr->timerList) {
-	tsdPtr->timerGeneration = 0;
+    if (!tsdPtr->absTimerList) {
+	tsdPtr->timerGeneratioe = 0;
     }
 
     /* Compute the next timeout (later via TimerSetupProc using the first timer). */
@@ -924,7 +1035,7 @@ TclCreateTimerEntryEx(
     	 * call of "after 0" and "after 1" */
 	entryPtr->generation = tsdPtr->timerGeneration;
 	/* attach to the prompt queue */
-	TclSpliceTailEx(entryPtr, tsdPtr->promptList, tsdPtr->lastPromptPtr);
+	TclSpliceTailEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
 	
 	/* execute immediately: signal pending and set timer marker */
 	tsdPtr->timerPending++;
@@ -933,7 +1044,7 @@ TclCreateTimerEntryEx(
     	/* idle generation */
 	entryPtr->generation = tsdPtr->idleGeneration;
 	/* attach to the idle queue */
-	TclSpliceTailEx(entryPtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+	TclSpliceTailEx(entryPtr, tsdPtr->idleList, tsdPtr->idleTail);
     }
 
     return entryPtr;
@@ -1003,7 +1114,7 @@ Tcl_CancelIdleCall(
 	if ((idlePtr->proc == proc)
 		&& (idlePtr->clientData == clientData)) {
 	    /* detach entry from the owner list */
-	    TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+	    TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->idleTail);
 
 	    /* free it via deleteProc and ckfree */
 	    if (idlePtr->deleteProc) {
@@ -1067,7 +1178,7 @@ TclServiceIdleEx(
 
     while (idlePtr->generation <= currentGeneration) {
 	/* detach entry from the owner's list */
-	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->lastIdlePtr);
+	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->idleTail);
 
 	/* execute event */
 	(*idlePtr->proc)(idlePtr->clientData);
@@ -1108,6 +1219,58 @@ TclServiceIdle(void)
 /*
  *----------------------------------------------------------------------
  *
+ * TclGetTimeFromObj --
+ *
+ *	This function converts numeric tcl-object contains decimal milliseconds,
+ *	(using milliseconds base) to time offset in microseconds,
+ *
+ *	If input object contains double, the return time has microsecond 
+ *	precision.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	If possible leaves internal representation unchanged (e. g. integer).
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclpGetUTimeFromObj(
+    Tcl_Interp	*interp,	/* Current interpreter or NULL. */
+    Tcl_Obj *CONST objPtr,	/* Object to read numeric time (in milliseconds). */
+    Tcl_WideInt	*timePtr)	/* Resulting time if converted (in microseconds). */
+{
+    if (objPtr->typePtr != &tclDoubleType) {
+	Tcl_WideInt ms;
+	if (Tcl_GetWideIntFromObj(NULL, objPtr, &ms) == TCL_OK) {
+	    if (ms < 0x7FFFFFFFFFFFFFFFL / 1000) { /* avoid overflow */
+		*timePtr = (ms * 1000);
+		return TCL_OK;
+	    }
+	    *timePtr = 0x7FFFFFFFFFFFFFFFL;
+	    return TCL_OK;
+	}
+    }
+    if (1) {
+	double ms;
+	if (Tcl_GetDoubleFromObj(interp, objv[1], &ms) == TCL_OK) {
+	    if (ms < 0x7FFFFFFFFFFFFFFFL / 1000) { /* avoid overflow */
+		/* use precise as possible calculation by double (microseconds) */
+		*timePtr = ((Tcl_WideInt)ms) * 1000 + (((long)(ms*1000)) % 1000);
+		return TCL_OK;
+	    }
+	    *timePtr = 0x7FFFFFFFFFFFFFFFL;
+	    return TCL_OK;
+	}
+    }
+    return TCL_ERROR;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_AfterObjCmd --
  *
  *	This function is invoked to process the "after" Tcl command. See the
@@ -1130,15 +1293,15 @@ Tcl_AfterObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
-    double ms;		/* Number of milliseconds to wait */
+    Tcl_WideInt usec;		/* Number of microseconds to wait (or time to wakeup) */
     AfterInfo *afterPtr;
     AfterAssocData *assocPtr;
     int length;
     int index;
     static CONST char *afterSubCmds[] = {
-	"cancel", "idle", "info", NULL
+	"at", "cancel", "idle", "info", NULL
     };
-    enum afterSubCmds {AFTER_CANCEL, AFTER_IDLE, AFTER_INFO};
+    enum afterSubCmds {AFTER_AT, AFTER_CANCEL, AFTER_IDLE, AFTER_INFO};
     ThreadSpecificData *tsdPtr = InitTimer();
 
     if (objc < 2) {
@@ -1167,39 +1330,58 @@ Tcl_AfterObjCmd(
 
     index = -1;
     if ( ( TclObjIsIndexOfTable(objv[1], afterSubCmds)
-	|| Tcl_GetDoubleFromObj(NULL, objv[1], &ms) != TCL_OK
+	|| TclpGetUTimeFromObj(NULL, objv[1], &usec) != TCL_OK
       )
       && Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0,
 				 &index) != TCL_OK
     ) {
 	Tcl_AppendResult(interp, "bad argument \"",
 		Tcl_GetString(objv[1]),
-		"\": must be cancel, idle, info, or an integer", NULL);
+		"\": must be at, cancel, idle, info, or a time", NULL);
 	return TCL_ERROR;
     }
 
     /* 
-     * At this point, either index = -1 and ms contains the number of ms
+     * At this point, either index = -1 and usec contains the time
      * to wait, or else index is the index of a subcommand.
      */
 
     switch (index) {
-    case -1: {
-    	TimerEntry *entryPtr;
-	if (ms < 0) {
-	    ms = 0;
+    case -1:
+	/* usec already contains time-offset from objv[1] */
+	/* relative time offset should be positive */
+	if (usec < 0) {
+	    usec = 0;
 	}
 	if (objc == 2) {
-	    return AfterDelay(interp, ms);
+	    /* after <offset> */
+	    return AfterDelay(interp, usec, 0);
+	}
+    case AFTER_AT: {
+    	TimerEntry *entryPtr;
+    	int flags = 0;
+    	if (index == AFTER_AT) {
+	    if (objc < 3) {
+		Tcl_WrongNumArgs(interp, 2, objv, "time");
+		return TCL_ERROR;
+	    }
+	    /* get time from objv[2] */
+	    if (TclpGetUTimeFromObj(interp, objv[2], &usec) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	    if (objc == 3) {
+		/* after at <time> */
+		return AfterDelay(interp, usec, flags);
+	    }
+	    flags = TCL_ABSTMR_EVENT;
 	}
 
-	if (ms) {
-	    Tcl_Time wakeup;
-	    Tcl_GetTime(&wakeup);
-	    TclTimeAddMilliseconds(&wakeup, ms);
-	    entryPtr = TclCreateAbsoluteTimerHandlerEx(&wakeup, AfterProc,
-			    FreeAfterPtr, sizeof(AfterInfo));
+	if (usec || (index == AFTER_AT)) {
+	    /* after ?at? <time|offset> <command> ... */
+	    entryPtr = TclpCreateTimerHandlerEx(usec, AfterProc,
+			    FreeAfterPtr, sizeof(AfterInfo), flags);
 	} else {
+	    /* after 0 <command> ... */
 	    entryPtr = TclCreateTimerEntryEx(AfterProc,
 			    FreeAfterPtr, sizeof(AfterInfo), TCL_PROMPT_EVENT);
 	}
@@ -1381,15 +1563,14 @@ Tcl_AfterObjCmd(
 static int
 AfterDelay(
     Tcl_Interp *interp,
-    double ms)
+    double ms,
+    int absolute)
 {
     Interp *iPtr = (Interp *) interp;
 
-    Tcl_Time endTime, now, prevNow;
-    Tcl_WideInt diff, prevUS, nowUS;
-#ifdef TMR_RES_TOLERANCE
-    long tolerance;
-#endif
+    Tcl_Time endTime, now, lastNow;
+    Tcl_WideInt diff;
+    long tolerance = 0;
 
     if (ms <= 0) {
 	/* to cause a context switch only */
@@ -1402,20 +1583,12 @@ AfterDelay(
     tolerance = ((ms < 1000) ? ms : 1000) * (1000 * TMR_RES_TOLERANCE / 100);
 #endif
 
-    prevUS = TclpGetMicroseconds();
-    Tcl_GetTime(&endTime); now = endTime;
-    prevNow = now;
+    Tcl_GetTime(&now);
+    lastNow = endTime = now;
+    if (absolute)
     TclTimeAddMilliseconds(&endTime, ms);
 
     do {
-    	nowUS = TclpGetMicroseconds();
-	Tcl_GetTime(&now);
-	if (now.sec < prevNow.sec || (now.sec == prevNow.sec && now.usec < prevNow.usec) ) {
-	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!long-diff!!!! %5.3f, prev: %d.%06d - now: %d.%06d (%d usec)\n", ms, prevNow.sec, prevNow.usec, now.sec, now.usec, now.usec - prevNow.usec);
-	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!long-diff!!!! %5.3f, prev: %I64d - now: %I64d (%I64d usec)\n", ms, prevUS, nowUS, nowUS - prevUS);
-	    //Tcl_Panic("Time running backwards!");
-	    //return TCL_ERROR;
-	}
 	if (iPtr->limit.timeEvent != NULL
 	    && TCL_TIME_BEFORE(iPtr->limit.time, now)) {
 	    iPtr->limit.granularityTicker = 0;
@@ -1426,9 +1599,6 @@ AfterDelay(
 	if (iPtr->limit.timeEvent == NULL
 	    || TCL_TIME_BEFORE(endTime, iPtr->limit.time)) {
 	    diff = TCL_TIME_DIFF_MS(endTime, now);
-	    if (TCL_TIME_DIFF_US(endTime, now) > 500 || TCL_TIME_DIFF_US(endTime, now) < -500) {
-		//printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!drift!!!! %5.3f, diff: %d -- %d.%06d - %d.%06d (%d usec)\n", ms, (int)diff, endTime.sec, endTime.usec, now.sec, now.usec, TCL_TIME_DIFF_US(endTime, now));
-	    }
 #ifndef TCL_WIDE_INT_IS_LONG
 	    if (diff > LONG_MAX) {
 		diff = LONG_MAX;
@@ -1436,7 +1606,6 @@ AfterDelay(
 #endif
 	    if (diff > 0) {
 		Tcl_Sleep((long)diff);
-		nowUS = TclpGetMicroseconds();
 		Tcl_GetTime(&now);
 	    }
 	} else {
@@ -1448,24 +1617,33 @@ AfterDelay(
 #endif
 	    if (diff > 0) {
 		Tcl_Sleep((long)diff);
-		nowUS = TclpGetMicroseconds();
 		Tcl_GetTime(&now);
 	    }
 	    if (Tcl_LimitCheck(interp) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	}
-	/* consider timer resolution tolerance (avoid busy wait) */
-	prevNow = now;
-	prevUS = nowUS;
-    #ifdef TMR_RES_TOLERANCE
-	now.usec += tolerance;
-	if (now.usec > 1000000) {
-	    now.usec -= 1000000;
-	    now.sec++;
+
+	/* 
+	 * Note time can be switched backwards, certainly adjust end-time
+	 * by possible time-jumps back.
+	 */
+	if (!absolute && TCL_TIME_BEFORE(now, lastNow)) {
+	    /* backwards time-jump - simply shift wakeup-time */
+	    endTime.sec -= (lastNow.sec - now.sec);
+	    endTime.usec -= (lastNow.usec - now.usec);
+	    if (endTime.usec < 0) {
+	        endTime.usec += 1000000;
+	        endTime.sec--;
+	    }
 	}
-    #endif
-    } while (TCL_TIME_BEFORE(now, endTime));
+	lastNow = now;
+
+	/* consider timer resolution tolerance (avoid busy wait) */
+    } while (
+	(now.sec > endTime.sec)
+     || (now.sec == endTime.sec && now.usec >= endTime.usec - tolerance)
+    );
     return TCL_OK;
 }
 
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index 6c7b3b7..d22373e 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -634,7 +634,7 @@ Tcl_WaitForEvent(
     DWORD timeout, result = WAIT_TIMEOUT;
     int status = 0;
     Tcl_Time waitTime = {0, 0};
-    Tcl_Time endTime;
+    Tcl_Time lastNow, endTime;
     long tolerance = 0;
     unsigned long actualResolution = 0;
 
@@ -670,6 +670,7 @@ Tcl_WaitForEvent(
 
 	/* calculate end of wait */
 	Tcl_GetTime(&endTime);
+	lastNow = endTime;
 	endTime.sec += waitTime.sec;
 	endTime.usec += waitTime.usec;
 	if (endTime.usec > 1000000) {
@@ -798,6 +799,22 @@ Tcl_WaitForEvent(
 	Tcl_Time now;
 
 	Tcl_GetTime(&now);
+	/* 
+	 * Note time can be switched backwards, certainly adjust end-time
+	 * by possible time-jumps back.
+	 */
+	if (TCL_TIME_BEFORE(now, lastNow)) {
+	    /* backwards time-jump - simply shift wakeup-time */
+	    endTime.sec -= (lastNow.sec - now.sec);
+	    endTime.usec -= (lastNow.usec - now.usec);
+	    if (endTime.usec < 0) {
+	        endTime.usec += 1000000;
+	        endTime.sec--;
+	    }
+	}
+	lastNow = now;
+
+	/* calculate new waitTime */
 	waitTime.sec = (endTime.sec - now.sec);
 	if ((waitTime.usec = (endTime.usec - now.usec)) < 0) {
 	    waitTime.usec += 1000000;
@@ -851,11 +868,12 @@ Tcl_Sleep(
      * requisite amount.
      */
 
-    Tcl_Time now;		/* Current wall clock time. */
+    Tcl_Time lastNow, now;	/* Current wall clock time. */
     Tcl_Time desired;		/* Desired wakeup time. */
     Tcl_Time vdelay;		/* Time to sleep, for scaling virtual ->
 				 * real. */
     DWORD sleepTime;		/* Time to sleep, real-time */
+    long tolerance = 0;
     unsigned long actualResolution = 0;
 
     if (ms <= 0) {
@@ -872,6 +890,7 @@ Tcl_Sleep(
     vdelay.usec = (ms % 1000) * 1000;
 
     Tcl_GetTime(&now);
+    lastNow = now;
     desired.sec  = now.sec  + vdelay.sec;
     desired.usec = now.usec + vdelay.usec;
     if (desired.usec > 1000000) {
@@ -879,16 +898,11 @@ Tcl_Sleep(
 	desired.sec++;
     }
 
-#ifdef TMR_RES_TOLERANCE
+  #ifdef TMR_RES_TOLERANCE
     /* calculate possible maximal tolerance (in usec) of original wait-time */
-    if (vdelay.sec <= 0) {
-	desired.usec -= vdelay.usec * (TMR_RES_TOLERANCE / 100);
-	if (desired.usec < 0) {
-	    desired.usec += 1000000;
-	    desired.sec--;
-	}
-    }
-#endif
+    tolerance = ((vdelay.sec <= 0) ? vdelay.usec : 1000000) *
+			(TMR_RES_TOLERANCE / 100);
+  #endif
 
     /*
      * TIP #233: Scale delay from virtual to real-time.
@@ -933,17 +947,32 @@ Tcl_Sleep(
     wait:
 	Sleep(sleepTime);
 	Tcl_GetTime(&now);
-	if (now.sec > desired.sec) {
-	    break;
-	} else if ((now.sec == desired.sec) && (now.usec >= desired.usec)) {
-	    break;
+	/* 
+	 * Note time can be switched backwards, certainly adjust end-time
+	 * by possible time-jumps back.
+	 */
+	if (TCL_TIME_BEFORE(now, lastNow)) {
+	    /* backwards time-jump - simply shift wakeup-time */
+	    desired.sec -= (lastNow.sec - now.sec);
+	    desired.usec -= (lastNow.usec - now.usec);
+	    if (desired.usec < 0) {
+	        desired.usec += 1000000;
+	        desired.sec--;
+	    }
 	}
+	lastNow = now;
 
 	vdelay.sec  = desired.sec  - now.sec;
 	vdelay.usec = desired.usec - now.usec;
 	if (vdelay.usec < 0) {
-	    vdelay.sec--;
 	    vdelay.usec += 1000000;
+	    vdelay.sec--;
+	}
+
+	if (vdelay.sec < 0) {
+	    break;
+	} else if ((vdelay.sec == 0) && (vdelay.usec <= tolerance)) {
+	    break;
 	}
     }
 
-- 
cgit v0.12


From 345ea34a7e160b62787cd3397d80dce03a4d1ee6 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:50 +0000
Subject: interim commit: trying to resolve time-freezes with new facilities
 timeJump/timeJumpEpoch

---
 generic/tclEvent.c  |  67 +++++++--------
 generic/tclInt.h    |  11 +++
 generic/tclInterp.c |  11 +--
 generic/tclTimer.c  | 239 +++++++++++++++++++++++++++++-----------------------
 unix/tclUnixTime.c  |  28 ++++++
 win/tclWinNotify.c  | 212 ++++++++++++++++++++++------------------------
 win/tclWinTime.c    |  64 ++++++++++++--
 7 files changed, 362 insertions(+), 270 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 53668d0..9a20cc2 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1384,9 +1384,10 @@ Tcl_VwaitObjCmd(
     int flags = TCL_ALL_EVENTS; /* default flags */
     char *nameString;
     int optc = objc - 2; /* options count without cmd and varname */
-    double ms = -1;
-    Tcl_Time lastNow, wakeup;
+    Tcl_WideInt usec = -1;
+    Tcl_WideInt lastNow = 0, wakeup = 0;
     long tolerance = 0;
+    size_t timeJumpEpoch = 0;
 
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?options? ?timeout? name");
@@ -1399,7 +1400,8 @@ Tcl_VwaitObjCmd(
 	 * we assume that option is not an integer, try to get numeric timeout
 	 */
 	if (!TclObjIsIndexOfTable(objv[optc], updateEventOptions)
-	  && Tcl_GetDoubleFromObj(NULL, objv[optc], &ms) == TCL_OK) {
+	  && TclpGetUTimeFromObj(NULL, objv[optc], &usec) == TCL_OK) {
+	    if (usec < 0) { usec = 0; };
 	    optc--;
 	}
 
@@ -1414,16 +1416,17 @@ Tcl_VwaitObjCmd(
     done = 0;
 
     /* if timeout specified - create timer event or no-wait by 0ms */
-    if (ms != -1) {
-	if (ms > 0) {
-	    Tcl_GetTime(&lastNow);
-	    wakeup = lastNow;
-	    TclTimeAddMilliseconds(&wakeup, ms);
+    if (usec != -1) {
+	if (usec > 0) {
+	    lastNow = TclpGetMicroseconds();
+	    timeJumpEpoch = TclpGetLastTimeJumpEpoch();
 	#ifdef TMR_RES_TOLERANCE
-	    tolerance = (ms < 1000 ? ms : 1000) *
-				(1000 * TMR_RES_TOLERANCE / 100);
+	    tolerance = (usec < 1000000 ? usec : 1000000) *
+				TMR_RES_TOLERANCE / 100;
+	    usec += tolerance / 3;
 	#endif
-	} else if (ms == 0) {
+	    wakeup = lastNow + usec;
+	} else {
 	    flags |= TCL_DONT_WAIT;
 	}
     }
@@ -1437,43 +1440,37 @@ Tcl_VwaitObjCmd(
 
     do {
     	/* if wait - set blocking time */
-	if (ms > 0) {
+	if (usec > 0) {
 	    Tcl_Time blockTime;
-	    Tcl_GetTime(&blockTime);
+	    Tcl_WideInt diff, now = TclpGetMicroseconds();
 	    /* 
 	     * Note time can be switched backwards, certainly adjust end-time
 	     * by possible time-jumps back.
 	     */
-	    if (TCL_TIME_BEFORE(blockTime, lastNow)) {
-		/* backwards time-jump - simply shift wakeup-time */
-		wakeup.sec -= (lastNow.sec - blockTime.sec);
-		wakeup.usec -= (lastNow.usec - blockTime.usec);
-		if (wakeup.usec < 0) {
-		    wakeup.usec += 1000000;
-		    wakeup.sec--;
-		}
+	    
+	    if ( (diff = TclpGetLastTimeJump(&timeJumpEpoch)) != 0 
+	      || (diff = (now - lastNow)) < 0
+	    ) {
+		/* recognized time-jump - simply shift wakeup-time */
+		wakeup += diff;
 	    }
 	    /* calculate blocking time */
-	    lastNow = blockTime;
-	    blockTime.sec = wakeup.sec - blockTime.sec;
-	    blockTime.usec = wakeup.usec - blockTime.usec;
-	    if (blockTime.usec < 0) {
-		blockTime.usec += 1000000;
-		blockTime.sec--;
-	    }
+	    lastNow = now;
+	    diff = wakeup - now;
+	    diff -= 1; /* overhead for Tcl_TraceVar / Tcl_UntraceVar */
 	    /* be sure process at least one event */
-	    if (  blockTime.sec < 0 
-	      || (blockTime.sec == 0 && blockTime.usec <= tolerance)
-	    ) {
+	    if (diff <= tolerance) {
 		/* timeout occurs */
 		if (checktime) {
 		    done = -1;
 		    break;
 		}
 		/* expired, be sure non-negative values here */
-		blockTime.usec = blockTime.sec = 0;
+		diff = 0;
 		checktime = 1;
 	    }
+	    blockTime.sec = diff / 1000000;
+	    blockTime.usec = diff % 1000000;
 	    Tcl_SetMaxBlockTime(&blockTime);
 	}
 	if ((foundEvent = Tcl_DoOneEvent(flags)) <= 0) {
@@ -1485,9 +1482,9 @@ Tcl_VwaitObjCmd(
 	    if (flags & TCL_DONT_WAIT) {
 		foundEvent = 1;
 		done = -2;
-	    } else if (ms > 0 && foundEvent == 0) {
+	    } else if (usec > 0 && foundEvent == 0) {
 		foundEvent = 1;
-	    } 
+	    }
 	    /* don't stop wait - no event expected here 
 	     * (stop only on error case foundEvent < 0). */
 	    if (foundEvent < 0) {
@@ -1507,7 +1504,7 @@ Tcl_VwaitObjCmd(
 	    VwaitVarProc, (ClientData) &done);
 
     /* if timeout specified (and no errors) */
-    if (ms != -1 && foundEvent > 0) {
+    if (usec != -1 && foundEvent > 0) {
     	Tcl_Obj *objPtr;
 
 	/* done - true, timeout false */
diff --git a/generic/tclInt.h b/generic/tclInt.h
index d270042..fcb4752 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2886,19 +2886,28 @@ MODULE_SCOPE double	TclpWideClickInMicrosec(void);
 #     endif
 #   endif
 #endif
+MODULE_SCOPE Tcl_WideInt TclpGetLastTimeJump(size_t *epoch);
+MODULE_SCOPE size_t	 TclpGetLastTimeJumpEpoch(void);
 MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
 
+MODULE_SCOPE int	TclpGetUTimeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, 
+			    Tcl_WideInt *timePtr);
+MODULE_SCOPE Tcl_WideInt TclpScaleUTime(Tcl_WideInt usec);
+
+MODULE_SCOPE void	TclpUSleep(Tcl_WideInt usec);
 /*
  * Helper macros for working with times. TCL_TIME_BEFORE encodes how to write
  * the ordering relation on (normalized) times, and TCL_TIME_DIFF_MS resp. 
  * TCL_TIME_DIFF_US compute the number of milliseconds or microseconds difference
  * between two times. Both macros use both of their arguments multiple times,
  * so make sure they are cheap and side-effect free. 
+ * Macro TCL_TIME_TO_USEC converts Tcl_Time to microseconds.
  * The "prototypes" for these macros are:
  *
  * static int		TCL_TIME_BEFORE(Tcl_Time t1, Tcl_Time t2);
  * static Tcl_WideInt	TCL_TIME_DIFF_MS(Tcl_Time t1, Tcl_Time t2);
  * static Tcl_WideInt	TCL_TIME_DIFF_US(Tcl_Time t1, Tcl_Time t2);
+ * static Tcl_WideInt   TCL_TIME_TO_USEC(Tcl_Time t)
  */
 
 #define TCL_TIME_BEFORE(t1, t2) \
@@ -2910,6 +2919,8 @@ MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
 #define TCL_TIME_DIFF_US(t1, t2) \
     (1000000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
 	    ((long)(t1).usec - (long)(t2).usec))
+#define TCL_TIME_TO_USEC(t) \
+    ((Tcl_WideInt)(t).sec * 1000000 + (t).usec)
 
 static inline void
 TclTimeSetMilliseconds(
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index b461f40..03a9fe2 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -3718,19 +3718,14 @@ Tcl_LimitSetTime(
     Tcl_Time *timeLimitPtr)
 {
     Interp *iPtr = (Interp *) interp;
-    Tcl_Time nextMoment;
+    Tcl_WideInt nextMoment;
 
     memcpy(&iPtr->limit.time, timeLimitPtr, sizeof(Tcl_Time));
     if (iPtr->limit.timeEvent != NULL) {
 	TclDeleteTimerEntry(iPtr->limit.timeEvent);
     }
-    nextMoment.sec = timeLimitPtr->sec;
-    nextMoment.usec = timeLimitPtr->usec+10;
-    if (nextMoment.usec >= 1000000) {
-	nextMoment.sec++;
-	nextMoment.usec -= 1000000;
-    }
-    iPtr->limit.timeEvent = TclCreateTimerHandlerEx(&nextMoment,
+    nextMoment = TCL_TIME_TO_USEC(*timeLimitPtr) + 10;
+    iPtr->limit.timeEvent = TclpCreateTimerHandlerEx(nextMoment,
 	    TimeLimitCallback, TimeLimitDeleteCallback, 0, TCL_ABSTMR_EVENT);
     iPtr->limit.timeEvent->clientData = interp;
     iPtr->limit.exceeded &= ~TCL_LIMIT_TIME;
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 9eaf944..aad8ee3 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -60,8 +60,10 @@ typedef struct AfterAssocData {
  */
 
 typedef struct {
-    Tcl_WideInt relTimerBase;	/* Time base (offset) of the last known relative,
-				 * timer, used to revert all events to the new
+    Tcl_WideInt knownTime;	/* Last know time */
+    size_t knownTimeJumpEpoch;	/* Epoch of the last time-jump */
+    Tcl_WideInt relTimerBase;	/* Time base of the first known relative */
+				/* timer, used to revert all events to the new
 				 * base after possible time-jump (adjustment).*/
     TimerEntry *relTimerList;	/* First event in queue of relative timers. */
     TimerEntry *relTimerTail;	/* Last event in queue of relative timers. */
@@ -102,7 +104,8 @@ static Tcl_ThreadDataKey dataKey;
 
 static void		AfterCleanupProc(ClientData clientData,
 			    Tcl_Interp *interp);
-static int		AfterDelay(Tcl_Interp *interp, double ms);
+static int		AfterDelay(Tcl_Interp *interp, Tcl_WideInt usec,
+			    int absolute);
 static void		AfterProc(ClientData clientData);
 static void		FreeAfterPtr(ClientData clientData);
 static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr, Tcl_Obj *objPtr);
@@ -366,7 +369,8 @@ TclpCreateTimerHandlerEx(
     int flags)			/* If TCL_ABSTMR_EVENT, time is absolute */
 {
     register TimerEntry *entryPtr, *entryPtrPos;
-    register TimerHandler *timerPtr, **tmrList, **tmrTail;
+    TimerEntry **tmrList, **tmrTail;
+    register TimerHandler *timerPtr;
     ThreadSpecificData *tsdPtr;
 
     tsdPtr = InitTimer();
@@ -391,18 +395,32 @@ TclpCreateTimerHandlerEx(
 
     if (flags & TCL_ABSTMR_EVENT) {
 	tmrList = &tsdPtr->absTimerList;
-	tmrTail = &tsdPte->absTimerTail;
+	tmrTail = &tsdPtr->absTimerTail;
     } else {
 	Tcl_WideInt now = TclpGetMicroseconds();
 
-    	tmrList = &tsdPtr->relTimerList;
-    	tmrTail = &tsdPtr->relTimerTail;
-    	if (tsdPtr->relTimerList) {
-    	    /* usec is relative current base (to now) */
-	    usec -= now - tsdPtr->relTimerBase;
-    	} else {
-	    tsdPtr->relTimerBase = now;
-    	}
+	tmrList = &tsdPtr->relTimerList;
+	tmrTail = &tsdPtr->relTimerTail;
+	/* 
+	 * We should have the ability to ajust end-time of relative events,
+	 * for possible time-jumps.
+	 */
+	if (tsdPtr->relTimerList) {
+	    /* 
+	     * end-time = now + usec
+	     * Adjust value of usec relative current base (to now), so
+	     * end-time = base + relative event-time, which corresponds 
+	     * original end-time.
+	     */
+	    Tcl_WideInt diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch);
+	    if (diff != 0) { /* jump recognized */
+		tsdPtr->relTimerBase += diff; /* shift the base of relative events*/
+    	    }
+	    usec += now - tsdPtr->relTimerBase;
+	} else {
+	    tsdPtr->knownTime = tsdPtr->relTimerBase = now;
+	    tsdPtr->knownTimeJumpEpoch = TclpGetLastTimeJumpEpoch();
+	}
     }
 
     timerPtr->time = usec;
@@ -626,7 +644,7 @@ TclDeleteTimerEntry(
 	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
 	if (entryPtr->flags & TCL_ABSTMR_EVENT) {
 	    TclSpliceOutEx(entryPtr, tsdPtr->absTimerList, tsdPtr->absTimerTail);
-	} else e
+	} else {
 	    TclSpliceOutEx(entryPtr, tsdPtr->relTimerList, tsdPtr->relTimerTail);
 	}
     }
@@ -645,37 +663,51 @@ TclDeleteTimerEntry(
 }
 
 static Tcl_WideInt
-TimerGetFirstTimeOffs(
+TimerGetFirstTime(
     ThreadSpecificData *tsdPtr,
+    TimerEntry *relTimerList,
+    TimerEntry *absTimerList,
+    Tcl_WideInt now,
     TimerEntry **entryPtr)
 {
     Tcl_WideInt firstTime = -0x7FFFFFFFFFFFFFFFL;
-    Tcl_WideInt now = TclpGetMicroseconds();
 
-    /* consider time-jump back */
-    if (tsdPtr->relTimerList) {
-	if (now < tsdPtr->relTimerBase) { /* switched back */
+    /* 
+     * Consider time-jump back - if time jumped forwards, nothing to be done,
+     * because event will be executed early as specified. But for backwards
+     * jumps we should adjust relative base to avoid too long waiting for
+     * relative events.
+     */
+    if (relTimerList) {
+	Tcl_WideInt diff;
+	if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
+	  || (diff = (now - tsdPtr->knownTime)) < 0 /* switched back */
+	) {
 	    /* 
-	     * Because the real jump is unknown (resp. too complex to retrieve
+	     * If the real jump is unknown (resp. too complex to retrieve
 	     * accross all threads), we simply accept possible small increment
 	     * of the real wait-time.
 	     */
-	    tsdPtr->relTimerBase = now; /* just shift the base back */
+	    tsdPtr->relTimerBase += diff; /* shift the base */
 	}
+	tsdPtr->knownTime = now;
+	/* end-time = base + relative event-time */
 	firstTime = tsdPtr->relTimerBase
-	    + TimerEntry2TimerHandler(tsdPtr->absTimerList)->time;
-        if (entryPtr) { *entryPtr = tsdPtr->relTimerBase; }
+	    + TimerEntry2TimerHandler(relTimerList)->time;
+	if (entryPtr) { *entryPtr = relTimerList; }
     }
 
-    if ( tsdPtr->absTimerList
-      && firstTime < TimerEntry2TimerHandler(tsdPtr->absTimerList)->time
+    if ( absTimerList
+      && firstTime < TimerEntry2TimerHandler(absTimerList)->time
     ) {
-	firstTime = TimerEntry2TimerHandler(tsdPtr->absTimerList)->time;
-        if (entryPtr) { *entryPtr = tsdPtr->absTimerList; }
+	/* end-time = absolute event-time */
+	firstTime = TimerEntry2TimerHandler(absTimerList)->time;
+	if (entryPtr) { *entryPtr = absTimerList; }
     }
 
-    return firstTime - now;
+    return firstTime;
 }
+
 /*
  *----------------------------------------------------------------------
  *
@@ -723,7 +755,9 @@ TimerSetupProc(
 	 * Compute the timeout for the next timer on the list.
 	 */
 
-	Tcl_WideInt timeOffs = TimerGetFirstTimeOffs(tsdPtr, NULL);
+	Tcl_WideInt now = TclpGetMicroseconds();
+	Tcl_WideInt timeOffs = TimerGetFirstTime(tsdPtr, 
+		tsdPtr->relTimerList, tsdPtr->absTimerList, now, NULL) - now;
 
 	if (timeOffs > 0) {
 	    blockTime.sec = (long) (timeOffs / 1000000);
@@ -776,7 +810,7 @@ TimerCheckProc(
     ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_WideInt timeOffs;
+    Tcl_WideInt now, timeOffs;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
     long tolerance = 0;
 
@@ -794,8 +828,10 @@ TimerCheckProc(
     /*
      * Verify the first timer on the queue.
      */
-    timeOffs = TimerGetFirstTimeOffs(tsdPtr, NULL);
-
+    now = TclpGetMicroseconds();
+    timeOffs = TimerGetFirstTime(tsdPtr,
+    	tsdPtr->relTimerList, tsdPtr->absTimerList, now, NULL) - now;
+    
 #ifdef TMR_RES_TOLERANCE
     /* consider timer resolution tolerance (avoid busy wait) */
     tolerance = ((timeOffs <= 1000000) ? timeOffs : 1000000) *
@@ -836,8 +872,8 @@ TimerCheckProc(
 int
 TclServiceTimerEvents(void)
 {
-    TimerEntry *entryPtr, *nextPtr;
-    Tcl_Time time, entrytm;
+    TimerEntry *entryPtr, *relTimerList, *absTimerList;
+    Tcl_WideInt now, entryTime;
     size_t currentGeneration, currentEpoch;
     int prevTmrPending;
     ThreadSpecificData *tsdPtr = InitTimer();
@@ -900,30 +936,28 @@ TclServiceTimerEvents(void)
     	return -1;
     }
 
-    /* Hereafter all timer events with time before now */
-    if (!tsdPtr->absTimerList) {
-    	goto done;
-    }
-    Tcl_GetTime(&time);
-    for (entryPtr = tsdPtr->absTimerList;
-	 entryPtr != NULLe
-	 entryPtr = nextPtr
-    ) {
-    	nextPtr = entryPtr->nextPtr;
+    /* Hereafter all relative and absolute timer events with time before now */
+    relTimerList = tsdPtr->relTimerList;
+    absTimerList = tsdPtr->absTimerList;
+    while (relTimerList || absTimerList)
+    {
+	now = TclpGetMicroseconds();
+	entryTime = TimerGetFirstTime(tsdPtr, relTimerList, absTimerList, now, &entryPtr);
 
-	entrytm = TimerEntry2TimerHandler(entryPtr)->time;
     #ifdef TMR_RES_TOLERANCE
-	entrytm.usec -= ((entrytm.sec <= 0) ? entrytm.usec : 1000000) *
-				(TMR_RES_TOLERANCE / 100);
-	if (entrytm.usec < 0) {
-	    entrytm.usec += 1000000;
-	    entrytm.sec--;
-	}
+	entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
+				TMR_RES_TOLERANCE / 100;
     #endif
-	if (TCL_TIME_BEFORE(time, entrytm)) {
+	if (now < entryTime) {
 	    break;
 	}
 
+	/* Current list head to next entry */
+	if (entryPtr == relTimerList) {
+	    relTimerList = relTimerList->nextPtr;
+	} else {
+	    absTimerList = absTimerList->nextPtr;
+	}
 	/*
 	 * Bypass timers of newer generation.
 	 */
@@ -935,16 +969,19 @@ TclServiceTimerEvents(void)
 	}
 
 	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
+	currentEpoch = tsdPtr->timerListEpoch;
 	 
 	/*
 	 * Remove the handler from the queue before invoking it, to avoid
 	 * potential reentrancy problems.
 	 */
-
-	TclSpliceOutEx(entryPtr, 
-	    tsdPtr->absTimerLise, tsdPtr->absTimerTail);
-
-	currentEpoch = tsdPtr->timerListEpoch;
+	if (!(entryPtr->flags & TCL_ABSTMR_EVENT)) {
+	    TclSpliceOutEx(entryPtr, 
+		tsdPtr->relTimerList, tsdPtr->relTimerTail);
+	} else {
+	    TclSpliceOutEx(entryPtr, 
+		tsdPtr->absTimerList, tsdPtr->absTimerTail);
+	}
 
 	/* reset current timer pending (correct process nested wait event) */
 	prevTmrPending = tsdPtr->timerPending;
@@ -969,17 +1006,15 @@ TclServiceTimerEvents(void)
 	}
     }
 
-done:
     /* pending timer events, so mark (queue) timer events  */
     if (tsdPtr->timerPending > 1) {
     	tsdPtr->timerPending = 1;
-
     	return -1;
     }
 
     /* Reset generation if both timer queue are empty */
-    if (!tsdPtr->absTimerList) {
-	tsdPtr->timerGeneratioe = 0;
+    if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
+	tsdPtr->timerGeneration = 0;
     }
 
     /* Compute the next timeout (later via TimerSetupProc using the first timer). */
@@ -1239,7 +1274,7 @@ TclServiceIdle(void)
 int
 TclpGetUTimeFromObj(
     Tcl_Interp	*interp,	/* Current interpreter or NULL. */
-    Tcl_Obj *CONST objPtr,	/* Object to read numeric time (in milliseconds). */
+    Tcl_Obj	*objPtr,	/* Object to read numeric time (in milliseconds). */
     Tcl_WideInt	*timePtr)	/* Resulting time if converted (in microseconds). */
 {
     if (objPtr->typePtr != &tclDoubleType) {
@@ -1255,7 +1290,7 @@ TclpGetUTimeFromObj(
     }
     if (1) {
 	double ms;
-	if (Tcl_GetDoubleFromObj(interp, objv[1], &ms) == TCL_OK) {
+	if (Tcl_GetDoubleFromObj(interp, objPtr, &ms) == TCL_OK) {
 	    if (ms < 0x7FFFFFFFFFFFFFFFL / 1000) { /* avoid overflow */
 		/* use precise as possible calculation by double (microseconds) */
 		*timePtr = ((Tcl_WideInt)ms) * 1000 + (((long)(ms*1000)) % 1000);
@@ -1563,16 +1598,16 @@ Tcl_AfterObjCmd(
 static int
 AfterDelay(
     Tcl_Interp *interp,
-    double ms,
+    Tcl_WideInt usec,
     int absolute)
 {
     Interp *iPtr = (Interp *) interp;
 
-    Tcl_Time endTime, now, lastNow;
-    Tcl_WideInt diff;
+    Tcl_WideInt endTime, now, lastNow, diff;
     long tolerance = 0;
+    size_t timeJumpEpoch = 0;
 
-    if (ms <= 0) {
+    if (usec <= 0) {
 	/* to cause a context switch only */
 	Tcl_Sleep(0);
 	return TCL_OK;
@@ -1580,44 +1615,42 @@ AfterDelay(
 
     /* calculate possible maximal tolerance (in usec) of original wait-time */
 #ifdef TMR_RES_TOLERANCE
-    tolerance = ((ms < 1000) ? ms : 1000) * (1000 * TMR_RES_TOLERANCE / 100);
+    tolerance = ((usec < 1000000) ? usec : 1000000) * TMR_RES_TOLERANCE / 100;
 #endif
 
-    Tcl_GetTime(&now);
-    lastNow = endTime = now;
-    if (absolute)
-    TclTimeAddMilliseconds(&endTime, ms);
+    lastNow = now = TclpGetMicroseconds();
+    endTime = usec;
+    timeJumpEpoch = TclpGetLastTimeJumpEpoch();
+
+    if (!absolute) {
+	endTime += now;
+	if (endTime < now) { /* overflow */
+	    endTime = 0x7FFFFFFFFFFFFFFFL;
+	}
+    }
 
     do {
-	if (iPtr->limit.timeEvent != NULL
-	    && TCL_TIME_BEFORE(iPtr->limit.time, now)) {
+	if ( iPtr->limit.timeEvent != NULL
+	  && now > TCL_TIME_TO_USEC(iPtr->limit.time)
+	) {
 	    iPtr->limit.granularityTicker = 0;
 	    if (Tcl_LimitCheck(interp) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	}
-	if (iPtr->limit.timeEvent == NULL
-	    || TCL_TIME_BEFORE(endTime, iPtr->limit.time)) {
-	    diff = TCL_TIME_DIFF_MS(endTime, now);
-#ifndef TCL_WIDE_INT_IS_LONG
-	    if (diff > LONG_MAX) {
-		diff = LONG_MAX;
-	    }
-#endif
+	if ( iPtr->limit.timeEvent == NULL
+	  || endTime < (diff = TCL_TIME_TO_USEC(iPtr->limit.time))
+	) {
+	    diff = endTime - now;
 	    if (diff > 0) {
-		Tcl_Sleep((long)diff);
-		Tcl_GetTime(&now);
+		TclpUSleep(diff);
+		now = TclpGetMicroseconds();
 	    }
 	} else {
-	    diff = TCL_TIME_DIFF_MS(iPtr->limit.time, now);
-#ifndef TCL_WIDE_INT_IS_LONG
-	    if (diff > LONG_MAX) {
-		diff = LONG_MAX;
-	    }
-#endif
+	    diff -= now;
 	    if (diff > 0) {
-		Tcl_Sleep((long)diff);
-		Tcl_GetTime(&now);
+		TclpUSleep(diff);
+		now = TclpGetMicroseconds();
 	    }
 	    if (Tcl_LimitCheck(interp) != TCL_OK) {
 		return TCL_ERROR;
@@ -1626,24 +1659,20 @@ AfterDelay(
 
 	/* 
 	 * Note time can be switched backwards, certainly adjust end-time
-	 * by possible time-jumps back.
+	 * by possible time-jumps (for relative sleep).
 	 */
-	if (!absolute && TCL_TIME_BEFORE(now, lastNow)) {
-	    /* backwards time-jump - simply shift wakeup-time */
-	    endTime.sec -= (lastNow.sec - now.sec);
-	    endTime.usec -= (lastNow.usec - now.usec);
-	    if (endTime.usec < 0) {
-	        endTime.usec += 1000000;
-	        endTime.sec--;
-	    }
+	if (!absolute
+	  && ( (diff = TclpGetLastTimeJump(&timeJumpEpoch)) != 0 
+	    || (diff = (now - lastNow)) < 0
+	  )
+	) {
+	    /* recognized time-jump - simply shift wakeup-time */
+	    endTime += diff;
 	}
 	lastNow = now;
 
 	/* consider timer resolution tolerance (avoid busy wait) */
-    } while (
-	(now.sec > endTime.sec)
-     || (now.sec == endTime.sec && now.usec >= endTime.usec - tolerance)
-    );
+    } while (now < endTime);
     return TCL_OK;
 }
 
diff --git a/unix/tclUnixTime.c b/unix/tclUnixTime.c
index 1b4ea15..7f22fab 100644
--- a/unix/tclUnixTime.c
+++ b/unix/tclUnixTime.c
@@ -632,6 +632,34 @@ NativeScaleTime(
 /*
  *----------------------------------------------------------------------
  *
+ * TclpScaleUTime --
+ *
+ *	This procedure scales number of microseconds if expected.
+ *
+ * Results:
+ *	Number of microseconds scaled using tclScaleTimeProcPtr.
+ *
+ *----------------------------------------------------------------------
+ */
+Tcl_WideInt
+TclpScaleUTime(
+    Tcl_WideInt usec)
+{
+    /* Native scale is 1:1. */
+    if (tclScaleTimeProcPtr != NativeScaleTime) {
+	return usec;
+    } else {
+	Tcl_Time scTime;
+	scTime.sec = usec / 1000000;
+	scTime.usec = usec % 1000000;
+	tclScaleTimeProcPtr(&scTime, tclTimeClientData);
+	return ((Tcl_WideInt)scTime.sec) * 1000000 + scTime.usec;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * NativeGetTime --
  *
  *	TIP #233: Gets the current system time in seconds and microseconds
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index d22373e..bd3b384 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -631,12 +631,13 @@ Tcl_WaitForEvent(
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     MSG msg;
-    DWORD timeout, result = WAIT_TIMEOUT;
+    DWORD timeout = INFINITE, result = WAIT_TIMEOUT;
     int status = 0;
-    Tcl_Time waitTime = {0, 0};
-    Tcl_Time lastNow, endTime;
+    Tcl_WideInt waitTime = 0;
+    Tcl_WideInt lastNow = 0, endTime = 0;
     long tolerance = 0;
     unsigned long actualResolution = 0;
+    size_t timeJumpEpoch = 0;
 
     /*
      * Allow the notifier to be hooked. This may not make sense on windows,
@@ -653,47 +654,44 @@ Tcl_WaitForEvent(
 
     if (timePtr) {
 
-	waitTime.sec  = timePtr->sec;
-	waitTime.usec = timePtr->usec;
+	waitTime = timePtr->sec * 1000000 + timePtr->usec;
 
 	/* if no wait */
-	if (waitTime.sec <= 0 && waitTime.usec <= 0) {
+	if (waitTime <= 0) {
 	    result = 0;
 	    goto peek;
 	}
 
-    #ifdef TMR_RES_TOLERANCE
-	/* calculate possible maximal tolerance (in usec) of original wait-time */
-	tolerance = ((waitTime.sec <= 0) ? waitTime.usec : 1000000) *
-			(TMR_RES_TOLERANCE / 100);
-    #endif
-
 	/* calculate end of wait */
-	Tcl_GetTime(&endTime);
-	lastNow = endTime;
-	endTime.sec += waitTime.sec;
-	endTime.usec += waitTime.usec;
-	if (endTime.usec > 1000000) {
-		endTime.usec -= 1000000;
-		endTime.sec++;
-	}
+	lastNow = TclpGetMicroseconds();
+	endTime = lastNow + waitTime;
+	timeJumpEpoch = TclpGetLastTimeJumpEpoch();
 
 	if (timerResolution.available == -1) {
 	    InitTimerResolution();
 	}
 	
+    #ifdef TMR_RES_TOLERANCE
+	/* calculate possible maximal tolerance (in usec) of original wait-time */
+	tolerance = ((waitTime <= 1000000) ? waitTime : 1000000) *
+			TMR_RES_TOLERANCE / 100;
+	if (tolerance > timerResolution.maxDelay) {
+	    tolerance = timerResolution.maxDelay;
+	}
+    #endif
+
     repeat:
 	/*
 	* TIP #233 (Virtualized Time). Convert virtual domain delay to
 	* real-time.
 	*/
-	(*tclScaleTimeProcPtr) (&waitTime, tclTimeClientData);
+	waitTime = TclpScaleUTime(waitTime);
 
 	/* No wait if timeout too small (because windows may wait too long) */
-	if (!waitTime.sec && waitTime.usec < (long)timerResolution.minDelay) {
+	if (waitTime < (long)timerResolution.minDelay) {
+	    timeout = 0;
 	    /* prevent busy wait */
-	    if (waitTime.usec >= 10) {
-	    	timeout = 0;
+	    if (waitTime >= 10) {
 		goto wait;
 	    }
 	    Sleep(0);
@@ -701,25 +699,23 @@ Tcl_WaitForEvent(
 	}
 	
 	if (timerResolution.available) {
-	    if (waitTime.sec || waitTime.usec + tolerance > timerResolution.maxDelay) {
-		long usec;
-		timeout = waitTime.sec * 1000;
-		usec = (timeout * 1000) + waitTime.usec + tolerance;
-		if (usec > 1000000) {
-		    usec -= 1000000;
-		    timeout += 1000;
-		}
-		timeout += (usec - (usec % timerResolution.maxDelay)) / 1000;
+	    long overhead = (tolerance < 100 ? tolerance/2 : 50);
+	    Tcl_WideInt waitTimeWithOverhead = waitTime + overhead;
+	    if (waitTimeWithOverhead > timerResolution.maxDelay) {
+		/* floor (truncate) using max delay as base (follow timeout better) */
+		timeout = (waitTimeWithOverhead
+				/ timerResolution.maxDelay)
+				* timerResolution.maxDelay / 1000;
 	    } else {
 		/* calculate resolution up to 1000 microseconds
 		 * (don't use highest, because of too large CPU load) */
 		ULONG res;
-		if (waitTime.usec >= 10000) {
+		if (waitTimeWithOverhead >= 10000) {
 		    res = 10000 * TMR_RES_MICROSEC;
 		} else {
 		    res = 1000 * TMR_RES_MICROSEC;
 		}
-		timeout = waitTime.usec / 1000;
+		timeout = waitTimeWithOverhead / 1000;
 		/* set more precise timer resolution for minimal delay */
 		if (!actualResolution || res < timerResolution.curRes) {
 		    actualResolution = SetTimerResolution(
@@ -727,11 +723,8 @@ Tcl_WaitForEvent(
 		}
 	    }
 	} else {
-	    timeout = waitTime.sec * 1000 + waitTime.usec / 1000;
+	    timeout = waitTime / 1000;
 	}
-
-    } else {
-	timeout = INFINITE;
     }
 
     /*
@@ -796,31 +789,28 @@ Tcl_WaitForEvent(
     else
     if (result == WAIT_TIMEOUT && timeout != INFINITE) {
 	/* Check the wait should be repeated, and correct time for wait */
-	Tcl_Time now;
+	Tcl_WideInt now;
 
-	Tcl_GetTime(&now);
+	now = TclpGetMicroseconds();
 	/* 
 	 * Note time can be switched backwards, certainly adjust end-time
-	 * by possible time-jumps back.
+	 * by possible time-jumps.
 	 */
-	if (TCL_TIME_BEFORE(now, lastNow)) {
-	    /* backwards time-jump - simply shift wakeup-time */
-	    endTime.sec -= (lastNow.sec - now.sec);
-	    endTime.usec -= (lastNow.usec - now.usec);
-	    if (endTime.usec < 0) {
-	        endTime.usec += 1000000;
-	        endTime.sec--;
-	    }
+	if ((waitTime = TclpGetLastTimeJump(&timeJumpEpoch)) != 0) {
+	    /* we know time-jump, adjust end-time using this offset */
+	    endTime += waitTime;
+	}
+	else
+	if ((waitTime = (now - lastNow)) < 0) {
+	    /* recognized backwards time-jump - simply shift wakeup-time *
+	     * considering timeout also, assume we've reached it completely */
+	    endTime += (waitTime - (timeout * 1000));
 	}
 	lastNow = now;
 
 	/* calculate new waitTime */
-	waitTime.sec = (endTime.sec - now.sec);
-	if ((waitTime.usec = (endTime.usec - now.usec)) < 0) {
-	    waitTime.usec += 1000000;
-	    waitTime.sec--;
-	}
-	if (waitTime.sec < 0 || !waitTime.sec && waitTime.usec <= tolerance) {
+	waitTime = endTime - now;
+	if (waitTime <= tolerance) {
 	    goto end;
 	}
 	/* Repeat wait with more precise timer resolution (or using sleep) */
@@ -841,9 +831,11 @@ Tcl_WaitForEvent(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_Sleep --
+ * Tcl_Sleep --, TclpUSleep --
  *
- *	Delay execution for the specified number of milliseconds.
+ *	Delay execution for the specified number of milliseconds (or microsec.).
+ *
+ *	TclpUSleep in contrast to Tcl_Sleep is more precise (microseconds).
  *
  * Results:
  *	None.
@@ -858,6 +850,13 @@ void
 Tcl_Sleep(
     int ms)			/* Number of milliseconds to sleep. */
 {
+    TclpUSleep((Tcl_WideInt)ms * 1000);
+}
+
+void
+TclpUSleep(
+    Tcl_WideInt usec)		/* Number of microseconds to sleep. */
+{
     /*
      * Simply calling 'Sleep' for the requisite number of milliseconds can
      * make the process appear to wake up early because it isn't synchronized
@@ -868,72 +867,67 @@ Tcl_Sleep(
      * requisite amount.
      */
 
-    Tcl_Time lastNow, now;	/* Current wall clock time. */
-    Tcl_Time desired;		/* Desired wakeup time. */
-    Tcl_Time vdelay;		/* Time to sleep, for scaling virtual ->
-				 * real. */
+    Tcl_WideInt lastNow, now;	/* Current wall clock time. */
+    Tcl_WideInt desired;	/* Desired wakeup time. */
     DWORD sleepTime;		/* Time to sleep, real-time */
     long tolerance = 0;
     unsigned long actualResolution = 0;
+    size_t timeJumpEpoch = 0;
 
-    if (ms <= 0) {
-    	/* causes context switch only */
-    	Sleep(0);
-    	return;
+    if (usec <= 9) { /* too short to start whole sleep process */
+	do {
+	    /* causes context switch only (shortest waiting) */
+	    Sleep(0);
+	} while (--usec > 0);
+	return;
     }
 
     if (timerResolution.available == -1) {
 	InitTimerResolution();
     }
 
-    vdelay.sec  = ms / 1000;
-    vdelay.usec = (ms % 1000) * 1000;
-
-    Tcl_GetTime(&now);
-    lastNow = now;
-    desired.sec  = now.sec  + vdelay.sec;
-    desired.usec = now.usec + vdelay.usec;
-    if (desired.usec > 1000000) {
-	desired.usec -= 1000000;
-	desired.sec++;
-    }
+    lastNow = now = TclpGetMicroseconds();
+    desired = now + usec;
+    timeJumpEpoch = TclpGetLastTimeJumpEpoch();
 
   #ifdef TMR_RES_TOLERANCE
     /* calculate possible maximal tolerance (in usec) of original wait-time */
-    tolerance = ((vdelay.sec <= 0) ? vdelay.usec : 1000000) *
-			(TMR_RES_TOLERANCE / 100);
+    tolerance = ((usec <= 1000000) ? usec : 1000000) *
+			TMR_RES_TOLERANCE / 100;
+    if (tolerance > timerResolution.maxDelay) {
+	tolerance = timerResolution.maxDelay;
+    }
   #endif
 
-    /*
-     * TIP #233: Scale delay from virtual to real-time.
-     */
-
     for (;;) {
 	
-	tclScaleTimeProcPtr(&vdelay, tclTimeClientData);
+	/*
+	 * TIP #233: Scale delay from virtual to real-time.
+	 */
+	usec = TclpScaleUTime(usec);
 
 	/* No wait if sleep time too small (because windows may wait too long) */
-	if (!vdelay.sec && vdelay.usec < (long)timerResolution.minDelay) {
+	if (usec < (long)timerResolution.minDelay) {
 	    sleepTime = 0;
 	    goto wait;
 	}
 
 	if (timerResolution.available) {
-	    if (vdelay.sec || vdelay.usec > timerResolution.maxDelay) {
-	    	long usec;
-	    	sleepTime = vdelay.sec * 1000;
-		usec = ((sleepTime * 1000) + vdelay.usec) % 1000000;
-		sleepTime += (usec - (usec % timerResolution.maxDelay)) / 1000;
+	    if (usec > timerResolution.maxDelay) {
+		/* floor (truncate) using max delay as base (follow timeout better) */
+		sleepTime = (usec
+				/ timerResolution.maxDelay)
+				* timerResolution.maxDelay / 1000;
 	    } else {
 	    	/* calculate resolution up to 1000 microseconds
 	    	 * (don't use highest, because of too large CPU load) */
 		ULONG res;
-		if (vdelay.usec >= 10000) {
+		if (usec >= 10000) {
 		    res = 10000 * TMR_RES_MICROSEC;
 		} else {
 		    res = 1000 * TMR_RES_MICROSEC;
 		}
-		sleepTime = vdelay.usec / 1000;
+		sleepTime = usec / 1000;
 		/* set more precise timer resolution for minimal delay */
 		if (!actualResolution || res < timerResolution.curRes) {
 		    actualResolution = SetTimerResolution(
@@ -941,37 +935,29 @@ Tcl_Sleep(
 		}
 	    }
 	} else {
-	    sleepTime = vdelay.sec * 1000 + vdelay.usec / 1000;
+	    sleepTime = usec / 1000;
 	}
 
     wait:
 	Sleep(sleepTime);
-	Tcl_GetTime(&now);
+	now = TclpGetMicroseconds();
 	/* 
 	 * Note time can be switched backwards, certainly adjust end-time
-	 * by possible time-jumps back.
+	 * by possible time-jumps.
 	 */
-	if (TCL_TIME_BEFORE(now, lastNow)) {
-	    /* backwards time-jump - simply shift wakeup-time */
-	    desired.sec -= (lastNow.sec - now.sec);
-	    desired.usec -= (lastNow.usec - now.usec);
-	    if (desired.usec < 0) {
-	        desired.usec += 1000000;
-	        desired.sec--;
-	    }
+	if ((usec = TclpGetLastTimeJump(&timeJumpEpoch)) != 0) {
+	    /* we know time-jump, adjust end-time using this offset */
+	    desired += usec;
 	}
-	lastNow = now;
-
-	vdelay.sec  = desired.sec  - now.sec;
-	vdelay.usec = desired.usec - now.usec;
-	if (vdelay.usec < 0) {
-	    vdelay.usec += 1000000;
-	    vdelay.sec--;
+	else
+	if ((usec = (now - lastNow)) < 0) {
+	    /* recognized backwards time-jump - simply shift wakeup-time *
+	     * considering sleep-time also, assume we've reached it completely */
+	    desired += (usec - (sleepTime * 1000));
 	}
+	lastNow = now;
 
-	if (vdelay.sec < 0) {
-	    break;
-	} else if ((vdelay.sec == 0) && (vdelay.usec <= tolerance)) {
+	if ((usec = (desired - now)) <= tolerance) {
 	    break;
 	}
     }
diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index 3a2ba8d..4835bf1 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -45,15 +45,15 @@ typedef struct TimeCalibInfo {
     LONGLONG perfCounter;	/* QPC value of last calibrated virtual time */
     Tcl_WideInt virtTimeBase;	/* Last virtual time base (in 100-ns) */
     Tcl_WideInt sysTime;	/* Last real system time (in 100-ns),
-    				   truncated to VT_SYSTMR_DIST (100ms) */
+				   truncated to VT_SYSTMR_DIST (100ms) */
 } TimeCalibInfo;
 
 /* Milliseconds <-> 100-ns ticks */
-#define MsToT100ns(ms)   (ms * 10000)
-#define T100nsToMs(ms)   (ms / 10000)
+#define MsToT100ns(ms)   ((ms) * 10000)
+#define T100nsToMs(ms)   ((ms) / 10000)
 /* Microseconds <-> 100-ns ticks */
-#define UsToT100ns(ms)   (ms * 10)
-#define T100nsToUs(ms)   (ms / 10)
+#define UsToT100ns(ms)   ((ms) * 10)
+#define T100nsToUs(ms)   ((ms) / 10)
 
 
 /*
@@ -103,7 +103,8 @@ typedef struct TimeInfo {
     
     size_t lastUsedTime;	/* Last known (caller) offset to virtual time
 				 * (used to avoid back-drifts after calibrate) */
-
+    size_t lastTimeJumpEpoch;	/* Last known epoch since last time-jump. */
+    Tcl_WideInt lastTimeJump;	/* Last known time-jump of thread. */
 } TimeInfo;
 
 static TimeInfo timeInfo = {
@@ -415,7 +416,7 @@ TclpWideClickInMicrosec(void)
 Tcl_WideInt 
 TclpGetMicroseconds(void)
 {
-#if 0
+#if 1
     /* Use high resolution timer if possible */
     if (tclGetTimeProcPtr == NativeGetTime) {
     	return NativeGetMicroseconds();
@@ -428,7 +429,7 @@ TclpGetMicroseconds(void)
 	Tcl_Time now;
 
 	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
-	return (((Tcl_WideInt)now.sec) * 1000000) + now.usec;
+	return TCL_TIME_TO_USEC(now);
     }
 
 #else
@@ -563,6 +564,34 @@ NativeScaleTime(
 /*
  *----------------------------------------------------------------------
  *
+ * TclpScaleUTime --
+ *
+ *	This procedure scales number of microseconds if expected.
+ *
+ * Results:
+ *	Number of microseconds scaled using tclScaleTimeProcPtr.
+ *
+ *----------------------------------------------------------------------
+ */
+Tcl_WideInt
+TclpScaleUTime(
+    Tcl_WideInt usec)
+{
+    /* Native scale is 1:1. */
+    if (tclScaleTimeProcPtr == NativeScaleTime) {
+	return usec;
+    } else {
+	Tcl_Time scTime;
+	scTime.sec = usec / 1000000;
+	scTime.usec = usec % 1000000;
+	tclScaleTimeProcPtr(&scTime, tclTimeClientData);
+	return ((Tcl_WideInt)scTime.sec) * 1000000 + scTime.usec;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * NativeGetMicroseconds --
  *
  *	Gets the current system time in microseconds since the beginning
@@ -719,7 +748,7 @@ NativeGetMicroseconds(void)
 		timeInfo.lastCI.sysTime =
 		    timeInfo.lastCI.virtTimeBase = GetSystemTimeAsVirtual();
 
-
+		timeInfo.lastTimeJumpEpoch = 1; /* let the caller know we've epoch */
 	    }
 	    timeInfo.initialized = TRUE;
 	}
@@ -826,6 +855,8 @@ NativeGetMicroseconds(void)
 		 * The time-jump (reset or initial), we should use system time
 		 * instead of virtual to recalibrate offsets (let the time jump).
 		 */
+		timeInfo.lastTimeJump = T100nsToUs(sysTime - vt0); /* 100-ns */;
+		timeInfo.lastTimeJumpEpoch++;
 		vt0 = sysTime;
 //!!!		printf("************* reset time: %I64d *****************\n", vt0);
 	    }
@@ -1342,6 +1373,21 @@ Tcl_QueryTimeProc(
     }
 }
 
+Tcl_WideInt
+TclpGetLastTimeJump(size_t *epoch)
+{
+    if (timeInfo.lastTimeJumpEpoch > *epoch) {
+    	*epoch = timeInfo.lastTimeJumpEpoch;
+	return timeInfo.lastTimeJump;
+    };
+    return 0;
+}
+size_t
+TclpGetLastTimeJumpEpoch(void)
+{
+    return timeInfo.lastTimeJumpEpoch;
+}
+
 /*
  * Local Variables:
  * mode: c
-- 
cgit v0.12


From 96076219018ba504254a342c4490fc787bb0ceae Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:29:58 +0000
Subject: don't use tolerance in vwait, because of dual usage, it causes
 canceling of wait before end-time, on small timeout values (like 0.5, etc.)

---
 generic/tclEvent.c | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 9a20cc2..b5e73ea 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1386,7 +1386,6 @@ Tcl_VwaitObjCmd(
     int optc = objc - 2; /* options count without cmd and varname */
     Tcl_WideInt usec = -1;
     Tcl_WideInt lastNow = 0, wakeup = 0;
-    long tolerance = 0;
     size_t timeJumpEpoch = 0;
 
     if (objc < 2) {
@@ -1420,11 +1419,6 @@ Tcl_VwaitObjCmd(
 	if (usec > 0) {
 	    lastNow = TclpGetMicroseconds();
 	    timeJumpEpoch = TclpGetLastTimeJumpEpoch();
-	#ifdef TMR_RES_TOLERANCE
-	    tolerance = (usec < 1000000 ? usec : 1000000) *
-				TMR_RES_TOLERANCE / 100;
-	    usec += tolerance / 3;
-	#endif
 	    wakeup = lastNow + usec;
 	} else {
 	    flags |= TCL_DONT_WAIT;
@@ -1457,9 +1451,9 @@ Tcl_VwaitObjCmd(
 	    /* calculate blocking time */
 	    lastNow = now;
 	    diff = wakeup - now;
-	    diff -= 1; /* overhead for Tcl_TraceVar / Tcl_UntraceVar */
+	    diff -= 1; /* overhead for this code (e. g. Tcl_TraceVar/Tcl_UntraceVar) */
 	    /* be sure process at least one event */
-	    if (diff <= tolerance) {
+	    if (diff <= 0) {
 		/* timeout occurs */
 		if (checktime) {
 		    done = -1;
-- 
cgit v0.12


From 345817796217f5d895ed8bbd46a95bbbea799404 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:30:05 +0000
Subject: amend with review

---
 generic/tclTimer.c | 69 +++++++++++++++++++++++++++++++++++++++++-------------
 tests/event.test   |  6 ++---
 2 files changed, 56 insertions(+), 19 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index aad8ee3..a97c73a 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -285,6 +285,9 @@ TimerExitProc(
 	while ((tsdPtr->promptTail) != NULL) {
 	    TclDeleteTimerEntry(tsdPtr->promptTail);
 	}
+	while ((tsdPtr->relTimerTail) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->relTimerTail);
+	}
 	while ((tsdPtr->absTimerTail) != NULL) {
 	    TclDeleteTimerEntry(tsdPtr->absTimerTail);
 	}
@@ -334,7 +337,7 @@ Tcl_CreateTimerHandler(
 
     entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, 0);
     if (entryPtr == NULL) {
-    	return NULL;
+	return NULL;
     }
     entryPtr->clientData = clientData;
 
@@ -412,15 +415,19 @@ TclpCreateTimerHandlerEx(
 	     * end-time = base + relative event-time, which corresponds 
 	     * original end-time.
 	     */
-	    Tcl_WideInt diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch);
-	    if (diff != 0) { /* jump recognized */
-		tsdPtr->relTimerBase += diff; /* shift the base of relative events*/
+	    Tcl_WideInt diff;
+	    if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
+	      || (diff = (tsdPtr->knownTime - now)) < 0
+	    ) { /* jump recognized */
+		tsdPtr->relTimerBase += diff; /* shift the base of relative events */
     	    }
 	    usec += now - tsdPtr->relTimerBase;
 	} else {
-	    tsdPtr->knownTime = tsdPtr->relTimerBase = now;
+	    /* first event here - initial values (base/epoch) */
+	    tsdPtr->relTimerBase = now;
 	    tsdPtr->knownTimeJumpEpoch = TclpGetLastTimeJumpEpoch();
 	}
+	tsdPtr->knownTime = now;
     }
 
     timerPtr->time = usec;
@@ -504,7 +511,7 @@ TclCreateAbsoluteTimerHandler(
 
     entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, TCL_ABSTMR_EVENT);
     if (entryPtr == NULL) {
-    	return NULL;
+	return NULL;
     }
     entryPtr->clientData = clientData;
 
@@ -550,7 +557,7 @@ TclCreateRelativeTimerHandler(
 
     entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, TCL_ABSTMR_EVENT);
     if (entryPtr == NULL) {
-    	return NULL;
+	return NULL;
     }
     entryPtr->clientData = clientData;
 
@@ -587,6 +594,18 @@ Tcl_DeleteTimerHandler(
 	return;
     }
 
+    for (entryPtr = tsdPtr->relTimerTail;
+	entryPtr != NULL;
+	entryPtr = entryPtr->prevPtr
+    ) {
+	if (TimerEntry2TimerHandler(entryPtr)->token != token) {
+	    continue;
+	}
+
+	TclDeleteTimerEntry(entryPtr);
+	return;
+    }
+
     for (entryPtr = tsdPtr->absTimerTail;
 	entryPtr != NULL;
 	entryPtr = entryPtr->prevPtr
@@ -622,8 +641,7 @@ Tcl_DeleteTimerHandler(
 void
 TclDeleteTimerEntry(
     TimerEntry *entryPtr)	/* Result previously returned by */
-	/* TclCreateRelativeTimerHandlerEx, TclCreateAbsoluteTimerHandlerEx
-	 * or TclCreateTimerEntryEx. */
+	/* TclCreateTimerHandlerEx or TclCreateTimerEntryEx. */
 {
     ThreadSpecificData *tsdPtr;
 
@@ -642,10 +660,10 @@ TclDeleteTimerEntry(
     } else {
 	/* timer event-handler */
 	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
-	if (entryPtr->flags & TCL_ABSTMR_EVENT) {
-	    TclSpliceOutEx(entryPtr, tsdPtr->absTimerList, tsdPtr->absTimerTail);
-	} else {
+	if (!(entryPtr->flags & TCL_ABSTMR_EVENT)) {
 	    TclSpliceOutEx(entryPtr, tsdPtr->relTimerList, tsdPtr->relTimerTail);
+	} else {
+	    TclSpliceOutEx(entryPtr, tsdPtr->absTimerList, tsdPtr->absTimerTail);
 	}
     }
 
@@ -662,6 +680,24 @@ TclDeleteTimerEntry(
     }
 }
 
+/*
+ *--------------------------------------------------------------
+ *
+ * TimerGetFirstTime --
+ *
+ *	Find the execution time of first relative or absolute timer starting
+ *	from given heads.
+ *
+ * Results:
+ *	A wide integer representing the due time (as microseconds) of first
+ *	timer event to execute.
+ *
+ * Side effects:
+ *	If time-jump recognized, may adjust the base for relative timers.
+ *
+ *--------------------------------------------------------------
+ */
+
 static Tcl_WideInt
 TimerGetFirstTime(
     ThreadSpecificData *tsdPtr,
@@ -673,10 +709,11 @@ TimerGetFirstTime(
     Tcl_WideInt firstTime = -0x7FFFFFFFFFFFFFFFL;
 
     /* 
-     * Consider time-jump back - if time jumped forwards, nothing to be done,
-     * because event will be executed early as specified. But for backwards
-     * jumps we should adjust relative base to avoid too long waiting for
-     * relative events.
+     * Consider time-jump (especially back) - if the time jumped forwards (and
+     * it recognized) the base can be shifted, but not badly needed, because
+     * event will be nevertheless executed early as specified. But for backwards
+     * jumps it is very important and we should adjust relative base to avoid 
+     * too long waiting for relative events.
      */
     if (relTimerList) {
 	Tcl_WideInt diff;
diff --git a/tests/event.test b/tests/event.test
index d2dd2fc..f943f23 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -529,9 +529,9 @@ test event-11.4.0 {vwait - interp limit precedence} {} {
     $i limit time -seconds {} -milliseconds {}
     lappend result 2. [catch {$i eval {vwait 0 x}} msg] $msg
 
-    # limit should be exceeded: (wait infinite by -1)
+    # limit should be exceeded: (wait infinite)
     $i limit time -milliseconds 0
-    lappend result 3. [catch {$i eval {vwait -1 x}} msg] $msg
+    lappend result 3. [catch {$i eval {vwait x}} msg] $msg
     # limit should be exceeded (wait too long - 1000ms):
     $i limit time -milliseconds 0
     lappend result 4. [catch {$i eval {vwait 1000 x}} msg] $msg
@@ -597,7 +597,7 @@ test event-11.4.1 {vwait with timeout} {} {
     lappend z $x; # 0 {} - (x still empty)
     vwait 200 x; # wait up-to 200ms
     lappend z $x; # 0 {} {1 2}
-    vwait -1 x; # infinite wait
+    vwait x; # infinite wait
     lappend z $x; # 0 {} {1 2} {1 2 3}
     foreach i [after info] {
 	after cancel $i
-- 
cgit v0.12


From 6b524c87faf668d9cd21daccf2cdc8aa08957bfa Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:30:08 +0000
Subject: revert dual lists (relative/absolute) back to single list (because of
 better handling, a bit faster, etc.)

---
 generic/tclTimer.c | 172 ++++++++++++++++++++---------------------------------
 1 file changed, 63 insertions(+), 109 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index a97c73a..a245a18 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -65,12 +65,10 @@ typedef struct {
     Tcl_WideInt relTimerBase;	/* Time base of the first known relative */
 				/* timer, used to revert all events to the new
 				 * base after possible time-jump (adjustment).*/
-    TimerEntry *relTimerList;	/* First event in queue of relative timers. */
-    TimerEntry *relTimerTail;	/* Last event in queue of relative timers. */
+    TimerEntry *timerList;	/* First event in queue of timers. */
+    TimerEntry *timerTail;	/* Last event in queue of timers. */
     TimerEntry *promptList;	/* First immediate event in queue. */
     TimerEntry *promptTail;	/* Last immediate event in queue. */
-    TimerEntry *absTimerList;	/* First event in queue of absolute timers. */
-    TimerEntry *absTimerTail;	/* Last event in queue of absolute timers. */
     size_t timerListEpoch;	/* Used for safe process of event queue (stop
     				 * the cycle after modifying of event queue) */
     int lastTimerId;		/* Timer identifier of most recently created
@@ -285,11 +283,8 @@ TimerExitProc(
 	while ((tsdPtr->promptTail) != NULL) {
 	    TclDeleteTimerEntry(tsdPtr->promptTail);
 	}
-	while ((tsdPtr->relTimerTail) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->relTimerTail);
-	}
-	while ((tsdPtr->absTimerTail) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->absTimerTail);
+	while ((tsdPtr->timerTail) != NULL) {
+	    TclDeleteTimerEntry(tsdPtr->timerTail);
 	}
 	while ((tsdPtr->idleTail) != NULL) {
 	    TclDeleteTimerEntry(tsdPtr->idleTail);
@@ -372,7 +367,6 @@ TclpCreateTimerHandlerEx(
     int flags)			/* If TCL_ABSTMR_EVENT, time is absolute */
 {
     register TimerEntry *entryPtr, *entryPtrPos;
-    TimerEntry **tmrList, **tmrTail;
     register TimerHandler *timerPtr;
     ThreadSpecificData *tsdPtr;
 
@@ -396,19 +390,14 @@ TclpCreateTimerHandlerEx(
     tsdPtr->lastTimerId++;
     timerPtr->token = (Tcl_TimerToken) INT2PTR(tsdPtr->lastTimerId);
 
-    if (flags & TCL_ABSTMR_EVENT) {
-	tmrList = &tsdPtr->absTimerList;
-	tmrTail = &tsdPtr->absTimerTail;
-    } else {
+    if (!(flags & TCL_ABSTMR_EVENT)) {
 	Tcl_WideInt now = TclpGetMicroseconds();
 
-	tmrList = &tsdPtr->relTimerList;
-	tmrTail = &tsdPtr->relTimerTail;
 	/* 
 	 * We should have the ability to ajust end-time of relative events,
 	 * for possible time-jumps.
 	 */
-	if (tsdPtr->relTimerList) {
+	if (tsdPtr->timerList) {
 	    /* 
 	     * end-time = now + usec
 	     * Adjust value of usec relative current base (to now), so
@@ -437,15 +426,15 @@ TclpCreateTimerHandlerEx(
      * (ordered by event firing time).
      */
 
-    /* if before current first (e. g. "after 0" before first "after 1000") */
-    if ( !(entryPtrPos = *tmrList)
+    /* if before current first (e. g. "after 1" before first "after 1000") */
+    if ( !(entryPtrPos = tsdPtr->timerList)
       || usec < TimerEntry2TimerHandler(entryPtrPos)->time
     ) {
     	/* splice to the head */
-	TclSpliceInEx(entryPtr, *tmrList, *tmrTail);
+	TclSpliceInEx(entryPtr, tsdPtr->timerList, tsdPtr->timerTail);
     } else {
     	/* search from end as long as one with time before not found */
-	for (entryPtrPos = *tmrTail; entryPtrPos != NULL;
+	for (entryPtrPos = tsdPtr->timerTail; entryPtrPos != NULL;
 	    entryPtrPos = entryPtrPos->prevPtr) {
 	    if (usec >= TimerEntry2TimerHandler(entryPtrPos)->time) {
 		break;
@@ -458,12 +447,12 @@ TclpCreateTimerHandlerEx(
 	    if ((entryPtr->nextPtr = entryPtrPos->nextPtr)) {
 		entryPtrPos->nextPtr->prevPtr = entryPtr;
 	    } else {
-		*tmrTail = entryPtr;
+		tsdPtr->timerTail = entryPtr;
 	    }
 	    entryPtrPos->nextPtr = entryPtr;
 	} else {
 	    /* unexpected case, but ... splice to the head */
-	    TclSpliceInEx(entryPtr, *tmrList, *tmrTail);
+	    TclSpliceInEx(entryPtr, tsdPtr->timerList, tsdPtr->timerTail);
 	}
     }
 
@@ -594,19 +583,7 @@ Tcl_DeleteTimerHandler(
 	return;
     }
 
-    for (entryPtr = tsdPtr->relTimerTail;
-	entryPtr != NULL;
-	entryPtr = entryPtr->prevPtr
-    ) {
-	if (TimerEntry2TimerHandler(entryPtr)->token != token) {
-	    continue;
-	}
-
-	TclDeleteTimerEntry(entryPtr);
-	return;
-    }
-
-    for (entryPtr = tsdPtr->absTimerTail;
+    for (entryPtr = tsdPtr->timerTail;
 	entryPtr != NULL;
 	entryPtr = entryPtr->prevPtr
     ) {
@@ -660,11 +637,7 @@ TclDeleteTimerEntry(
     } else {
 	/* timer event-handler */
 	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
-	if (!(entryPtr->flags & TCL_ABSTMR_EVENT)) {
-	    TclSpliceOutEx(entryPtr, tsdPtr->relTimerList, tsdPtr->relTimerTail);
-	} else {
-	    TclSpliceOutEx(entryPtr, tsdPtr->absTimerList, tsdPtr->absTimerTail);
-	}
+	TclSpliceOutEx(entryPtr, tsdPtr->timerList, tsdPtr->timerTail);
     }
 
     /* free it via deleteProc or ckfree */
@@ -683,7 +656,7 @@ TclDeleteTimerEntry(
 /*
  *--------------------------------------------------------------
  *
- * TimerGetFirstTime --
+ * TimerGetDueTime --
  *
  *	Find the execution time of first relative or absolute timer starting
  *	from given heads.
@@ -699,14 +672,12 @@ TclDeleteTimerEntry(
  */
 
 static Tcl_WideInt
-TimerGetFirstTime(
+TimerGetDueTime(
     ThreadSpecificData *tsdPtr,
-    TimerEntry *relTimerList,
-    TimerEntry *absTimerList,
-    Tcl_WideInt now,
-    TimerEntry **entryPtr)
+    TimerEntry *entryPtr,
+    Tcl_WideInt now)
 {
-    Tcl_WideInt firstTime = -0x7FFFFFFFFFFFFFFFL;
+    Tcl_WideInt firstTime;
 
     /* 
      * Consider time-jump (especially back) - if the time jumped forwards (and
@@ -715,34 +686,26 @@ TimerGetFirstTime(
      * jumps it is very important and we should adjust relative base to avoid 
      * too long waiting for relative events.
      */
-    if (relTimerList) {
-	Tcl_WideInt diff;
-	if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
-	  || (diff = (now - tsdPtr->knownTime)) < 0 /* switched back */
-	) {
-	    /* 
-	     * If the real jump is unknown (resp. too complex to retrieve
-	     * accross all threads), we simply accept possible small increment
-	     * of the real wait-time.
-	     */
-	    tsdPtr->relTimerBase += diff; /* shift the base */
-	}
-	tsdPtr->knownTime = now;
-	/* end-time = base + relative event-time */
-	firstTime = tsdPtr->relTimerBase
-	    + TimerEntry2TimerHandler(relTimerList)->time;
-	if (entryPtr) { *entryPtr = relTimerList; }
-    }
-
-    if ( absTimerList
-      && firstTime < TimerEntry2TimerHandler(absTimerList)->time
+    Tcl_WideInt diff;
+    if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
+      || (diff = (now - tsdPtr->knownTime)) < 0 /* switched back */
     ) {
-	/* end-time = absolute event-time */
-	firstTime = TimerEntry2TimerHandler(absTimerList)->time;
-	if (entryPtr) { *entryPtr = absTimerList; }
+	/* 
+	 * If the real jump is unknown (resp. too complex to retrieve
+	 * accross all threads), we simply accept possible small increment
+	 * of the real wait-time.
+	 */
+	tsdPtr->relTimerBase += diff; /* shift the base */
     }
+    tsdPtr->knownTime = now;
 
-    return firstTime;
+    /* If absolute timer: end-time = absolute event-time */
+    firstTime = TimerEntry2TimerHandler(entryPtr)->time;
+    if ((entryPtr->flags & TCL_ABSTMR_EVENT)) {
+    	return firstTime;
+    }
+    /* end-time = base + relative event-time */
+    return firstTime + tsdPtr->relTimerBase;
 }
 
 /*
@@ -770,7 +733,6 @@ TimerSetupProc(
 {
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
-    long tolerance = 0;
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
@@ -786,25 +748,27 @@ TimerSetupProc(
 
     } else if (
 	   (flags & TCL_TIMER_EVENTS) 
-	&& (tsdPtr->relTimerList || tsdPtr->absTimerList)
+	&& (tsdPtr->timerList)
     ) {
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
 
 	Tcl_WideInt now = TclpGetMicroseconds();
-	Tcl_WideInt timeOffs = TimerGetFirstTime(tsdPtr, 
-		tsdPtr->relTimerList, tsdPtr->absTimerList, now, NULL) - now;
+	Tcl_WideInt entryTime;
 
-	if (timeOffs > 0) {
-	    blockTime.sec = (long) (timeOffs / 1000000);
-	    blockTime.usec = (unsigned long) (timeOffs % 1000000);
+	entryTime = TimerGetDueTime(tsdPtr, tsdPtr->timerList, now) - now;
 
 	#ifdef TMR_RES_TOLERANCE
 	    /* consider timer resolution tolerance (avoid busy wait) */
-	    tolerance = ((timeOffs <= 1000000) ? timeOffs : 1000000) *
+	    entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
 				TMR_RES_TOLERANCE / 100;
 	#endif
+
+	if (entryTime > 0) {
+	    blockTime.sec = (long) (entryTime / 1000000);
+	    blockTime.usec = (unsigned long) (entryTime % 1000000);
+
 	} else {
 	    blockTime.sec = 0;
 	    blockTime.usec = 0;
@@ -813,7 +777,7 @@ TimerSetupProc(
 	/*
 	* If the first timer has expired, stick an event on the queue right now.
 	*/
-	if (!tsdPtr->timerPending && timeOffs <= tolerance) {
+	if (!tsdPtr->timerPending && entryTime <= 0) {
 	    TclSetTimerEventMarker(0);
 	    tsdPtr->timerPending = 1;
 	}
@@ -847,9 +811,8 @@ TimerCheckProc(
     ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_WideInt now, timeOffs;
+    Tcl_WideInt now, entryTime;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
-    long tolerance = 0;
 
     if (!(flags & TCL_TIMER_EVENTS)) {
     	return;
@@ -858,7 +821,7 @@ TimerCheckProc(
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
     /* If already pending (or no timer-events) */
-    if (tsdPtr->timerPending || !(tsdPtr->relTimerList || tsdPtr->absTimerList)) {
+    if (tsdPtr->timerPending || !tsdPtr->timerList) {
     	return;
     }
 
@@ -866,19 +829,18 @@ TimerCheckProc(
      * Verify the first timer on the queue.
      */
     now = TclpGetMicroseconds();
-    timeOffs = TimerGetFirstTime(tsdPtr,
-    	tsdPtr->relTimerList, tsdPtr->absTimerList, now, NULL) - now;
+    entryTime = TimerGetDueTime(tsdPtr, tsdPtr->timerList, now) - now;
     
 #ifdef TMR_RES_TOLERANCE
     /* consider timer resolution tolerance (avoid busy wait) */
-    tolerance = ((timeOffs <= 1000000) ? timeOffs : 1000000) *
+    entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
 			TMR_RES_TOLERANCE / 100;
 #endif
    
     /*
     * If the first timer has expired, stick an event on the queue.
     */
-    if (timeOffs <= tolerance) {
+    if (entryTime <= 0) {
 	TclSetTimerEventMarker(0);
 	tsdPtr->timerPending = 1;
     }
@@ -909,7 +871,7 @@ TimerCheckProc(
 int
 TclServiceTimerEvents(void)
 {
-    TimerEntry *entryPtr, *relTimerList, *absTimerList;
+    TimerEntry *entryPtr, *nextPtr;
     Tcl_WideInt now, entryTime;
     size_t currentGeneration, currentEpoch;
     int prevTmrPending;
@@ -974,27 +936,24 @@ TclServiceTimerEvents(void)
     }
 
     /* Hereafter all relative and absolute timer events with time before now */
-    relTimerList = tsdPtr->relTimerList;
-    absTimerList = tsdPtr->absTimerList;
-    while (relTimerList || absTimerList)
-    {
+    for (entryPtr = tsdPtr->timerList;
+	 entryPtr != NULL;
+	 entryPtr = nextPtr
+    ) {
+	nextPtr = entryPtr->nextPtr;
 	now = TclpGetMicroseconds();
-	entryTime = TimerGetFirstTime(tsdPtr, relTimerList, absTimerList, now, &entryPtr);
+	entryTime = TimerGetDueTime(tsdPtr, entryPtr, now);
 
+    	/* the same tolerance logic as in TimerSetupProc/TimerCheckProc */
     #ifdef TMR_RES_TOLERANCE
 	entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
 				TMR_RES_TOLERANCE / 100;
     #endif
+
 	if (now < entryTime) {
 	    break;
 	}
 
-	/* Current list head to next entry */
-	if (entryPtr == relTimerList) {
-	    relTimerList = relTimerList->nextPtr;
-	} else {
-	    absTimerList = absTimerList->nextPtr;
-	}
 	/*
 	 * Bypass timers of newer generation.
 	 */
@@ -1012,13 +971,8 @@ TclServiceTimerEvents(void)
 	 * Remove the handler from the queue before invoking it, to avoid
 	 * potential reentrancy problems.
 	 */
-	if (!(entryPtr->flags & TCL_ABSTMR_EVENT)) {
-	    TclSpliceOutEx(entryPtr, 
-		tsdPtr->relTimerList, tsdPtr->relTimerTail);
-	} else {
-	    TclSpliceOutEx(entryPtr, 
-		tsdPtr->absTimerList, tsdPtr->absTimerTail);
-	}
+	TclSpliceOutEx(entryPtr, 
+		tsdPtr->timerList, tsdPtr->timerTail);
 
 	/* reset current timer pending (correct process nested wait event) */
 	prevTmrPending = tsdPtr->timerPending;
@@ -1050,7 +1004,7 @@ TclServiceTimerEvents(void)
     }
 
     /* Reset generation if both timer queue are empty */
-    if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
+    if (!tsdPtr->timerList) {
 	tsdPtr->timerGeneration = 0;
     }
 
-- 
cgit v0.12


From beb9601daa56f0fa2d98122884b79d9bc59e8d1e Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:30:12 +0000
Subject: interim commit: code review, rewrite tclTimer, etc.

---
 generic/tclIO.c     |  53 +++++++++++--
 generic/tclIO.h     |   2 +-
 generic/tclInt.h    |  53 +++++++------
 generic/tclInterp.c |   4 +-
 generic/tclTimer.c  | 218 +++++++++++++++++++++++++++++++++-------------------
 5 files changed, 219 insertions(+), 111 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 2e1569f..a705199 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -167,6 +167,7 @@ static void		PreserveChannelBuffer(ChannelBuffer *bufPtr);
 static void		ReleaseChannelBuffer(ChannelBuffer *bufPtr);
 static int		IsShared(ChannelBuffer *bufPtr);
 static void		ChannelFree(Channel *chanPtr);
+static void		FreeChannelTimerProc(ClientData clientData);
 static void		ChannelTimerProc(ClientData clientData);
 static int		ChanRead(Channel *chanPtr, char *dst, int dstSize);
 static int		CheckChannelErrors(ChannelState *statePtr,
@@ -2968,7 +2969,9 @@ CloseChannel(
      * Cancel any outstanding timer.
      */
 
-    Tcl_DeleteTimerHandler(statePtr->timer);
+    if (statePtr->timer) {
+	TclpDeleteTimerEntry(statePtr->timer);
+    }
 
     /*
      * Mark the channel as deleted by clearing the type structure.
@@ -3450,7 +3453,9 @@ Tcl_ClearChannelHandlers(
      * Cancel any outstanding timer.
      */
 
-    Tcl_DeleteTimerHandler(statePtr->timer);
+    if (statePtr->timer) {
+	TclpDeleteTimerEntry(statePtr->timer);
+    }
 
     /*
      * Remove any references to channel handlers for this channel that may be
@@ -8063,8 +8068,11 @@ UpdateInterest(
 	    mask &= ~TCL_EXCEPTION;
 
 	    if (!statePtr->timer) {
-		statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,
-			chanPtr);
+		statePtr->timer = TclpCreateTimerEntryEx(ChannelTimerProc,
+			FreeChannelTimerProc, 0, TCL_PROMPT_EVENT);
+		if (statePtr->timer) {
+		    statePtr->timer->clientData = chanPtr;
+		}
 	    }
 	}
     }
@@ -8074,6 +8082,35 @@ UpdateInterest(
 /*
  *----------------------------------------------------------------------
  *
+ * FreeChannelTimerProc --
+ *
+ *	This function simply reset timer in channel state structure.
+ *	It does *not* cancel the timer (called on execute/delete timer).
+ *
+ * Results:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+FreeChannelTimerProc(
+    ClientData clientData)		/* Channel handle. */
+{
+    Channel *chanPtr = clientData;
+    ChannelState *statePtr = chanPtr->state;
+    /* 
+     * Because channel can operate with multiple timers (asynchronously),
+     * be sure another timer was not set in-between (e. g. recursive events)
+     */
+    if (statePtr->timer && (statePtr->timer->flags & TCL_EVENTST_DELETE)) {
+	statePtr->timer = NULL; /* timer deleted */
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * ChannelTimerProc --
  *
  *	Timer handler scheduled by UpdateInterest to monitor the channel
@@ -8101,11 +8138,11 @@ ChannelTimerProc(
 	    && (statePtr->inQueueHead != NULL)
 	    && IsBufferReady(statePtr->inQueueHead)) {
 	/*
-	 * Restart the timer in case a channel handler reenters the event loop
+	 * Prolong the timer in case a channel handler reenters the event loop
 	 * before UpdateInterest gets called by Tcl_NotifyChannel.
 	 */
 
-	statePtr->timer = Tcl_CreateTimerHandler(0, ChannelTimerProc,chanPtr);
+	TclpProlongTimerHandler(statePtr->timer, 0, 0);
 	Tcl_Preserve(statePtr);
 	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
 	Tcl_Release(statePtr);
@@ -8703,7 +8740,9 @@ TclCopyChannel(
      */
 
     if ((nonBlocking == CHANNEL_NONBLOCKING) && (toRead == 0)) {
-        Tcl_CreateTimerHandler(0, ZeroTransferTimerProc, csPtr);
+        TclTimerEntry *timer = TclpCreateTimerEntryEx(ZeroTransferTimerProc,
+        	NULL, 0, TCL_PROMPT_EVENT);
+        timer->clientData = csPtr;
         return 0;
     }
 
diff --git a/generic/tclIO.h b/generic/tclIO.h
index d096798..cb2ca54 100644
--- a/generic/tclIO.h
+++ b/generic/tclIO.h
@@ -187,7 +187,7 @@ typedef struct ChannelState {
 				/* Chain of all scripts registered for event
 				 * handlers ("fileevent") on this channel. */
     int bufSize;		/* What size buffers to allocate? */
-    Tcl_TimerToken timer;	/* Handle to wakeup timer for this channel. */
+    TclTimerEntry *timer;	/* Handle to wakeup timer for this channel. */
     struct CopyState *csPtrR;	/* State of background copy for which channel
 				 * is input, or NULL. */
     struct CopyState *csPtrW;	/* State of background copy for which channel
diff --git a/generic/tclInt.h b/generic/tclInt.h
index fcb4752..88d101b 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -143,10 +143,12 @@ typedef int ptrdiff_t;
  *----------------------------------------------------------------
  */
 
-#define TCL_PROMPT_EVENT (1 << 0)	/* Mark immediate event */
-#define TCL_ABSTMR_EVENT (1 << 1)	/* Mark absolute timer event (the time 
-					 * of TimerHandler is absolute). */
-#define TCL_IDLE_EVENT   (1 << 5)	/* Mark idle event */
+#define TCL_PROMPT_EVENT    (1 << 0)	/* Mark immediate event */
+#define TCL_ABSTMR_EVENT    (1 << 1)	/* Mark absolute timer event (the time 
+					 * of TclTimerHandler is absolute). */
+#define TCL_IDLE_EVENT      (1 << 3)	/* Mark idle event */
+#define TCL_EVENTST_EXECUTE (1 << 5)	/* Event executed now (reset to prolong). */
+#define TCL_EVENTST_DELETE  (1 << 7)	/* Event will be deleted. */
 
 /*
  * This structure used for handling of timer events (with or without time to 
@@ -155,43 +157,44 @@ typedef int ptrdiff_t;
  * together into corresponding list.
  */
 
-typedef struct TimerEntry {
+typedef struct TclTimerEntry {
     Tcl_TimerProc	*proc;	/* Function to call timer/idle event */
     Tcl_TimerDeleteProc *deleteProc; /* Function to cleanup idle event */
     ClientData clientData;	/* Argument to pass to proc and deleteProc */
     int			flags;	/* Flags (TCL_IDLE_EVENT, TCL_PROMPT_EVENT) */
     size_t generation;		/* Used to distinguish older handlers from
 				 * recently-created ones. */
-    struct TimerEntry *nextPtr;/* Next and prev event in idle queue, */
-    struct TimerEntry *prevPtr;/* or NULL for end/start of the queue. */
+    struct TclTimerEntry *nextPtr;/* Next and prev event in idle queue, */
+    struct TclTimerEntry *prevPtr;/* or NULL for end/start of the queue. */
 /*  ExtraData	 */
-} TimerEntry;
+} TclTimerEntry;
 
 /*
  * For each timer callback that's pending there is one record of the following
  * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
- * together in a list via TimerEntry sorted by time (earliest event first).
+ * together in a list via TclTimerEntry sorted by time (earliest event first).
  */
 
 				 
-typedef struct TimerHandler {
+typedef struct TclTimerHandler {
     Tcl_WideInt		time;	/* When timer is to fire (absolute/relative). */
     Tcl_TimerToken	token;	/* Identifies handler so it can be deleted. */
-    struct TimerEntry	entry;
+    struct TclTimerEntry	entry;
 /*  ExtraData	 */
-} TimerHandler;
+} TclTimerHandler;
 
 /*
- * Macros to wrap ExtraData and TimerHandler resp. TimerEntry (and vice versa)
+ * Macros to wrap ExtraData and TclTimerHandler resp. TclTimerEntry (and vice versa)
  */
-#define TimerEntry2ClientData(ptr)					\
-	    ( (ClientData)(((TimerEntry *)(ptr))+1) )
-#define ClientData2TimerEntry(ptr)					\
-	    ( ((TimerEntry *)(ptr))-1 )
+#define TclpTimerEntry2ClientData(ptr)					\
+	    ( (ClientData)(((TclTimerEntry *)(ptr))+1) )
+#define TclpClientData2TimerEntry(ptr)					\
+	    ( ((TclTimerEntry *)(ptr))-1 )
 
-#define TimerEntry2TimerHandler(ptr)					\
-	    ( (TimerHandler *)(((char *)(ptr)) - TclOffset(TimerHandler,entry)) )
-#define TimerHandler2TimerEntry(ptr)					\
+#define TclpTimerEntry2TimerHandler(ptr)				\
+	    ( (TclTimerHandler *)(((char *)(ptr)) -			\
+			TclOffset(TclTimerHandler,entry)) )
+#define TclpTimerHandler2TimerEntry(ptr)				\
 	    ( &(ptr)->entry )
 
 /*
@@ -1864,7 +1867,7 @@ typedef struct Interp {
 				 * reached. */
 	int timeGranularity;	/* Mod factor used to determine how often to
 				 * evaluate the limit check. */
-	TimerEntry *timeEvent;	/* Handle for a timer callback that will occur
+	TclTimerEntry *timeEvent;/* Handle for a timer callback that will occur
 				 * when the time-limit is exceeded. */
 
 	Tcl_HashTable callbacks;/* Mapping from (interp,type) pair to data
@@ -3003,7 +3006,7 @@ MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 MODULE_SCOPE void	TclSetTimerEventMarker(int head);
 MODULE_SCOPE int	TclServiceTimerEvents(void);
 MODULE_SCOPE int	TclServiceIdleEx(int flags, int count);
-MODULE_SCOPE TimerEntry* TclpCreateTimerHandlerEx(
+MODULE_SCOPE TclTimerEntry* TclpCreateTimerHandlerEx(
 			    Tcl_WideInt usec,
 			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
 			    size_t extraDataSize, int flags);
@@ -3013,10 +3016,12 @@ MODULE_SCOPE Tcl_TimerToken TclCreateRelativeTimerHandler(
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
 			    ClientData clientData);
-MODULE_SCOPE TimerEntry* TclCreateTimerEntryEx(
+MODULE_SCOPE TclTimerEntry* TclpCreateTimerEntryEx(
 			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
 			    size_t extraDataSize, int flags);
-MODULE_SCOPE void	TclDeleteTimerEntry(TimerEntry *entryPtr);
+MODULE_SCOPE void	TclpDeleteTimerEntry(TclTimerEntry *entryPtr);
+MODULE_SCOPE void	TclpProlongTimerHandler(TclTimerEntry *entryPtr,
+			    Tcl_WideInt usec, int flags);
 MODULE_SCOPE int	TclPeekEventQueued(int flags);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index 03a9fe2..0d7086c 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -3513,7 +3513,7 @@ TclLimitRemoveAllHandlers(
      */
 
     if (iPtr->limit.timeEvent != NULL) {
-	TclDeleteTimerEntry(iPtr->limit.timeEvent);
+	TclpDeleteTimerEntry(iPtr->limit.timeEvent);
 	iPtr->limit.timeEvent = NULL;
     }
 }
@@ -3722,7 +3722,7 @@ Tcl_LimitSetTime(
 
     memcpy(&iPtr->limit.time, timeLimitPtr, sizeof(Tcl_Time));
     if (iPtr->limit.timeEvent != NULL) {
-	TclDeleteTimerEntry(iPtr->limit.timeEvent);
+	TclpDeleteTimerEntry(iPtr->limit.timeEvent);
     }
     nextMoment = TCL_TIME_TO_USEC(*timeLimitPtr) + 10;
     iPtr->limit.timeEvent = TclpCreateTimerHandlerEx(nextMoment,
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index a245a18..c4183f4 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -65,17 +65,17 @@ typedef struct {
     Tcl_WideInt relTimerBase;	/* Time base of the first known relative */
 				/* timer, used to revert all events to the new
 				 * base after possible time-jump (adjustment).*/
-    TimerEntry *timerList;	/* First event in queue of timers. */
-    TimerEntry *timerTail;	/* Last event in queue of timers. */
-    TimerEntry *promptList;	/* First immediate event in queue. */
-    TimerEntry *promptTail;	/* Last immediate event in queue. */
+    TclTimerEntry *timerList;	/* First event in queue of timers. */
+    TclTimerEntry *timerTail;	/* Last event in queue of timers. */
+    TclTimerEntry *promptList;	/* First immediate event in queue. */
+    TclTimerEntry *promptTail;	/* Last immediate event in queue. */
     size_t timerListEpoch;	/* Used for safe process of event queue (stop
     				 * the cycle after modifying of event queue) */
     int lastTimerId;		/* Timer identifier of most recently created
 				 * timer event. */
     int timerPending;		/* 1 if a timer event is in the queue. */
-    TimerEntry *idleList;	/* First in list of all idle handlers. */
-    TimerEntry *idleTail;	/* Last in list (or NULL for empty list). */
+    TclTimerEntry *idleList;	/* First in list of all idle handlers. */
+    TclTimerEntry *idleTail;	/* Last in list (or NULL for empty list). */
     size_t timerGeneration;	/* Used to fill in the "generation" fields of */
     size_t idleGeneration;	/* timer or idle structures. Increments each
 				 * time we place a new handler to queue inside,
@@ -91,10 +91,10 @@ static Tcl_ThreadDataKey dataKey;
  * Helper macros to wrap AfterInfo and handlers (and vice versa)
  */
 
-#define TimerEntry2AfterInfo(ptr)					\
-	    ( (AfterInfo*)TimerEntry2ClientData(ptr) )
-#define AfterInfo2TimerEntry(ptr)					\
-	    ClientData2TimerEntry(ptr)
+#define TclpTimerEntry2AfterInfo(ptr)					\
+	    ( (AfterInfo*)TclpTimerEntry2ClientData(ptr) )
+#define TclpAfterInfo2TimerEntry(ptr)					\
+	    TclpClientData2TimerEntry(ptr)
 
 /*
  * Prototypes for functions referenced only in this file:
@@ -253,6 +253,29 @@ InitTimer(void)
     return tsdPtr;
 }
 
+static void
+AttachTimerEntry(
+    ThreadSpecificData *tsdPtr,
+    TclTimerEntry *entryPtr)
+{
+    if (entryPtr->flags & TCL_PROMPT_EVENT) {
+	/* use timer generation, because usually no differences between 
+	 * call of "after 0" and "after 1" */
+	entryPtr->generation = tsdPtr->timerGeneration;
+	/* attach to the prompt queue */
+	TclSpliceTailEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
+	
+	/* execute immediately: signal pending and set timer marker */
+	tsdPtr->timerPending++;
+	TclSetTimerEventMarker(0);
+    } else {
+	/* idle generation */
+	entryPtr->generation = tsdPtr->idleGeneration;
+	/* attach to the idle queue */
+	TclSpliceTailEx(entryPtr, tsdPtr->idleList, tsdPtr->idleTail);
+    }
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -281,13 +304,13 @@ TimerExitProc(
 	Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
 
 	while ((tsdPtr->promptTail) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->promptTail);
+	    TclpDeleteTimerEntry(tsdPtr->promptTail);
 	}
 	while ((tsdPtr->timerTail) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->timerTail);
+	    TclpDeleteTimerEntry(tsdPtr->timerTail);
 	}
 	while ((tsdPtr->idleTail) != NULL) {
-	    TclDeleteTimerEntry(tsdPtr->idleTail);
+	    TclpDeleteTimerEntry(tsdPtr->idleTail);
 	}
     }
 }
@@ -317,7 +340,7 @@ Tcl_CreateTimerHandler(
     Tcl_TimerProc *proc,	/* Function to invoke. */
     ClientData clientData)	/* Arbitrary data to pass to proc. */
 {
-    register TimerEntry *entryPtr;
+    register TclTimerEntry *entryPtr;
     Tcl_WideInt usec;
 
     /*
@@ -336,7 +359,7 @@ Tcl_CreateTimerHandler(
     }
     entryPtr->clientData = clientData;
 
-    return TimerEntry2TimerHandler(entryPtr)->token;
+    return TclpTimerEntry2TimerHandler(entryPtr)->token;
 }
 
 /*
@@ -358,7 +381,7 @@ Tcl_CreateTimerHandler(
  *--------------------------------------------------------------
  */
 
-TimerEntry*
+TclTimerEntry*
 TclpCreateTimerHandlerEx(
     Tcl_WideInt usec,		/* Time to be invoked (absolute/relative) */
     Tcl_TimerProc *proc,	/* Function to invoke */
@@ -366,16 +389,17 @@ TclpCreateTimerHandlerEx(
     size_t extraDataSize,	/* Size of extra data to allocate */
     int flags)			/* If TCL_ABSTMR_EVENT, time is absolute */
 {
-    register TimerEntry *entryPtr, *entryPtrPos;
-    register TimerHandler *timerPtr;
+    register TclTimerEntry *entryPtr, *entryPtrPos;
+    register TclTimerHandler *timerPtr;
     ThreadSpecificData *tsdPtr;
 
     tsdPtr = InitTimer();
-    timerPtr = (TimerHandler *) ckalloc(sizeof(TimerHandler) + extraDataSize);
+    timerPtr = (TclTimerHandler *)ckalloc(
+			sizeof(TclTimerHandler) + extraDataSize);
     if (timerPtr == NULL) {
 	return NULL;
     }
-    entryPtr = TimerHandler2TimerEntry(timerPtr);
+    entryPtr = TclpTimerHandler2TimerEntry(timerPtr);
 
     /*
      * Fill in fields for the event.
@@ -383,7 +407,7 @@ TclpCreateTimerHandlerEx(
 
     entryPtr->proc = proc;
     entryPtr->deleteProc = deleteProc;
-    entryPtr->clientData = TimerEntry2ClientData(entryPtr);
+    entryPtr->clientData = TclpTimerEntry2ClientData(entryPtr);
     entryPtr->flags = flags & TCL_ABSTMR_EVENT;
     entryPtr->generation = tsdPtr->timerGeneration;
     tsdPtr->timerListEpoch++; /* signal-timer list was changed */
@@ -428,7 +452,7 @@ TclpCreateTimerHandlerEx(
 
     /* if before current first (e. g. "after 1" before first "after 1000") */
     if ( !(entryPtrPos = tsdPtr->timerList)
-      || usec < TimerEntry2TimerHandler(entryPtrPos)->time
+      || usec < TclpTimerEntry2TimerHandler(entryPtrPos)->time
     ) {
     	/* splice to the head */
 	TclSpliceInEx(entryPtr, tsdPtr->timerList, tsdPtr->timerTail);
@@ -436,7 +460,7 @@ TclpCreateTimerHandlerEx(
     	/* search from end as long as one with time before not found */
 	for (entryPtrPos = tsdPtr->timerTail; entryPtrPos != NULL;
 	    entryPtrPos = entryPtrPos->prevPtr) {
-	    if (usec >= TimerEntry2TimerHandler(entryPtrPos)->time) {
+	    if (usec >= TclpTimerEntry2TimerHandler(entryPtrPos)->time) {
 		break;
 	    }
 	}
@@ -485,7 +509,7 @@ TclCreateAbsoluteTimerHandler(
     Tcl_TimerProc *proc,
     ClientData clientData)
 {
-    register TimerEntry *entryPtr;
+    register TclTimerEntry *entryPtr;
     Tcl_WideInt usec;
 
     /*
@@ -504,7 +528,7 @@ TclCreateAbsoluteTimerHandler(
     }
     entryPtr->clientData = clientData;
 
-    return TimerEntry2TimerHandler(entryPtr)->token;
+    return TclpTimerEntry2TimerHandler(entryPtr)->token;
 }
 
 /*
@@ -531,7 +555,7 @@ TclCreateRelativeTimerHandler(
     Tcl_TimerProc *proc,
     ClientData clientData)
 {
-    register TimerEntry *entryPtr;
+    register TclTimerEntry *entryPtr;
     Tcl_WideInt usec;
 
     /*
@@ -550,7 +574,7 @@ TclCreateRelativeTimerHandler(
     }
     entryPtr->clientData = clientData;
 
-    return TimerEntry2TimerHandler(entryPtr)->token;
+    return TclpTimerEntry2TimerHandler(entryPtr)->token;
 }
 
 /*
@@ -576,7 +600,7 @@ Tcl_DeleteTimerHandler(
     Tcl_TimerToken token)	/* Result previously returned by
 				 * Tcl_CreateTimerHandler. */
 {
-    register TimerEntry *entryPtr;
+    register TclTimerEntry *entryPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     if (token == NULL) {
@@ -587,11 +611,11 @@ Tcl_DeleteTimerHandler(
 	entryPtr != NULL;
 	entryPtr = entryPtr->prevPtr
     ) {
-	if (TimerEntry2TimerHandler(entryPtr)->token != token) {
+	if (TclpTimerEntry2TimerHandler(entryPtr)->token != token) {
 	    continue;
 	}
 
-	TclDeleteTimerEntry(entryPtr);
+	TclpDeleteTimerEntry(entryPtr);
 	return;
     }
 }
@@ -600,7 +624,7 @@ Tcl_DeleteTimerHandler(
 /*
  *--------------------------------------------------------------
  *
- * TclDeleteTimerEntry --
+ * TclpDeleteTimerEntry --
  *
  *	Delete a previously-registered prompt, timer or idle handler.
  *
@@ -616,18 +640,28 @@ Tcl_DeleteTimerHandler(
  */
 
 void
-TclDeleteTimerEntry(
-    TimerEntry *entryPtr)	/* Result previously returned by */
-	/* TclCreateTimerHandlerEx or TclCreateTimerEntryEx. */
+TclpDeleteTimerEntry(
+    TclTimerEntry *entryPtr)	/* Result previously returned by */
+	/* TclpCreateTimerHandlerEx or TclpCreateTimerEntryEx. */
 {
     ThreadSpecificData *tsdPtr;
 
     if (entryPtr == NULL) {
 	return;
     }
+    if (entryPtr->flags & (TCL_EVENTST_EXECUTE|TCL_EVENTST_DELETE)) {
+	/* do nothing - event will be automatically deleted hereafter */
+	return;
+    }
 
     tsdPtr = InitTimer();
 
+    /* 
+     * Mark this entry will be deleted, so it can avoid double delete and
+     * caller can check in delete callback, the time entry handle is still
+     * the same (was not overriden in some recursive async-envent).
+     */
+    entryPtr->flags |= TCL_EVENTST_DELETE;
     if (entryPtr->flags & TCL_PROMPT_EVENT) {
 	/* prompt handler */
 	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
@@ -642,15 +676,38 @@ TclDeleteTimerEntry(
 
     /* free it via deleteProc or ckfree */
     if (entryPtr->deleteProc) {
+    	entryPtr->flags |= TCL_EVENTST_DELETE;
 	(*entryPtr->deleteProc)(entryPtr->clientData);
+	/* if prolongation requested - reattached to tail */
+	if (!(entryPtr->flags & TCL_EVENTST_DELETE)) {
+	    return;
+	}
     }
 
     if (entryPtr->flags & (TCL_PROMPT_EVENT|TCL_IDLE_EVENT)) {
 	ckfree((char *)entryPtr);
     } else {
 	/* shift to the allocated pointer */
-	ckfree((char *)TimerEntry2TimerHandler(entryPtr));
+	ckfree((char *)TclpTimerEntry2TimerHandler(entryPtr));
+    }
+}
+
+void
+TclpProlongTimerHandler(
+    TclTimerEntry *entryPtr,
+    Tcl_WideInt usec,
+    int flags)
+{
+    ThreadSpecificData *tsdPtr = InitTimer();
+
+    /* reset execution and deletion states */
+    entryPtr->flags &= ~(TCL_EVENTST_EXECUTE|TCL_EVENTST_DELETE);
+    /* attach to the queue again (new generation) */
+    if (usec != 0 || flags != 0) {
+	Tcl_Panic("NYI: ATM only prompt & idle");
+	return;
     }
+    AttachTimerEntry(tsdPtr, entryPtr);
 }
 
 /*
@@ -674,7 +731,7 @@ TclDeleteTimerEntry(
 static Tcl_WideInt
 TimerGetDueTime(
     ThreadSpecificData *tsdPtr,
-    TimerEntry *entryPtr,
+    TclTimerEntry *entryPtr,
     Tcl_WideInt now)
 {
     Tcl_WideInt firstTime;
@@ -700,7 +757,7 @@ TimerGetDueTime(
     tsdPtr->knownTime = now;
 
     /* If absolute timer: end-time = absolute event-time */
-    firstTime = TimerEntry2TimerHandler(entryPtr)->time;
+    firstTime = TclpTimerEntry2TimerHandler(entryPtr)->time;
     if ((entryPtr->flags & TCL_ABSTMR_EVENT)) {
     	return firstTime;
     }
@@ -871,7 +928,7 @@ TimerCheckProc(
 int
 TclServiceTimerEvents(void)
 {
-    TimerEntry *entryPtr, *nextPtr;
+    TclTimerEntry *entryPtr, *nextPtr;
     Tcl_WideInt now, entryTime;
     size_t currentGeneration, currentEpoch;
     int prevTmrPending;
@@ -917,13 +974,22 @@ TclServiceTimerEvents(void)
 	prevTmrPending = tsdPtr->timerPending;
 	tsdPtr->timerPending = 0;
 	/* execute event */
+	entryPtr->flags |= TCL_EVENTST_EXECUTE;
 	(*entryPtr->proc)(entryPtr->clientData);
 	/* restore current timer pending */
 	tsdPtr->timerPending += prevTmrPending;
-
+	/* if prolongation requested - reattached to tail */
+	if (!(entryPtr->flags & TCL_EVENTST_EXECUTE)) {
+	    continue;
+	}
 	/* free it via deleteProc and ckfree */
 	if (entryPtr->deleteProc) {
+	    entryPtr->flags |= TCL_EVENTST_DELETE;
 	    (*entryPtr->deleteProc)(entryPtr->clientData);
+	    /* if prolongation requested - reattached to tail */
+	    if (!(entryPtr->flags & TCL_EVENTST_DELETE)) {
+	        continue;
+	    }
 	}
 	ckfree((char *) entryPtr);
     }
@@ -978,16 +1044,18 @@ TclServiceTimerEvents(void)
 	prevTmrPending = tsdPtr->timerPending;
 	tsdPtr->timerPending = 0;
 	/* invoke timer proc */
+	entryPtr->flags |= TCL_EVENTST_EXECUTE;
 	(*entryPtr->proc)(entryPtr->clientData);
 	/* restore current timer pending */
 	tsdPtr->timerPending += prevTmrPending;
 
 	/* free it via deleteProc or ckfree */
 	if (entryPtr->deleteProc) {
+	    entryPtr->flags |= TCL_EVENTST_DELETE;
 	    (*entryPtr->deleteProc)(entryPtr->clientData);
 	}
 
-	ckfree((char *) TimerEntry2TimerHandler(entryPtr));
+	ckfree((char *) TclpTimerEntry2TimerHandler(entryPtr));
 
 	/* be sure that timer-list was not changed inside the proc call */
 	if (currentEpoch != tsdPtr->timerListEpoch) {
@@ -1017,7 +1085,7 @@ TclServiceTimerEvents(void)
 /*
  *--------------------------------------------------------------
  *
- * TclCreateTimerEntryEx --
+ * TclpCreateTimerEntryEx --
  *
  *	Arrange for proc to be invoked delayed (but prompt) as timer event,
  *	without time ("after 0").
@@ -1038,40 +1106,26 @@ TclServiceTimerEvents(void)
  *--------------------------------------------------------------
  */
 
-TimerEntry *
-TclCreateTimerEntryEx(
+TclTimerEntry *
+TclpCreateTimerEntryEx(
     Tcl_TimerProc *proc,		/* Function to invoke. */
     Tcl_TimerDeleteProc *deleteProc,	/* Function to cleanup */
     size_t extraDataSize,
     int flags)
 {
-    register TimerEntry *entryPtr;
+    register TclTimerEntry *entryPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    entryPtr = (TimerEntry *) ckalloc(sizeof(TimerEntry) + extraDataSize);
+    entryPtr = (TclTimerEntry *) ckalloc(sizeof(TclTimerEntry) + extraDataSize);
     if (entryPtr == NULL) {
 	return NULL;
     }
     entryPtr->proc = proc;
     entryPtr->deleteProc = deleteProc;
-    entryPtr->clientData = TimerEntry2ClientData(entryPtr);
+    entryPtr->clientData = TclpTimerEntry2ClientData(entryPtr);
     entryPtr->flags = flags;
-    if (flags & TCL_PROMPT_EVENT) {
-    	/* use timer generation, because usually no differences between 
-    	 * call of "after 0" and "after 1" */
-	entryPtr->generation = tsdPtr->timerGeneration;
-	/* attach to the prompt queue */
-	TclSpliceTailEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
-	
-	/* execute immediately: signal pending and set timer marker */
-	tsdPtr->timerPending++;
-	TclSetTimerEventMarker(0);
-    } else {
-    	/* idle generation */
-	entryPtr->generation = tsdPtr->idleGeneration;
-	/* attach to the idle queue */
-	TclSpliceTailEx(entryPtr, tsdPtr->idleList, tsdPtr->idleTail);
-    }
+
+    AttachTimerEntry(tsdPtr, entryPtr);
 
     return entryPtr;
 }
@@ -1099,7 +1153,7 @@ Tcl_DoWhenIdle(
     Tcl_IdleProc *proc,		/* Function to invoke. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    TimerEntry *idlePtr = TclCreateTimerEntryEx(proc, NULL, 0, TCL_IDLE_EVENT);
+    TclTimerEntry *idlePtr = TclpCreateTimerEntryEx(proc, NULL, 0, TCL_IDLE_EVENT);
 
     if (idlePtr) {
     	idlePtr->clientData = clientData;
@@ -1129,7 +1183,7 @@ Tcl_CancelIdleCall(
     Tcl_IdleProc *proc,		/* Function that was previously registered. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    register TimerEntry *idlePtr, *nextPtr;
+    register TclTimerEntry *idlePtr, *nextPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     for (idlePtr = tsdPtr->idleList;
@@ -1144,6 +1198,7 @@ Tcl_CancelIdleCall(
 
 	    /* free it via deleteProc and ckfree */
 	    if (idlePtr->deleteProc) {
+	    	idlePtr->flags |= TCL_EVENTST_DELETE;
 		(*idlePtr->deleteProc)(idlePtr->clientData);
 	    }
 	    ckfree((char *) idlePtr);
@@ -1175,7 +1230,7 @@ TclServiceIdleEx(
     int flags,
     int count)
 {
-    TimerEntry *idlePtr;
+    TclTimerEntry *idlePtr;
     size_t currentGeneration;
     ThreadSpecificData *tsdPtr = InitTimer();
 
@@ -1207,19 +1262,28 @@ TclServiceIdleEx(
 	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->idleTail);
 
 	/* execute event */
+	idlePtr->flags |= TCL_EVENTST_EXECUTE;
 	(*idlePtr->proc)(idlePtr->clientData);
-
+	/* if prolongation requested - reattached to tail */
+	if (!(idlePtr->flags & TCL_EVENTST_EXECUTE)) {
+	    goto nextEvent;
+	}
 	/* free it via deleteProc and ckfree */
 	if (idlePtr->deleteProc) {
+	    idlePtr->flags |= TCL_EVENTST_DELETE;
 	    (*idlePtr->deleteProc)(idlePtr->clientData);
+	    /* if prolongation requested - reattached to tail */
+	    if (!(idlePtr->flags & TCL_EVENTST_DELETE)) {
+		goto nextEvent;
+	    }
 	}
 	ckfree((char *) idlePtr);
 
+    nextEvent:
 	/*
 	 * Stop processing idle if idle queue empty, count reached or other
 	 * events queued (only if not idle events only to service).
 	 */
-
 	if ( (idlePtr = tsdPtr->idleList) == NULL
 	  || !--count
 	  || ((flags & TCL_ALL_EVENTS) != TCL_IDLE_EVENTS 
@@ -1384,7 +1448,7 @@ Tcl_AfterObjCmd(
 	    return AfterDelay(interp, usec, 0);
 	}
     case AFTER_AT: {
-    	TimerEntry *entryPtr;
+    	TclTimerEntry *entryPtr;
     	int flags = 0;
     	if (index == AFTER_AT) {
 	    if (objc < 3) {
@@ -1408,14 +1472,14 @@ Tcl_AfterObjCmd(
 			    FreeAfterPtr, sizeof(AfterInfo), flags);
 	} else {
 	    /* after 0 <command> ... */
-	    entryPtr = TclCreateTimerEntryEx(AfterProc,
+	    entryPtr = TclpCreateTimerEntryEx(AfterProc,
 			    FreeAfterPtr, sizeof(AfterInfo), TCL_PROMPT_EVENT);
 	}
 
 	if (entryPtr == NULL) { /* error handled in panic */
 	    return TCL_ERROR;
 	}
-	afterPtr = TimerEntry2AfterInfo(entryPtr);
+	afterPtr = TclpTimerEntry2AfterInfo(entryPtr);
 
 	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
@@ -1485,24 +1549,24 @@ Tcl_AfterObjCmd(
 	    }
 	}
 	if (afterPtr != NULL && afterPtr->assocPtr->interp == interp) {
-	    TclDeleteTimerEntry(AfterInfo2TimerEntry(afterPtr));
+	    TclpDeleteTimerEntry(TclpAfterInfo2TimerEntry(afterPtr));
 	}
 	break;
     }
     case AFTER_IDLE: {
-    	TimerEntry *idlePtr;
+    	TclTimerEntry *idlePtr;
 
 	if (objc < 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "script script ...");
 	    return TCL_ERROR;
 	}
 
-	idlePtr = TclCreateTimerEntryEx(AfterProc,
+	idlePtr = TclpCreateTimerEntryEx(AfterProc,
 			FreeAfterPtr, sizeof(AfterInfo), TCL_IDLE_EVENT);
 	if (idlePtr == NULL) { /* error handled in panic */
 	    return TCL_ERROR;
 	}
-	afterPtr = TimerEntry2AfterInfo(idlePtr);
+	afterPtr = TclpTimerEntry2AfterInfo(idlePtr);
 
 	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
@@ -1557,7 +1621,7 @@ Tcl_AfterObjCmd(
 	resultListPtr = Tcl_NewObj();
 	Tcl_ListObjAppendElement(interp, resultListPtr, afterPtr->commandPtr);
 	Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
- 		(AfterInfo2TimerEntry(afterPtr)->flags & TCL_IDLE_EVENT) ? 
+ 		(TclpAfterInfo2TimerEntry(afterPtr)->flags & TCL_IDLE_EVENT) ?
  		    "idle" : "timer", -1));
 	Tcl_SetObjResult(interp, resultListPtr);
 	break;
@@ -1755,7 +1819,7 @@ AfterProc(
      */
 
     /* remove delete proc from handler (we'll do cleanup here) */
-    AfterInfo2TimerEntry(afterPtr)->deleteProc = NULL;
+    TclpAfterInfo2TimerEntry(afterPtr)->deleteProc = NULL;
 
     /* release object (mark it was triggered) */
     if (afterPtr->selfPtr) {
@@ -1858,7 +1922,7 @@ AfterCleanupProc(
     AfterAssocData *assocPtr = (AfterAssocData *) clientData;
 
     while ( assocPtr->lastAfterPtr ) {
-	TclDeleteTimerEntry(AfterInfo2TimerEntry(assocPtr->lastAfterPtr));
+	TclpDeleteTimerEntry(TclpAfterInfo2TimerEntry(assocPtr->lastAfterPtr));
     }
 }
 
-- 
cgit v0.12


From 76c0ca9d7fe8df2d4a5b46ead77bd8bd3f9d05a5 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:30:30 +0000
Subject: code review, rewrite tclTimer, prolongation, etc.

---
 generic/tclEvent.c  |   2 +-
 generic/tclIO.c     |  31 +-
 generic/tclIO.h     |   2 +-
 generic/tclInt.h    |  89 +++---
 generic/tclInterp.c |  50 +++-
 generic/tclTimer.c  | 792 ++++++++++++++++++++++++++++++----------------------
 tests/event.test    |  31 ++
 7 files changed, 593 insertions(+), 404 deletions(-)

diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index b5e73ea..dcd7e6b 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1399,7 +1399,7 @@ Tcl_VwaitObjCmd(
 	 * we assume that option is not an integer, try to get numeric timeout
 	 */
 	if (!TclObjIsIndexOfTable(objv[optc], updateEventOptions)
-	  && TclpGetUTimeFromObj(NULL, objv[optc], &usec) == TCL_OK) {
+	  && TclpGetUTimeFromObj(NULL, objv[optc], &usec, 1000) == TCL_OK) {
 	    if (usec < 0) { usec = 0; };
 	    optc--;
 	}
diff --git a/generic/tclIO.c b/generic/tclIO.c
index a705199..e4bfd35 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -2970,7 +2970,8 @@ CloseChannel(
      */
 
     if (statePtr->timer) {
-	TclpDeleteTimerEntry(statePtr->timer);
+	TclpDeleteTimerEvent(statePtr->timer);
+	statePtr->timer = NULL;
     }
 
     /*
@@ -3454,7 +3455,8 @@ Tcl_ClearChannelHandlers(
      */
 
     if (statePtr->timer) {
-	TclpDeleteTimerEntry(statePtr->timer);
+	TclpDeleteTimerEvent(statePtr->timer);
+	statePtr->timer = NULL;
     }
 
     /*
@@ -8068,8 +8070,8 @@ UpdateInterest(
 	    mask &= ~TCL_EXCEPTION;
 
 	    if (!statePtr->timer) {
-		statePtr->timer = TclpCreateTimerEntryEx(ChannelTimerProc,
-			FreeChannelTimerProc, 0, TCL_PROMPT_EVENT);
+		statePtr->timer = TclpCreatePromptTimerEvent(ChannelTimerProc,
+			FreeChannelTimerProc, 0, TCL_TMREV_PROMPT);
 		if (statePtr->timer) {
 		    statePtr->timer->clientData = chanPtr;
 		}
@@ -8099,13 +8101,7 @@ FreeChannelTimerProc(
 {
     Channel *chanPtr = clientData;
     ChannelState *statePtr = chanPtr->state;
-    /* 
-     * Because channel can operate with multiple timers (asynchronously),
-     * be sure another timer was not set in-between (e. g. recursive events)
-     */
-    if (statePtr->timer && (statePtr->timer->flags & TCL_EVENTST_DELETE)) {
-	statePtr->timer = NULL; /* timer deleted */
-    }
+    statePtr->timer = NULL; /* timer deleted */
 }
 
 /*
@@ -8142,7 +8138,14 @@ ChannelTimerProc(
 	 * before UpdateInterest gets called by Tcl_NotifyChannel.
 	 */
 
-	TclpProlongTimerHandler(statePtr->timer, 0, 0);
+	statePtr->timer = TclpProlongTimerEvent(statePtr->timer, 0, 0);
+	if (!statePtr->timer) {
+	    statePtr->timer = TclpCreatePromptTimerEvent(ChannelTimerProc,
+		FreeChannelTimerProc, 0, TCL_TMREV_PROMPT);
+	    if (statePtr->timer) {
+		statePtr->timer->clientData = chanPtr;
+	    }
+	}
 	Tcl_Preserve(statePtr);
 	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
 	Tcl_Release(statePtr);
@@ -8740,8 +8743,8 @@ TclCopyChannel(
      */
 
     if ((nonBlocking == CHANNEL_NONBLOCKING) && (toRead == 0)) {
-        TclTimerEntry *timer = TclpCreateTimerEntryEx(ZeroTransferTimerProc,
-        	NULL, 0, TCL_PROMPT_EVENT);
+        TclTimerEvent *timer = TclpCreatePromptTimerEvent(ZeroTransferTimerProc,
+        	NULL, 0, TCL_TMREV_PROMPT);
         timer->clientData = csPtr;
         return 0;
     }
diff --git a/generic/tclIO.h b/generic/tclIO.h
index cb2ca54..0b41f54 100644
--- a/generic/tclIO.h
+++ b/generic/tclIO.h
@@ -187,7 +187,7 @@ typedef struct ChannelState {
 				/* Chain of all scripts registered for event
 				 * handlers ("fileevent") on this channel. */
     int bufSize;		/* What size buffers to allocate? */
-    TclTimerEntry *timer;	/* Handle to wakeup timer for this channel. */
+    TclTimerEvent *timer;	/* Handle to wakeup timer for this channel. */
     struct CopyState *csPtrR;	/* State of background copy for which channel
 				 * is input, or NULL. */
     struct CopyState *csPtrW;	/* State of background copy for which channel
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 88d101b..78c56e1 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -143,59 +143,51 @@ typedef int ptrdiff_t;
  *----------------------------------------------------------------
  */
 
-#define TCL_PROMPT_EVENT    (1 << 0)	/* Mark immediate event */
-#define TCL_ABSTMR_EVENT    (1 << 1)	/* Mark absolute timer event (the time 
-					 * of TclTimerHandler is absolute). */
-#define TCL_IDLE_EVENT      (1 << 3)	/* Mark idle event */
-#define TCL_EVENTST_EXECUTE (1 << 5)	/* Event executed now (reset to prolong). */
-#define TCL_EVENTST_DELETE  (1 << 7)	/* Event will be deleted. */
+#define TCL_TMREV_PROMPT  (1 << 0)	/* Mark immediate event (0 microseconds) */
+#define TCL_TMREV_AT	  (1 << 1)	/* Mark timer event to execute verbatim
+					 * at the due-time (regardless any 
+					 * time-jumps). */
+#define TCL_TMREV_IDLE    (1 << 3)	/* Mark idle event */
+#define TCL_TMREV_LISTED  (1 << 5)	/* Event listed (attached to queue). */
+#define TCL_TMREV_DELETE  (1 << 7)	/* Event will be deleted. */
 
 /*
  * This structure used for handling of timer events (with or without time to 
  * invoke, e. g. created with "after 0") or declared in a call to Tcl_DoWhenIdle
  * (created with "after idle"). All of the currently-active handlers are linked
  * together into corresponding list.
+ *
+ * For each timer callback that's pending there is one record of the following
+ * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
+ * together in a list via TclTimerEvent sorted by time (earliest event first).
  */
 
-typedef struct TclTimerEntry {
+typedef struct TclTimerEvent {
     Tcl_TimerProc	*proc;	/* Function to call timer/idle event */
     Tcl_TimerDeleteProc *deleteProc; /* Function to cleanup idle event */
     ClientData clientData;	/* Argument to pass to proc and deleteProc */
-    int			flags;	/* Flags (TCL_IDLE_EVENT, TCL_PROMPT_EVENT) */
-    size_t generation;		/* Used to distinguish older handlers from
-				 * recently-created ones. */
-    struct TclTimerEntry *nextPtr;/* Next and prev event in idle queue, */
-    struct TclTimerEntry *prevPtr;/* or NULL for end/start of the queue. */
-/*  ExtraData	 */
-} TclTimerEntry;
-
-/*
- * For each timer callback that's pending there is one record of the following
- * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
- * together in a list via TclTimerEntry sorted by time (earliest event first).
- */
+    int			flags;	/* Flags, OR-ed combination of flags/states
+				 * TCL_TMREV_PROMPT ... TCL_TMREV_DELETE */
 
-				 
-typedef struct TclTimerHandler {
     Tcl_WideInt		time;	/* When timer is to fire (absolute/relative). */
     Tcl_TimerToken	token;	/* Identifies handler so it can be deleted. */
-    struct TclTimerEntry	entry;
-/*  ExtraData	 */
-} TclTimerHandler;
+
+    size_t generation;		/* Used to distinguish older handlers from
+				 * recently-created ones. */
+    size_t refCount;		/* Used to preserve for deletion (nested exec
+				 * resp. prolongation). */
+    struct TclTimerEvent *nextPtr;/* Next and prev event in idle queue, */
+    struct TclTimerEvent *prevPtr;/* or NULL for end/start of the queue. */
+    /* variable ExtraData */	/* If extraDataSize supplied to create event. */
+} TclTimerEvent;
 
 /*
- * Macros to wrap ExtraData and TclTimerHandler resp. TclTimerEntry (and vice versa)
+ * Macros to wrap ExtraData and TclTimerEvent (and vice versa)
  */
-#define TclpTimerEntry2ClientData(ptr)					\
-	    ( (ClientData)(((TclTimerEntry *)(ptr))+1) )
-#define TclpClientData2TimerEntry(ptr)					\
-	    ( ((TclTimerEntry *)(ptr))-1 )
-
-#define TclpTimerEntry2TimerHandler(ptr)				\
-	    ( (TclTimerHandler *)(((char *)(ptr)) -			\
-			TclOffset(TclTimerHandler,entry)) )
-#define TclpTimerHandler2TimerEntry(ptr)				\
-	    ( &(ptr)->entry )
+#define TclpTimerEvent2ExtraData(ptr)					\
+	    ( (ClientData)(((TclTimerEvent *)(ptr))+1) )
+#define TclpExtraData2TimerEvent(ptr)					\
+	    ( ((TclTimerEvent *)(ptr))-1 )
 
 /*
  * The following procedures allow namespaces to be customized to support
@@ -1867,7 +1859,7 @@ typedef struct Interp {
 				 * reached. */
 	int timeGranularity;	/* Mod factor used to determine how often to
 				 * evaluate the limit check. */
-	TclTimerEntry *timeEvent;/* Handle for a timer callback that will occur
+	TclTimerEvent *timeEvent;/* Handle for a timer callback that will occur
 				 * when the time-limit is exceeded. */
 
 	Tcl_HashTable callbacks;/* Mapping from (interp,type) pair to data
@@ -2894,7 +2886,7 @@ MODULE_SCOPE size_t	 TclpGetLastTimeJumpEpoch(void);
 MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
 
 MODULE_SCOPE int	TclpGetUTimeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, 
-			    Tcl_WideInt *timePtr);
+			    Tcl_WideInt *timePtr, int factor);
 MODULE_SCOPE Tcl_WideInt TclpScaleUTime(Tcl_WideInt usec);
 
 MODULE_SCOPE void	TclpUSleep(Tcl_WideInt usec);
@@ -3006,21 +2998,20 @@ MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 MODULE_SCOPE void	TclSetTimerEventMarker(int head);
 MODULE_SCOPE int	TclServiceTimerEvents(void);
 MODULE_SCOPE int	TclServiceIdleEx(int flags, int count);
-MODULE_SCOPE TclTimerEntry* TclpCreateTimerHandlerEx(
-			    Tcl_WideInt usec,
-			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
+MODULE_SCOPE TclTimerEvent* TclpCreateTimerEvent(Tcl_WideInt usec,
+			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *delProc,
 			    size_t extraDataSize, int flags);
-MODULE_SCOPE Tcl_TimerToken TclCreateRelativeTimerHandler(
-			    Tcl_Time *timeOffsPtr, Tcl_TimerProc *proc,
-			    ClientData clientData);
+MODULE_SCOPE TclTimerEvent* TclpCreatePromptTimerEvent(
+			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *delProc,
+			    size_t extraDataSize, int flags);
+MODULE_SCOPE Tcl_TimerToken TclCreateTimerHandler(
+			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
+			    ClientData clientData, int flags);
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
 			    ClientData clientData);
-MODULE_SCOPE TclTimerEntry* TclpCreateTimerEntryEx(
-			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *deleteProc,
-			    size_t extraDataSize, int flags);
-MODULE_SCOPE void	TclpDeleteTimerEntry(TclTimerEntry *entryPtr);
-MODULE_SCOPE void	TclpProlongTimerHandler(TclTimerEntry *entryPtr,
+MODULE_SCOPE void	TclpDeleteTimerEvent(TclTimerEvent *tmrEvent);
+MODULE_SCOPE TclTimerEvent* TclpProlongTimerEvent(TclTimerEvent *tmrEvent,
 			    Tcl_WideInt usec, int flags);
 MODULE_SCOPE int	TclPeekEventQueued(int flags);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index 0d7086c..0c98844 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -3513,7 +3513,7 @@ TclLimitRemoveAllHandlers(
      */
 
     if (iPtr->limit.timeEvent != NULL) {
-	TclpDeleteTimerEntry(iPtr->limit.timeEvent);
+	TclpDeleteTimerEvent(iPtr->limit.timeEvent);
 	iPtr->limit.timeEvent = NULL;
     }
 }
@@ -3689,18 +3689,20 @@ TimeLimitDeleteCallback(
     ClientData clientData)
 {
     Interp *iPtr = clientData;
-
     iPtr->limit.timeEvent = NULL;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_LimitSetTime --
+ * Tcl_LimitSetTime --, TclpLimitSetTimeOffs --
  *
  *	Set the time limit for an interpreter by copying it from the value
  *	pointed to by the timeLimitPtr argument.
  *
+ *	TclpLimitSetTimeOffs opposite to Tcl_LimitSetTime set the limit as
+ *	relative time.
+ *
  * Results:
  *	None.
  *
@@ -3721,15 +3723,49 @@ Tcl_LimitSetTime(
     Tcl_WideInt nextMoment;
 
     memcpy(&iPtr->limit.time, timeLimitPtr, sizeof(Tcl_Time));
+    nextMoment = TCL_TIME_TO_USEC(*timeLimitPtr) + 10;
     if (iPtr->limit.timeEvent != NULL) {
-	TclpDeleteTimerEntry(iPtr->limit.timeEvent);
+	iPtr->limit.timeEvent = TclpProlongTimerEvent(iPtr->limit.timeEvent,
+		nextMoment, TCL_TMREV_AT);
+	if (iPtr->limit.timeEvent) {
+	    return;
+	}
     }
-    nextMoment = TCL_TIME_TO_USEC(*timeLimitPtr) + 10;
-    iPtr->limit.timeEvent = TclpCreateTimerHandlerEx(nextMoment,
-	    TimeLimitCallback, TimeLimitDeleteCallback, 0, TCL_ABSTMR_EVENT);
+    iPtr->limit.timeEvent = TclpCreateTimerEvent(nextMoment,
+	    TimeLimitCallback, TimeLimitDeleteCallback, 0, TCL_TMREV_AT);
+    iPtr->limit.timeEvent->clientData = interp;
+    iPtr->limit.exceeded &= ~TCL_LIMIT_TIME;
+}
+#if 0
+void
+TclpLimitSetTimeOffs(
+    Tcl_Interp *interp,
+    Tcl_WideInt timeOffs)
+{
+    Interp *iPtr = (Interp *) interp;
+
+    Tcl_GetTime(&iPtr->limit.time);
+    iPtr->limit.time.sec += timeOffs / 1000000;
+    iPtr->limit.time.usec += timeOffs % 1000000;
+    if (iPtr->limit.time.usec > 1000000) {
+    	iPtr->limit.time.usec -= 1000000;
+    	iPtr->limit.time.sec++;
+    }
+    timeOffs += 10;
+    /* we should use relative time (because of the timeout meaning) */
+    if (iPtr->limit.timeEvent != NULL) {
+	iPtr->limit.timeEvent = TclpProlongTimerEvent(iPtr->limit.timeEvent,
+		timeOffs, 0);
+	if (iPtr->limit.timeEvent) {
+	    return;
+	}
+    }
+    iPtr->limit.timeEvent = TclpCreateTimerEvent(timeOffs,
+	    TimeLimitCallback, TimeLimitDeleteCallback, 0, 0);
     iPtr->limit.timeEvent->clientData = interp;
     iPtr->limit.exceeded &= ~TCL_LIMIT_TIME;
 }
+#endif
 
 /*
  *----------------------------------------------------------------------
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index c4183f4..5878b39 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -65,17 +65,19 @@ typedef struct {
     Tcl_WideInt relTimerBase;	/* Time base of the first known relative */
 				/* timer, used to revert all events to the new
 				 * base after possible time-jump (adjustment).*/
-    TclTimerEntry *timerList;	/* First event in queue of timers. */
-    TclTimerEntry *timerTail;	/* Last event in queue of timers. */
-    TclTimerEntry *promptList;	/* First immediate event in queue. */
-    TclTimerEntry *promptTail;	/* Last immediate event in queue. */
+    TclTimerEvent *promptList;	/* First immediate event in queue. */
+    TclTimerEvent *promptTail;	/* Last immediate event in queue. */
+    TclTimerEvent *relTimerList;/* First event in queue of relative timers. */
+    TclTimerEvent *relTimerTail;/* Last event in queue of relative timers. */
+    TclTimerEvent *absTimerList;/* First event in queue of absolute timers. */
+    TclTimerEvent *absTimerTail;/* Last event in queue of absolute timers. */
     size_t timerListEpoch;	/* Used for safe process of event queue (stop
     				 * the cycle after modifying of event queue) */
     int lastTimerId;		/* Timer identifier of most recently created
 				 * timer event. */
     int timerPending;		/* 1 if a timer event is in the queue. */
-    TclTimerEntry *idleList;	/* First in list of all idle handlers. */
-    TclTimerEntry *idleTail;	/* Last in list (or NULL for empty list). */
+    TclTimerEvent *idleList;	/* First in list of all idle handlers. */
+    TclTimerEvent *idleTail;	/* Last in list (or NULL for empty list). */
     size_t timerGeneration;	/* Used to fill in the "generation" fields of */
     size_t idleGeneration;	/* timer or idle structures. Increments each
 				 * time we place a new handler to queue inside,
@@ -91,10 +93,10 @@ static Tcl_ThreadDataKey dataKey;
  * Helper macros to wrap AfterInfo and handlers (and vice versa)
  */
 
-#define TclpTimerEntry2AfterInfo(ptr)					\
-	    ( (AfterInfo*)TclpTimerEntry2ClientData(ptr) )
-#define TclpAfterInfo2TimerEntry(ptr)					\
-	    TclpClientData2TimerEntry(ptr)
+#define TclpTimerEvent2AfterInfo(ptr)					\
+	    ( (AfterInfo*)TclpTimerEvent2ExtraData(ptr) )
+#define TclpAfterInfo2TimerEvent(ptr)					\
+	    TclpExtraData2TimerEvent(ptr)
 
 /*
  * Prototypes for functions referenced only in this file:
@@ -254,28 +256,141 @@ InitTimer(void)
 }
 
 static void
-AttachTimerEntry(
+AttachTimerEvent(
     ThreadSpecificData *tsdPtr,
-    TclTimerEntry *entryPtr)
+    TclTimerEvent *tmrEvent)
 {
-    if (entryPtr->flags & TCL_PROMPT_EVENT) {
+    TclTimerEvent **tmrList, **tmrTail;
+
+    tmrEvent->flags |= TCL_TMREV_LISTED;
+    if (tmrEvent->flags & TCL_TMREV_PROMPT) {
 	/* use timer generation, because usually no differences between 
 	 * call of "after 0" and "after 1" */
-	entryPtr->generation = tsdPtr->timerGeneration;
+	tmrEvent->generation = tsdPtr->timerGeneration;
 	/* attach to the prompt queue */
-	TclSpliceTailEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
-	
+	TclSpliceTailEx(tmrEvent, tsdPtr->promptList, tsdPtr->promptTail);
 	/* execute immediately: signal pending and set timer marker */
 	tsdPtr->timerPending++;
 	TclSetTimerEventMarker(0);
-    } else {
+	return;
+    } 
+
+    if (tmrEvent->flags & TCL_TMREV_IDLE) {
 	/* idle generation */
-	entryPtr->generation = tsdPtr->idleGeneration;
+	tmrEvent->generation = tsdPtr->idleGeneration;
 	/* attach to the idle queue */
-	TclSpliceTailEx(entryPtr, tsdPtr->idleList, tsdPtr->idleTail);
+	TclSpliceTailEx(tmrEvent, tsdPtr->idleList, tsdPtr->idleTail);
+	return;
+    }
+
+    /* current timer generation */
+    tmrEvent->generation = tsdPtr->timerGeneration;
+
+    /*
+     * Add the event to the queue in the correct position
+     * (ordered by event firing time).
+     */
+
+    tsdPtr->timerListEpoch++; /* signal - timer list was changed */
+
+    if (!(tmrEvent->flags & TCL_TMREV_AT)) {
+	tmrList = &tsdPtr->relTimerList;
+	tmrTail = &tsdPtr->relTimerTail;
+    } else {
+	tmrList = &tsdPtr->absTimerList;
+	tmrTail = &tsdPtr->absTimerTail;
+    }
+    /* if before current first (e. g. "after 1" before first "after 1000") */
+    if ( !(*tmrList) || tmrEvent->time < (*tmrList)->time) {
+    	/* splice to the head */
+	TclSpliceInEx(tmrEvent, *tmrList, *tmrTail);
+    } else {
+    	TclTimerEvent *tmrEventPos;
+	Tcl_WideInt usec = tmrEvent->time;
+	/* search from end as long as one with time before not found */
+	for (tmrEventPos = *tmrTail; tmrEventPos != NULL;
+	    tmrEventPos = tmrEventPos->prevPtr) {
+	    if (usec >= tmrEventPos->time) {
+		break;
+	    }
+	}
+	/* normally it should be always true, because checked above, but ... */
+	if (tmrEventPos != NULL) {
+	    /* insert after found element (with time before new) */
+	    tmrEvent->prevPtr = tmrEventPos;
+	    if ((tmrEvent->nextPtr = tmrEventPos->nextPtr)) {
+		tmrEventPos->nextPtr->prevPtr = tmrEvent;
+	    } else {
+		*tmrTail = tmrEvent;
+	    }
+	    tmrEventPos->nextPtr = tmrEvent;
+	} else {
+	    /* unexpected case, but ... splice to the head */
+	    TclSpliceInEx(tmrEvent, *tmrList, *tmrTail);
+	}
+    }
+}
+
+static void
+DetachTimerEvent(
+    ThreadSpecificData *tsdPtr,
+    TclTimerEvent *tmrEvent)
+{
+    tmrEvent->flags &= ~TCL_TMREV_LISTED;
+    if (tmrEvent->flags & TCL_TMREV_PROMPT) {
+	/* prompt handler */
+	TclSpliceOutEx(tmrEvent, tsdPtr->promptList, tsdPtr->promptTail);
+	return;
+    } 
+    if (tmrEvent->flags & TCL_TMREV_IDLE) {
+	/* idle handler */
+	TclSpliceOutEx(tmrEvent, tsdPtr->idleList, tsdPtr->idleTail);
+	return;
+    }
+    /* timer event-handler */
+    tsdPtr->timerListEpoch++; /* signal - timer list was changed */
+    if (!(tmrEvent->flags & TCL_TMREV_AT)) {
+	TclSpliceOutEx(tmrEvent, tsdPtr->relTimerList, tsdPtr->relTimerTail);
+    } else {
+    	TclSpliceOutEx(tmrEvent, tsdPtr->absTimerList, tsdPtr->absTimerTail);
     }
 }
 
+static Tcl_WideInt
+TimerMakeRelativeTime(
+    ThreadSpecificData *tsdPtr,
+    Tcl_WideInt usec)
+{
+    Tcl_WideInt now = TclpGetMicroseconds();
+
+    /* 
+     * We should have the ability to ajust end-time of relative events,
+     * for possible time-jumps.
+     */
+    if (tsdPtr->relTimerList) {
+	/* 
+	 * end-time = now + usec
+	 * Adjust value of usec relative current base (to now), so
+	 * end-time = base + relative event-time, which corresponds 
+	 * original end-time.
+	 */
+	Tcl_WideInt diff;
+	if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
+	  || (diff = (tsdPtr->knownTime - now)) < 0
+	) { /* jump recognized */
+	    tsdPtr->relTimerBase += diff; /* shift the base of relative events */
+	}
+	usec += now - tsdPtr->relTimerBase;
+    } else {
+	/* first event here - initial values (base/epoch) */
+	tsdPtr->relTimerBase = now;
+	tsdPtr->knownTimeJumpEpoch = TclpGetLastTimeJumpEpoch();
+    }
+    tsdPtr->knownTime = now;
+
+    return usec;
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -304,13 +419,16 @@ TimerExitProc(
 	Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, tsdPtr);
 
 	while ((tsdPtr->promptTail) != NULL) {
-	    TclpDeleteTimerEntry(tsdPtr->promptTail);
+	    TclpDeleteTimerEvent(tsdPtr->promptTail);
+	}
+	while ((tsdPtr->relTimerTail) != NULL) {
+	    TclpDeleteTimerEvent(tsdPtr->relTimerTail);
 	}
-	while ((tsdPtr->timerTail) != NULL) {
-	    TclpDeleteTimerEntry(tsdPtr->timerTail);
+	while ((tsdPtr->absTimerTail) != NULL) {
+	    TclpDeleteTimerEvent(tsdPtr->absTimerTail);
 	}
 	while ((tsdPtr->idleTail) != NULL) {
-	    TclpDeleteTimerEntry(tsdPtr->idleTail);
+	    TclpDeleteTimerEvent(tsdPtr->idleTail);
 	}
     }
 }
@@ -340,7 +458,7 @@ Tcl_CreateTimerHandler(
     Tcl_TimerProc *proc,	/* Function to invoke. */
     ClientData clientData)	/* Arbitrary data to pass to proc. */
 {
-    register TclTimerEntry *entryPtr;
+    register TclTimerEvent *tmrEvent;
     Tcl_WideInt usec;
 
     /*
@@ -353,19 +471,19 @@ Tcl_CreateTimerHandler(
 	usec = 0x7FFFFFFFFFFFFFFFL;
     }
 
-    entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, 0);
-    if (entryPtr == NULL) {
+    tmrEvent = TclpCreateTimerEvent(usec, proc, NULL, 0, 0);
+    if (tmrEvent == NULL) {
 	return NULL;
     }
-    entryPtr->clientData = clientData;
+    tmrEvent->clientData = clientData;
 
-    return TclpTimerEntry2TimerHandler(entryPtr)->token;
+    return tmrEvent->token;
 }
 
 /*
  *--------------------------------------------------------------
  *
- * TclpCreateTimerHandlerEx --
+ * TclpCreateTimerEvent --
  *
  *	Arrange for a given function to be invoked at or in a particular time
  *	in the future (microseconds).
@@ -381,108 +499,111 @@ Tcl_CreateTimerHandler(
  *--------------------------------------------------------------
  */
 
-TclTimerEntry*
-TclpCreateTimerHandlerEx(
+TclTimerEvent*
+TclpCreateTimerEvent(
     Tcl_WideInt usec,		/* Time to be invoked (absolute/relative) */
     Tcl_TimerProc *proc,	/* Function to invoke */
     Tcl_TimerDeleteProc *deleteProc,/* Function to cleanup */
     size_t extraDataSize,	/* Size of extra data to allocate */
-    int flags)			/* If TCL_ABSTMR_EVENT, time is absolute */
+    int flags)			/* Flags corresponding type of event */
 {
-    register TclTimerEntry *entryPtr, *entryPtrPos;
-    register TclTimerHandler *timerPtr;
+    register TclTimerEvent *tmrEvent;
     ThreadSpecificData *tsdPtr;
 
     tsdPtr = InitTimer();
-    timerPtr = (TclTimerHandler *)ckalloc(
-			sizeof(TclTimerHandler) + extraDataSize);
-    if (timerPtr == NULL) {
+    tmrEvent = (TclTimerEvent *)ckalloc(
+			sizeof(TclTimerEvent) + extraDataSize);
+    if (tmrEvent == NULL) {
 	return NULL;
     }
-    entryPtr = TclpTimerHandler2TimerEntry(timerPtr);
 
+    if (usec <= 0 && !(flags & (TCL_TMREV_AT|TCL_TMREV_PROMPT|TCL_TMREV_IDLE))) {
+    	usec = 0;
+    	flags |= TCL_TMREV_PROMPT;
+    }
+    
     /*
      * Fill in fields for the event.
      */
 
-    entryPtr->proc = proc;
-    entryPtr->deleteProc = deleteProc;
-    entryPtr->clientData = TclpTimerEntry2ClientData(entryPtr);
-    entryPtr->flags = flags & TCL_ABSTMR_EVENT;
-    entryPtr->generation = tsdPtr->timerGeneration;
-    tsdPtr->timerListEpoch++; /* signal-timer list was changed */
+    tmrEvent->proc = proc;
+    tmrEvent->deleteProc = deleteProc;
+    tmrEvent->clientData = TclpTimerEvent2ExtraData(tmrEvent);
+    tmrEvent->flags = flags & (TCL_TMREV_AT|TCL_TMREV_PROMPT|TCL_TMREV_IDLE);
     tsdPtr->lastTimerId++;
-    timerPtr->token = (Tcl_TimerToken) INT2PTR(tsdPtr->lastTimerId);
+    tmrEvent->token = (Tcl_TimerToken) INT2PTR(tsdPtr->lastTimerId);
 
-    if (!(flags & TCL_ABSTMR_EVENT)) {
-	Tcl_WideInt now = TclpGetMicroseconds();
-
-	/* 
-	 * We should have the ability to ajust end-time of relative events,
-	 * for possible time-jumps.
-	 */
-	if (tsdPtr->timerList) {
-	    /* 
-	     * end-time = now + usec
-	     * Adjust value of usec relative current base (to now), so
-	     * end-time = base + relative event-time, which corresponds 
-	     * original end-time.
-	     */
-	    Tcl_WideInt diff;
-	    if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
-	      || (diff = (tsdPtr->knownTime - now)) < 0
-	    ) { /* jump recognized */
-		tsdPtr->relTimerBase += diff; /* shift the base of relative events */
-    	    }
-	    usec += now - tsdPtr->relTimerBase;
-	} else {
-	    /* first event here - initial values (base/epoch) */
-	    tsdPtr->relTimerBase = now;
-	    tsdPtr->knownTimeJumpEpoch = TclpGetLastTimeJumpEpoch();
-	}
-	tsdPtr->knownTime = now;
+    /* 
+     * If TCL_TMREV_AT (and TCL_TMREV_PROMPT) are not specified, event observes
+     * due-time considering possible time-jump.
+     */
+    if (!(flags & (TCL_TMREV_AT|TCL_TMREV_PROMPT|TCL_TMREV_IDLE))) {
+	/* relative event - realign time using current relative base */
+	usec = TimerMakeRelativeTime(tsdPtr, usec);
     }
 
-    timerPtr->time = usec;
+    tmrEvent->time = usec;
+    tmrEvent->refCount = 0;
 
     /*
-     * Add the event to the queue in the correct position
-     * (ordered by event firing time).
+     * Attach the event to the corresponding queue in the correct position
+     * (ordered by event firing time, if time specified).
      */
 
-    /* if before current first (e. g. "after 1" before first "after 1000") */
-    if ( !(entryPtrPos = tsdPtr->timerList)
-      || usec < TclpTimerEntry2TimerHandler(entryPtrPos)->time
-    ) {
-    	/* splice to the head */
-	TclSpliceInEx(entryPtr, tsdPtr->timerList, tsdPtr->timerTail);
-    } else {
-    	/* search from end as long as one with time before not found */
-	for (entryPtrPos = tsdPtr->timerTail; entryPtrPos != NULL;
-	    entryPtrPos = entryPtrPos->prevPtr) {
-	    if (usec >= TclpTimerEntry2TimerHandler(entryPtrPos)->time) {
-		break;
-	    }
-	}
-	/* normally it should be always true, because checked above, but ... */
-	if (entryPtrPos != NULL) {
-	    /* insert after found element (with time before new) */
-	    entryPtr->prevPtr = entryPtrPos;
-	    if ((entryPtr->nextPtr = entryPtrPos->nextPtr)) {
-		entryPtrPos->nextPtr->prevPtr = entryPtr;
-	    } else {
-		tsdPtr->timerTail = entryPtr;
-	    }
-	    entryPtrPos->nextPtr = entryPtr;
-	} else {
-	    /* unexpected case, but ... splice to the head */
-	    TclSpliceInEx(entryPtr, tsdPtr->timerList, tsdPtr->timerTail);
-	}
-    }
+    AttachTimerEvent(tsdPtr, tmrEvent);
 
-    return entryPtr;
+    return tmrEvent;
 }
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TclpCreatePromptTimerEvent --
+ *
+ *	Arrange for proc to be invoked delayed (but prompt) as timer event,
+ *	without time ("after 0").
+ *	Or as idle event (the next time the system is idle i.e., just 
+ *	before the next time that Tcl_DoOneEvent would have to wait for
+ *	something to happen).
+ *
+ *	Providing the flag TCL_TMREV_PROMPT ensures that timer event-handler
+ *	will be queued immediately to guarantee the execution of timer-event
+ *	as soon as possible
+ *
+ * Results:
+ *	Returns the created timer entry.
+ *
+ * Side effects:
+ *	None.
+ *
+ *--------------------------------------------------------------
+ */
 
+TclTimerEvent *
+TclpCreatePromptTimerEvent(
+    Tcl_TimerProc *proc,		/* Function to invoke. */
+    Tcl_TimerDeleteProc *deleteProc,	/* Function to cleanup */
+    size_t extraDataSize,
+    int flags)
+{
+    register TclTimerEvent *tmrEvent;
+    ThreadSpecificData *tsdPtr = InitTimer();
+
+    tmrEvent = (TclTimerEvent *) ckalloc(sizeof(TclTimerEvent) + extraDataSize);
+    if (tmrEvent == NULL) {
+	return NULL;
+    }
+    tmrEvent->proc = proc;
+    tmrEvent->deleteProc = deleteProc;
+    tmrEvent->clientData = TclpTimerEvent2ExtraData(tmrEvent);
+    tmrEvent->flags = flags;
+    tmrEvent->time = 0;
+    tmrEvent->refCount = 0;
+
+    AttachTimerEvent(tsdPtr, tmrEvent);
+
+    return tmrEvent;
+}
 
 /*
  *--------------------------------------------------------------
@@ -490,7 +611,7 @@ TclpCreateTimerHandlerEx(
  * TclCreateAbsoluteTimerHandler --
  *
  *	Arrange for a given function to be invoked at a particular time in the
- *	future.
+ *	future (absolute time).
  *
  * Results:
  *	The return value is a token of the timer event, which
@@ -509,7 +630,7 @@ TclCreateAbsoluteTimerHandler(
     Tcl_TimerProc *proc,
     ClientData clientData)
 {
-    register TclTimerEntry *entryPtr;
+    register TclTimerEvent *tmrEvent;
     Tcl_WideInt usec;
 
     /*
@@ -522,13 +643,13 @@ TclCreateAbsoluteTimerHandler(
 	usec = 0x7FFFFFFFFFFFFFFFL;
     }
 
-    entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, TCL_ABSTMR_EVENT);
-    if (entryPtr == NULL) {
+    tmrEvent = TclpCreateTimerEvent(usec, proc, NULL, 0, TCL_TMREV_AT);
+    if (tmrEvent == NULL) {
 	return NULL;
     }
-    entryPtr->clientData = clientData;
+    tmrEvent->clientData = clientData;
 
-    return TclpTimerEntry2TimerHandler(entryPtr)->token;
+    return tmrEvent->token;
 }
 
 /*
@@ -550,12 +671,13 @@ TclCreateAbsoluteTimerHandler(
  */
 
 Tcl_TimerToken
-TclCreateRelativeTimerHandler(
+TclCreateTimerHandler(
     Tcl_Time *timePtr,
     Tcl_TimerProc *proc,
-    ClientData clientData)
+    ClientData clientData,
+    int flags)
 {
-    register TclTimerEntry *entryPtr;
+    register TclTimerEvent *tmrEvent;
     Tcl_WideInt usec;
 
     /*
@@ -568,13 +690,13 @@ TclCreateRelativeTimerHandler(
 	usec = 0x7FFFFFFFFFFFFFFFL;
     }
 
-    entryPtr = TclpCreateTimerHandlerEx(usec, proc, NULL, 0, TCL_ABSTMR_EVENT);
-    if (entryPtr == NULL) {
+    tmrEvent = TclpCreateTimerEvent(usec, proc, NULL, 0, flags);
+    if (tmrEvent == NULL) {
 	return NULL;
     }
-    entryPtr->clientData = clientData;
+    tmrEvent->clientData = clientData;
 
-    return TclpTimerEntry2TimerHandler(entryPtr)->token;
+    return tmrEvent->token;
 }
 
 /*
@@ -600,22 +722,34 @@ Tcl_DeleteTimerHandler(
     Tcl_TimerToken token)	/* Result previously returned by
 				 * Tcl_CreateTimerHandler. */
 {
-    register TclTimerEntry *entryPtr;
+    register TclTimerEvent *tmrEvent;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     if (token == NULL) {
 	return;
     }
 
-    for (entryPtr = tsdPtr->timerTail;
-	entryPtr != NULL;
-	entryPtr = entryPtr->prevPtr
+    for (tmrEvent = tsdPtr->relTimerTail;
+	tmrEvent != NULL;
+	tmrEvent = tmrEvent->prevPtr
+    ) {
+	if (tmrEvent->token != token) {
+	    continue;
+	}
+
+	TclpDeleteTimerEvent(tmrEvent);
+	return;
+    }
+
+    for (tmrEvent = tsdPtr->absTimerTail;
+	tmrEvent != NULL;
+	tmrEvent = tmrEvent->prevPtr
     ) {
-	if (TclpTimerEntry2TimerHandler(entryPtr)->token != token) {
+	if (tmrEvent->token != token) {
 	    continue;
 	}
 
-	TclpDeleteTimerEntry(entryPtr);
+	TclpDeleteTimerEvent(tmrEvent);
 	return;
     }
 }
@@ -624,7 +758,7 @@ Tcl_DeleteTimerHandler(
 /*
  *--------------------------------------------------------------
  *
- * TclpDeleteTimerEntry --
+ * TclpDeleteTimerEvent --
  *
  *	Delete a previously-registered prompt, timer or idle handler.
  *
@@ -640,74 +774,75 @@ Tcl_DeleteTimerHandler(
  */
 
 void
-TclpDeleteTimerEntry(
-    TclTimerEntry *entryPtr)	/* Result previously returned by */
-	/* TclpCreateTimerHandlerEx or TclpCreateTimerEntryEx. */
+TclpDeleteTimerEvent(
+    TclTimerEvent *tmrEvent)	/* Result previously returned by */
+	/* TclpCreateTimerEvent or derivatives. */
 {
     ThreadSpecificData *tsdPtr;
 
-    if (entryPtr == NULL) {
-	return;
-    }
-    if (entryPtr->flags & (TCL_EVENTST_EXECUTE|TCL_EVENTST_DELETE)) {
-	/* do nothing - event will be automatically deleted hereafter */
+    if (tmrEvent == NULL) {
 	return;
     }
 
     tsdPtr = InitTimer();
 
-    /* 
-     * Mark this entry will be deleted, so it can avoid double delete and
-     * caller can check in delete callback, the time entry handle is still
-     * the same (was not overriden in some recursive async-envent).
-     */
-    entryPtr->flags |= TCL_EVENTST_DELETE;
-    if (entryPtr->flags & TCL_PROMPT_EVENT) {
-	/* prompt handler */
-	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
-    } else if (entryPtr->flags & TCL_IDLE_EVENT) {
-	/* idle handler */
-	TclSpliceOutEx(entryPtr, tsdPtr->idleList, tsdPtr->idleTail);
-    } else {
-	/* timer event-handler */
-	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
-	TclSpliceOutEx(entryPtr, tsdPtr->timerList, tsdPtr->timerTail);
-    }
-
-    /* free it via deleteProc or ckfree */
-    if (entryPtr->deleteProc) {
-    	entryPtr->flags |= TCL_EVENTST_DELETE;
-	(*entryPtr->deleteProc)(entryPtr->clientData);
-	/* if prolongation requested - reattached to tail */
-	if (!(entryPtr->flags & TCL_EVENTST_DELETE)) {
-	    return;
-	}
+    /* detach from list */
+    if (tmrEvent->flags & TCL_TMREV_LISTED) {
+	DetachTimerEvent(tsdPtr, tmrEvent);
     }
 
-    if (entryPtr->flags & (TCL_PROMPT_EVENT|TCL_IDLE_EVENT)) {
-	ckfree((char *)entryPtr);
-    } else {
-	/* shift to the allocated pointer */
-	ckfree((char *)TclpTimerEntry2TimerHandler(entryPtr));
+    /* free it via deleteProc and ckfree */
+    if (tmrEvent->deleteProc && !(tmrEvent->flags & TCL_TMREV_DELETE)) {
+	/* 
+	 * Mark this entry will be deleted, so it can avoid double delete and
+	 * caller can check in delete callback, the time entry handle is still
+	 * the same (was not overriden in some recursive async-envent).
+	 */
+    	tmrEvent->flags |= TCL_TMREV_DELETE;
+	(*tmrEvent->deleteProc)(tmrEvent->clientData);
     }
+
+    /* if frozen somewhere (nested service cycle) */
+    if (tmrEvent->refCount > 0) {
+	/* do nothing - event will be automatically deleted hereafter */
+	return;
+    }
+
+    ckfree((char *)tmrEvent);
 }
 
-void
-TclpProlongTimerHandler(
-    TclTimerEntry *entryPtr,
+TclTimerEvent *
+TclpProlongTimerEvent(
+    TclTimerEvent *tmrEvent,
     Tcl_WideInt usec,
     int flags)
 {
+#if 0
+    return NULL;
+#else
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    /* reset execution and deletion states */
-    entryPtr->flags &= ~(TCL_EVENTST_EXECUTE|TCL_EVENTST_DELETE);
-    /* attach to the queue again (new generation) */
-    if (usec != 0 || flags != 0) {
-	Tcl_Panic("NYI: ATM only prompt & idle");
-	return;
+    if (tmrEvent->flags & TCL_TMREV_DELETE) {
+	return NULL;
+    }
+    /* if still belong to the queue, detach it from corresponding list */
+    if (tmrEvent->flags & TCL_TMREV_LISTED) {
+	DetachTimerEvent(tsdPtr, tmrEvent);
+    }
+    /* set wanted flags and prolong */
+    tmrEvent->flags |= (flags & (TCL_TMREV_AT|TCL_TMREV_PROMPT|TCL_TMREV_IDLE));
+    /* new firing time */
+    if (!(flags & (TCL_TMREV_PROMPT|TCL_TMREV_IDLE))) {
+	/* if relative event - realign time using current relative base */
+	if (!(flags & TCL_TMREV_AT)) {
+	    usec = TimerMakeRelativeTime(tsdPtr, usec);
+	}
+	tmrEvent->time = usec;
     }
-    AttachTimerEntry(tsdPtr, entryPtr);
+    /* attach to the queue again (new generation) */
+    AttachTimerEvent(tsdPtr, tmrEvent);
+    return tmrEvent;
+#endif
 }
 
 /*
@@ -731,11 +866,9 @@ TclpProlongTimerHandler(
 static Tcl_WideInt
 TimerGetDueTime(
     ThreadSpecificData *tsdPtr,
-    TclTimerEntry *entryPtr,
+    TclTimerEvent *relEvent,
     Tcl_WideInt now)
 {
-    Tcl_WideInt firstTime;
-
     /* 
      * Consider time-jump (especially back) - if the time jumped forwards (and
      * it recognized) the base can be shifted, but not badly needed, because
@@ -756,13 +889,8 @@ TimerGetDueTime(
     }
     tsdPtr->knownTime = now;
 
-    /* If absolute timer: end-time = absolute event-time */
-    firstTime = TclpTimerEntry2TimerHandler(entryPtr)->time;
-    if ((entryPtr->flags & TCL_ABSTMR_EVENT)) {
-    	return firstTime;
-    }
     /* end-time = base + relative event-time */
-    return firstTime + tsdPtr->relTimerBase;
+    return tsdPtr->relTimerBase + relEvent->time;
 }
 
 /*
@@ -805,16 +933,25 @@ TimerSetupProc(
 
     } else if (
 	   (flags & TCL_TIMER_EVENTS) 
-	&& (tsdPtr->timerList)
+	&& (tsdPtr->relTimerList || tsdPtr->absTimerList)
     ) {
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
 
 	Tcl_WideInt now = TclpGetMicroseconds();
-	Tcl_WideInt entryTime;
+	Tcl_WideInt entryTime = 0x7FFFFFFFFFFFFFFFL;
 
-	entryTime = TimerGetDueTime(tsdPtr, tsdPtr->timerList, now) - now;
+	if (tsdPtr->relTimerList) {
+	    entryTime = TimerGetDueTime(tsdPtr,
+	    	tsdPtr->relTimerList, now);
+	}
+	/* if absolute timer before */
+	if (tsdPtr->absTimerList && tsdPtr->absTimerList->time < entryTime) {
+	    entryTime = tsdPtr->absTimerList->time;
+	}
+	/* as offset to now */
+	entryTime -= now;
 
 	#ifdef TMR_RES_TOLERANCE
 	    /* consider timer resolution tolerance (avoid busy wait) */
@@ -868,7 +1005,7 @@ TimerCheckProc(
     ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_WideInt now, entryTime;
+    Tcl_WideInt now, entryTime = 0x7FFFFFFFFFFFFFFFL;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
 
     if (!(flags & TCL_TIMER_EVENTS)) {
@@ -878,7 +1015,7 @@ TimerCheckProc(
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
     /* If already pending (or no timer-events) */
-    if (tsdPtr->timerPending || !tsdPtr->timerList) {
+    if (tsdPtr->timerPending || !tsdPtr->relTimerList) {
     	return;
     }
 
@@ -886,7 +1023,16 @@ TimerCheckProc(
      * Verify the first timer on the queue.
      */
     now = TclpGetMicroseconds();
-    entryTime = TimerGetDueTime(tsdPtr, tsdPtr->timerList, now) - now;
+    if (tsdPtr->relTimerList) {
+	entryTime = TimerGetDueTime(tsdPtr,
+	tsdPtr->relTimerList, now);
+    }
+    /* if absolute timer before */
+    if (tsdPtr->absTimerList && tsdPtr->absTimerList->time < entryTime) {
+	entryTime = tsdPtr->absTimerList->time;
+    }
+    /* as offset to now */
+    entryTime -= now;
     
 #ifdef TMR_RES_TOLERANCE
     /* consider timer resolution tolerance (avoid busy wait) */
@@ -928,8 +1074,7 @@ TimerCheckProc(
 int
 TclServiceTimerEvents(void)
 {
-    TclTimerEntry *entryPtr, *nextPtr;
-    Tcl_WideInt now, entryTime;
+    TclTimerEvent *tmrEvent, *relTimerList, *absTimerList;
     size_t currentGeneration, currentEpoch;
     int prevTmrPending;
     ThreadSpecificData *tsdPtr = InitTimer();
@@ -964,34 +1109,30 @@ TclServiceTimerEvents(void)
     currentGeneration = tsdPtr->timerGeneration++;
 
     /* First process all prompt (immediate) events */
-    while ((entryPtr = tsdPtr->promptList) != NULL
-	&& entryPtr->generation <= currentGeneration
+    while ((tmrEvent = tsdPtr->promptList) != NULL
+	&& tmrEvent->generation <= currentGeneration
     ) {
-	/* detach entry from the owner's list */
-	TclSpliceOutEx(entryPtr, tsdPtr->promptList, tsdPtr->promptTail);
-
+	/* freeze / detach entry from the owner's list */
+	tmrEvent->refCount++;
+	tmrEvent->flags &= ~TCL_TMREV_LISTED;
+	TclSpliceOutEx(tmrEvent, tsdPtr->promptList, tsdPtr->promptTail);
 	/* reset current timer pending (correct process nested wait event) */
 	prevTmrPending = tsdPtr->timerPending;
 	tsdPtr->timerPending = 0;
 	/* execute event */
-	entryPtr->flags |= TCL_EVENTST_EXECUTE;
-	(*entryPtr->proc)(entryPtr->clientData);
+	(*tmrEvent->proc)(tmrEvent->clientData);
 	/* restore current timer pending */
 	tsdPtr->timerPending += prevTmrPending;
-	/* if prolongation requested - reattached to tail */
-	if (!(entryPtr->flags & TCL_EVENTST_EXECUTE)) {
+	/* unfreeze / if used somewhere else (nested) or prolongation (reattached) */
+	if (tmrEvent->refCount-- > 1 || (tmrEvent->flags & TCL_TMREV_LISTED)) {
 	    continue;
-	}
+	};
 	/* free it via deleteProc and ckfree */
-	if (entryPtr->deleteProc) {
-	    entryPtr->flags |= TCL_EVENTST_DELETE;
-	    (*entryPtr->deleteProc)(entryPtr->clientData);
-	    /* if prolongation requested - reattached to tail */
-	    if (!(entryPtr->flags & TCL_EVENTST_DELETE)) {
-	        continue;
-	    }
+	if (tmrEvent->deleteProc && !(tmrEvent->flags & TCL_TMREV_DELETE)) {
+	    tmrEvent->flags |= TCL_TMREV_DELETE;
+	    (*tmrEvent->deleteProc)(tmrEvent->clientData);
 	}
-	ckfree((char *) entryPtr);
+	ckfree((char *) tmrEvent);
     }
 
     /* if stil pending prompt events (new generation) - repeat event cycle as 
@@ -1002,61 +1143,84 @@ TclServiceTimerEvents(void)
     }
 
     /* Hereafter all relative and absolute timer events with time before now */
-    for (entryPtr = tsdPtr->timerList;
-	 entryPtr != NULL;
-	 entryPtr = nextPtr
-    ) {
-	nextPtr = entryPtr->nextPtr;
-	now = TclpGetMicroseconds();
-	entryTime = TimerGetDueTime(tsdPtr, entryPtr, now);
-
+    relTimerList = tsdPtr->relTimerList;
+    absTimerList = tsdPtr->absTimerList;
+    while (relTimerList || absTimerList) {
+    	Tcl_WideInt entryTime = 0x7FFFFFFFFFFFFFFFL;
+	Tcl_WideInt now = TclpGetMicroseconds();
+	/* find shortest due-time */
+	if ((tmrEvent = relTimerList) != NULL) {
+	    entryTime = TimerGetDueTime(tsdPtr, tmrEvent, now);
+	}
+	if (absTimerList && (!tmrEvent || absTimerList->time < entryTime)) {
+	    tmrEvent = absTimerList;
+	    entryTime = absTimerList->time;
+	}
+	/* offset to now */
+	entryTime -= now;
     	/* the same tolerance logic as in TimerSetupProc/TimerCheckProc */
     #ifdef TMR_RES_TOLERANCE
 	entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
 				TMR_RES_TOLERANCE / 100;
     #endif
-
-	if (now < entryTime) {
+	/* still not reached */
+	if (entryTime > 0) {
 	    break;
 	}
 
+	/* for the next iteration */
+	if (tmrEvent == relTimerList) {
+	    relTimerList = tmrEvent->nextPtr;
+	} else {
+	    absTimerList = tmrEvent->nextPtr;
+	}
+
 	/*
 	 * Bypass timers of newer generation.
 	 */
 
-	if (entryPtr->generation > currentGeneration) {
+	if (tmrEvent->generation > currentGeneration) {
 	    /* increase pending to signal repeat */
 	    tsdPtr->timerPending++;
 	    continue;
 	}
 
-	tsdPtr->timerListEpoch++; /* signal-timer list was changed */
-	currentEpoch = tsdPtr->timerListEpoch;
+	tsdPtr->timerListEpoch++; /* signal - timer list was changed */
+	currentEpoch = tsdPtr->timerListEpoch; /* save it to compare */
 	 
 	/*
 	 * Remove the handler from the queue before invoking it, to avoid
 	 * potential reentrancy problems.
 	 */
-	TclSpliceOutEx(entryPtr, 
-		tsdPtr->timerList, tsdPtr->timerTail);
+	tmrEvent->refCount++; /* freeze */
+	tmrEvent->flags &= ~TCL_TMREV_LISTED;
+	if (!(tmrEvent->flags & TCL_TMREV_AT)) {
+	    TclSpliceOutEx(tmrEvent,
+		tsdPtr->relTimerList, tsdPtr->relTimerTail);
+	} else {
+	    TclSpliceOutEx(tmrEvent,
+		tsdPtr->absTimerList, tsdPtr->absTimerTail);
+	}
 
 	/* reset current timer pending (correct process nested wait event) */
 	prevTmrPending = tsdPtr->timerPending;
 	tsdPtr->timerPending = 0;
 	/* invoke timer proc */
-	entryPtr->flags |= TCL_EVENTST_EXECUTE;
-	(*entryPtr->proc)(entryPtr->clientData);
+	(*tmrEvent->proc)(tmrEvent->clientData);
 	/* restore current timer pending */
 	tsdPtr->timerPending += prevTmrPending;
-
-	/* free it via deleteProc or ckfree */
-	if (entryPtr->deleteProc) {
-	    entryPtr->flags |= TCL_EVENTST_DELETE;
-	    (*entryPtr->deleteProc)(entryPtr->clientData);
+	/* unfreeze / if used somewhere else (nested) or prolongation (reattached) */
+	if (tmrEvent->refCount-- > 1 || (tmrEvent->flags & TCL_TMREV_LISTED)) {
+	    goto nextEvent;
+	};
+	/* free it via deleteProc and ckfree */
+	if (tmrEvent->deleteProc && !(tmrEvent->flags & TCL_TMREV_DELETE)) {
+	    tmrEvent->flags |= TCL_TMREV_DELETE;
+	    (*tmrEvent->deleteProc)(tmrEvent->clientData);
 	}
-
-	ckfree((char *) TclpTimerEntry2TimerHandler(entryPtr));
-
+	ckfree((char *) tmrEvent);
+    
+    nextEvent:
 	/* be sure that timer-list was not changed inside the proc call */
 	if (currentEpoch != tsdPtr->timerListEpoch) {
 	    /* timer-list was changed - stop processing */
@@ -1072,7 +1236,7 @@ TclServiceTimerEvents(void)
     }
 
     /* Reset generation if both timer queue are empty */
-    if (!tsdPtr->timerList) {
+    if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
 	tsdPtr->timerGeneration = 0;
     }
 
@@ -1085,54 +1249,6 @@ TclServiceTimerEvents(void)
 /*
  *--------------------------------------------------------------
  *
- * TclpCreateTimerEntryEx --
- *
- *	Arrange for proc to be invoked delayed (but prompt) as timer event,
- *	without time ("after 0").
- *	Or as idle event (the next time the system is idle i.e., just 
- *	before the next time that Tcl_DoOneEvent would have to wait for
- *	something to happen).
- *
- *	Providing the flag TCL_PROMPT_EVENT ensures that timer event-handler
- *	will be queued immediately to guarantee the execution of timer-event
- *	as soon as possible
- *
- * Results:
- *	Returns the created timer entry.
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-
-TclTimerEntry *
-TclpCreateTimerEntryEx(
-    Tcl_TimerProc *proc,		/* Function to invoke. */
-    Tcl_TimerDeleteProc *deleteProc,	/* Function to cleanup */
-    size_t extraDataSize,
-    int flags)
-{
-    register TclTimerEntry *entryPtr;
-    ThreadSpecificData *tsdPtr = InitTimer();
-
-    entryPtr = (TclTimerEntry *) ckalloc(sizeof(TclTimerEntry) + extraDataSize);
-    if (entryPtr == NULL) {
-	return NULL;
-    }
-    entryPtr->proc = proc;
-    entryPtr->deleteProc = deleteProc;
-    entryPtr->clientData = TclpTimerEntry2ClientData(entryPtr);
-    entryPtr->flags = flags;
-
-    AttachTimerEntry(tsdPtr, entryPtr);
-
-    return entryPtr;
-}
-
-/*
- *--------------------------------------------------------------
- *
  * Tcl_DoWhenIdle --
  *
  *	Arrange for proc to be invoked the next time the system is idle (i.e.,
@@ -1153,7 +1269,7 @@ Tcl_DoWhenIdle(
     Tcl_IdleProc *proc,		/* Function to invoke. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    TclTimerEntry *idlePtr = TclpCreateTimerEntryEx(proc, NULL, 0, TCL_IDLE_EVENT);
+    TclTimerEvent *idlePtr = TclpCreatePromptTimerEvent(proc, NULL, 0, TCL_TMREV_IDLE);
 
     if (idlePtr) {
     	idlePtr->clientData = clientData;
@@ -1183,7 +1299,7 @@ Tcl_CancelIdleCall(
     Tcl_IdleProc *proc,		/* Function that was previously registered. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    register TclTimerEntry *idlePtr, *nextPtr;
+    register TclTimerEvent *idlePtr, *nextPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     for (idlePtr = tsdPtr->idleList;
@@ -1194,11 +1310,12 @@ Tcl_CancelIdleCall(
 	if ((idlePtr->proc == proc)
 		&& (idlePtr->clientData == clientData)) {
 	    /* detach entry from the owner list */
+	    idlePtr->flags &= ~TCL_TMREV_LISTED;
 	    TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->idleTail);
 
 	    /* free it via deleteProc and ckfree */
-	    if (idlePtr->deleteProc) {
-	    	idlePtr->flags |= TCL_EVENTST_DELETE;
+	    if (idlePtr->deleteProc && !(idlePtr->flags & TCL_TMREV_DELETE)) {
+		idlePtr->flags |= TCL_TMREV_DELETE;
 		(*idlePtr->deleteProc)(idlePtr->clientData);
 	    }
 	    ckfree((char *) idlePtr);
@@ -1230,7 +1347,7 @@ TclServiceIdleEx(
     int flags,
     int count)
 {
-    TclTimerEntry *idlePtr;
+    TclTimerEvent *idlePtr;
     size_t currentGeneration;
     ThreadSpecificData *tsdPtr = InitTimer();
 
@@ -1258,24 +1375,21 @@ TclServiceIdleEx(
      */
 
     while (idlePtr->generation <= currentGeneration) {
-	/* detach entry from the owner's list */
+	/* freeze / detach entry from the owner's list */
+	idlePtr->refCount++;
+	idlePtr->flags &= ~TCL_TMREV_LISTED;
 	TclSpliceOutEx(idlePtr, tsdPtr->idleList, tsdPtr->idleTail);
 
 	/* execute event */
-	idlePtr->flags |= TCL_EVENTST_EXECUTE;
 	(*idlePtr->proc)(idlePtr->clientData);
-	/* if prolongation requested - reattached to tail */
-	if (!(idlePtr->flags & TCL_EVENTST_EXECUTE)) {
+	/* unfreeze / if used somewhere else (nested) or prolongation (reattached) */
+	if (idlePtr->refCount-- > 1 || (idlePtr->flags & TCL_TMREV_LISTED)) {
 	    goto nextEvent;
-	}
+	};
 	/* free it via deleteProc and ckfree */
-	if (idlePtr->deleteProc) {
-	    idlePtr->flags |= TCL_EVENTST_DELETE;
+	if (idlePtr->deleteProc && !(idlePtr->flags & TCL_TMREV_DELETE)) {
+	    idlePtr->flags |= TCL_TMREV_DELETE;
 	    (*idlePtr->deleteProc)(idlePtr->clientData);
-	    /* if prolongation requested - reattached to tail */
-	    if (!(idlePtr->flags & TCL_EVENTST_DELETE)) {
-		goto nextEvent;
-	    }
 	}
 	ckfree((char *) idlePtr);
 
@@ -1329,14 +1443,19 @@ TclServiceIdle(void)
 int
 TclpGetUTimeFromObj(
     Tcl_Interp	*interp,	/* Current interpreter or NULL. */
-    Tcl_Obj	*objPtr,	/* Object to read numeric time (in milliseconds). */
-    Tcl_WideInt	*timePtr)	/* Resulting time if converted (in microseconds). */
+    Tcl_Obj	*objPtr,	/* Object to read numeric time (in units
+				 * corresponding given factor). */
+    Tcl_WideInt	*timePtr,	/* Resulting time if converted (in microseconds). */
+    int factor)			/* Current factor of the time-object:
+				 *         1 - microseconds,
+				 *	1000 - milliseconds,
+				 *   1000000 - seconds */
 {
     if (objPtr->typePtr != &tclDoubleType) {
-	Tcl_WideInt ms;
-	if (Tcl_GetWideIntFromObj(NULL, objPtr, &ms) == TCL_OK) {
-	    if (ms < 0x7FFFFFFFFFFFFFFFL / 1000) { /* avoid overflow */
-		*timePtr = (ms * 1000);
+	Tcl_WideInt tm;
+	if (Tcl_GetWideIntFromObj(NULL, objPtr, &tm) == TCL_OK) {
+	    if (tm < 0x7FFFFFFFFFFFFFFFL / factor) { /* avoid overflow */
+		*timePtr = (tm * factor);
 		return TCL_OK;
 	    }
 	    *timePtr = 0x7FFFFFFFFFFFFFFFL;
@@ -1344,11 +1463,16 @@ TclpGetUTimeFromObj(
 	}
     }
     if (1) {
-	double ms;
-	if (Tcl_GetDoubleFromObj(interp, objPtr, &ms) == TCL_OK) {
-	    if (ms < 0x7FFFFFFFFFFFFFFFL / 1000) { /* avoid overflow */
+	double tm;
+	if (Tcl_GetDoubleFromObj(interp, objPtr, &tm) == TCL_OK) {
+	    if (tm < 0x7FFFFFFFFFFFFFFFL / factor) { /* avoid overflow */
 		/* use precise as possible calculation by double (microseconds) */
-		*timePtr = ((Tcl_WideInt)ms) * 1000 + (((long)(ms*1000)) % 1000);
+		if (factor == 1) {
+		    *timePtr = tm;
+		} else {
+		    *timePtr = ((Tcl_WideInt)tm * factor) + 
+			(((long)(tm*factor)) % factor);
+		}
 		return TCL_OK;
 	    }
 	    *timePtr = 0x7FFFFFFFFFFFFFFFL;
@@ -1391,7 +1515,9 @@ Tcl_AfterObjCmd(
     static CONST char *afterSubCmds[] = {
 	"at", "cancel", "idle", "info", NULL
     };
-    enum afterSubCmds {AFTER_AT, AFTER_CANCEL, AFTER_IDLE, AFTER_INFO};
+    enum afterSubCmds {
+	AFTER_AT, AFTER_CANCEL, AFTER_IDLE, AFTER_INFO
+    };
     ThreadSpecificData *tsdPtr = InitTimer();
 
     if (objc < 2) {
@@ -1420,14 +1546,14 @@ Tcl_AfterObjCmd(
 
     index = -1;
     if ( ( TclObjIsIndexOfTable(objv[1], afterSubCmds)
-	|| TclpGetUTimeFromObj(NULL, objv[1], &usec) != TCL_OK
+	|| TclpGetUTimeFromObj(NULL, objv[1], &usec, 1000) != TCL_OK
       )
       && Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0,
 				 &index) != TCL_OK
     ) {
 	Tcl_AppendResult(interp, "bad argument \"",
 		Tcl_GetString(objv[1]),
-		"\": must be at, cancel, idle, info, or a time", NULL);
+		"\": must be at, cancel, idle, info, prolong or a time", NULL);
 	return TCL_ERROR;
     }
 
@@ -1448,38 +1574,40 @@ Tcl_AfterObjCmd(
 	    return AfterDelay(interp, usec, 0);
 	}
     case AFTER_AT: {
-    	TclTimerEntry *entryPtr;
+    	TclTimerEvent *tmrEvent;
     	int flags = 0;
     	if (index == AFTER_AT) {
-	    if (objc < 3) {
-		Tcl_WrongNumArgs(interp, 2, objv, "time");
+	    flags = TCL_TMREV_AT;
+    	    objc--;
+    	    objv++;
+	    if (objc < 2) {
+		Tcl_WrongNumArgs(interp, 1, objv, "?option? time");
 		return TCL_ERROR;
 	    }
-	    /* get time from objv[2] */
-	    if (TclpGetUTimeFromObj(interp, objv[2], &usec) != TCL_OK) {
+	    /* get time from object, default factor 1000 (ms) */
+	    if (TclpGetUTimeFromObj(interp, objv[1], &usec, 1000) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if (objc == 3) {
+	    if (objc == 2) {
 		/* after at <time> */
 		return AfterDelay(interp, usec, flags);
 	    }
-	    flags = TCL_ABSTMR_EVENT;
 	}
 
 	if (usec || (index == AFTER_AT)) {
 	    /* after ?at? <time|offset> <command> ... */
-	    entryPtr = TclpCreateTimerHandlerEx(usec, AfterProc,
+	    tmrEvent = TclpCreateTimerEvent(usec, AfterProc,
 			    FreeAfterPtr, sizeof(AfterInfo), flags);
 	} else {
 	    /* after 0 <command> ... */
-	    entryPtr = TclpCreateTimerEntryEx(AfterProc,
-			    FreeAfterPtr, sizeof(AfterInfo), TCL_PROMPT_EVENT);
+	    tmrEvent = TclpCreatePromptTimerEvent(AfterProc,
+			    FreeAfterPtr, sizeof(AfterInfo), TCL_TMREV_PROMPT);
 	}
 
-	if (entryPtr == NULL) { /* error handled in panic */
+	if (tmrEvent == NULL) { /* error handled in panic */
 	    return TCL_ERROR;
 	}
-	afterPtr = TclpTimerEntry2AfterInfo(entryPtr);
+	afterPtr = TclpTimerEvent2AfterInfo(tmrEvent);
 
 	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
@@ -1549,24 +1677,24 @@ Tcl_AfterObjCmd(
 	    }
 	}
 	if (afterPtr != NULL && afterPtr->assocPtr->interp == interp) {
-	    TclpDeleteTimerEntry(TclpAfterInfo2TimerEntry(afterPtr));
+	    TclpDeleteTimerEvent(TclpAfterInfo2TimerEvent(afterPtr));
 	}
 	break;
     }
     case AFTER_IDLE: {
-    	TclTimerEntry *idlePtr;
+    	TclTimerEvent *idlePtr;
 
 	if (objc < 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "script script ...");
 	    return TCL_ERROR;
 	}
 
-	idlePtr = TclpCreateTimerEntryEx(AfterProc,
-			FreeAfterPtr, sizeof(AfterInfo), TCL_IDLE_EVENT);
+	idlePtr = TclpCreatePromptTimerEvent(AfterProc,
+			FreeAfterPtr, sizeof(AfterInfo), TCL_TMREV_IDLE);
 	if (idlePtr == NULL) { /* error handled in panic */
 	    return TCL_ERROR;
 	}
-	afterPtr = TclpTimerEntry2AfterInfo(idlePtr);
+	afterPtr = TclpTimerEvent2AfterInfo(idlePtr);
 
 	/* attach to the list */
 	afterPtr->assocPtr = assocPtr;
@@ -1621,7 +1749,7 @@ Tcl_AfterObjCmd(
 	resultListPtr = Tcl_NewObj();
 	Tcl_ListObjAppendElement(interp, resultListPtr, afterPtr->commandPtr);
 	Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
- 		(TclpAfterInfo2TimerEntry(afterPtr)->flags & TCL_IDLE_EVENT) ?
+ 		(TclpAfterInfo2TimerEvent(afterPtr)->flags & TCL_TMREV_IDLE) ?
  		    "idle" : "timer", -1));
 	Tcl_SetObjResult(interp, resultListPtr);
 	break;
@@ -1819,7 +1947,7 @@ AfterProc(
      */
 
     /* remove delete proc from handler (we'll do cleanup here) */
-    TclpAfterInfo2TimerEntry(afterPtr)->deleteProc = NULL;
+    TclpAfterInfo2TimerEvent(afterPtr)->deleteProc = NULL;
 
     /* release object (mark it was triggered) */
     if (afterPtr->selfPtr) {
@@ -1922,7 +2050,7 @@ AfterCleanupProc(
     AfterAssocData *assocPtr = (AfterAssocData *) clientData;
 
     while ( assocPtr->lastAfterPtr ) {
-	TclpDeleteTimerEntry(TclpAfterInfo2TimerEntry(assocPtr->lastAfterPtr));
+	TclpDeleteTimerEvent(TclpAfterInfo2TimerEvent(assocPtr->lastAfterPtr));
     }
 }
 
diff --git a/tests/event.test b/tests/event.test
index f943f23..9a31ff7 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -404,6 +404,37 @@ foo
     ("after" script)
 }
 
+test event-7.10 {after at - absolute time} {
+    set result {}
+    # 1st test simple delay (and mix generation / recursive processing)
+    set attm [expr {[clock milliseconds]+150}]
+    after 0 {lappend result 1}
+    after 100 {
+    	update; # this don't catch event 3
+    	lappend result 2a
+    	after at $attm; # delay to 150ms from start
+    	update; # this still don't catch event 3 also
+    	lappend result 2b
+    	after at [incr attm 100]; # delay to 250ms from start
+    	update; # this should catch event 3
+    	lappend result 2c
+    }
+    after 200 {lappend result 3; set a done}
+    vwait a
+    # 2nd test events "at" (mix due-times between relative/absolute events)
+    lappend result --
+    set sttm [clock milliseconds]
+    after 200 {lappend result 4; set a done}
+    after 120 {lappend result 5}
+    after 40 {lappend result 6}
+    after at [expr {$sttm+160}] {lappend result at-1}
+    after at [expr {$sttm+80}] {lappend result at-2}
+    after at ${sttm}.999 {lappend result at-3}
+    after 2000 {lappend result [set a timeout]}
+    after 0 {lappend result 7}
+    vwait a
+    set result
+} {1 2a 2b 3 2c -- 7 at-3 6 at-2 5 at-1 4}
 
 # someday : add a test checking that 
 # when there is no bgerror, an error msg goes to stderr
-- 
cgit v0.12


From 4378179cb1eb32da7bfaf8041c2a3efafdffff33 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:30:36 +0000
Subject: "after at" set factor to 1000000 (seconds), test cases fixed

---
 generic/tclTimer.c | 10 +++++-----
 tests/event.test   | 12 ++++++------
 tests/timer.test   |  4 ++--
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 5878b39..e6b0799 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -1468,10 +1468,10 @@ TclpGetUTimeFromObj(
 	    if (tm < 0x7FFFFFFFFFFFFFFFL / factor) { /* avoid overflow */
 		/* use precise as possible calculation by double (microseconds) */
 		if (factor == 1) {
-		    *timePtr = tm;
+		    *timePtr = (Tcl_WideInt)tm;
 		} else {
 		    *timePtr = ((Tcl_WideInt)tm * factor) + 
-			(((long)(tm*factor)) % factor);
+			(((Tcl_WideInt)(tm*factor)) % factor);
 		}
 		return TCL_OK;
 	    }
@@ -1553,7 +1553,7 @@ Tcl_AfterObjCmd(
     ) {
 	Tcl_AppendResult(interp, "bad argument \"",
 		Tcl_GetString(objv[1]),
-		"\": must be at, cancel, idle, info, prolong or a time", NULL);
+		"\": must be at, cancel, idle, info or a time", NULL);
 	return TCL_ERROR;
     }
 
@@ -1584,8 +1584,8 @@ Tcl_AfterObjCmd(
 		Tcl_WrongNumArgs(interp, 1, objv, "?option? time");
 		return TCL_ERROR;
 	    }
-	    /* get time from object, default factor 1000 (ms) */
-	    if (TclpGetUTimeFromObj(interp, objv[1], &usec, 1000) != TCL_OK) {
+	    /* get time from object, default factor for "at" - 1000000 (s) */
+	    if (TclpGetUTimeFromObj(interp, objv[1], &usec, 1000000) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	    if (objc == 2) {
diff --git a/tests/event.test b/tests/event.test
index 9a31ff7..cb887c5 100644
--- a/tests/event.test
+++ b/tests/event.test
@@ -407,7 +407,7 @@ foo
 test event-7.10 {after at - absolute time} {
     set result {}
     # 1st test simple delay (and mix generation / recursive processing)
-    set attm [expr {[clock milliseconds]+150}]
+    set attm [expr {[clock milliseconds]/1000.0 + 0.150}]
     after 0 {lappend result 1}
     after 100 {
     	update; # this don't catch event 3
@@ -415,7 +415,7 @@ test event-7.10 {after at - absolute time} {
     	after at $attm; # delay to 150ms from start
     	update; # this still don't catch event 3 also
     	lappend result 2b
-    	after at [incr attm 100]; # delay to 250ms from start
+    	after at [expr {$attm + 0.100}]; # delay to 250ms from start
     	update; # this should catch event 3
     	lappend result 2c
     }
@@ -423,13 +423,13 @@ test event-7.10 {after at - absolute time} {
     vwait a
     # 2nd test events "at" (mix due-times between relative/absolute events)
     lappend result --
-    set sttm [clock milliseconds]
+    set sttm [expr {[clock milliseconds]/1000.0}]
     after 200 {lappend result 4; set a done}
     after 120 {lappend result 5}
     after 40 {lappend result 6}
-    after at [expr {$sttm+160}] {lappend result at-1}
-    after at [expr {$sttm+80}] {lappend result at-2}
-    after at ${sttm}.999 {lappend result at-3}
+    after at [expr {$sttm+0.160}] {lappend result at-1}
+    after at [expr {$sttm+0.080}] {lappend result at-2}
+    after at [expr {$sttm+0.005}] {lappend result at-3}
     after 2000 {lappend result [set a timeout]}
     after 0 {lappend result 7}
     vwait a
diff --git a/tests/timer.test b/tests/timer.test
index 5a63d54..2dbcae3 100644
--- a/tests/timer.test
+++ b/tests/timer.test
@@ -175,10 +175,10 @@ test timer-6.1 {Tcl_AfterCmd procedure, basics} {
 } {1 {wrong # args: should be "after option ?arg arg ...?"}}
 test timer-6.2 {Tcl_AfterCmd procedure, basics} {
     list [catch {after 2x} msg] $msg
-} {1 {bad argument "2x": must be cancel, idle, info, or an integer}}
+} {1 {bad argument "2x": must be at, cancel, idle, info or a time}}
 test timer-6.3 {Tcl_AfterCmd procedure, basics} {
     list [catch {after gorp} msg] $msg
-} {1 {bad argument "gorp": must be cancel, idle, info, or an integer}}
+} {1 {bad argument "gorp": must be at, cancel, idle, info or a time}}
 test timer-6.4 {Tcl_AfterCmd procedure, ms argument} {
     set x before
     # cover prompt events also (immediate handling differs now):
-- 
cgit v0.12


From 07b7b6eb37bb7ac079e3b55068fae7f96adbea4c Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:31:13 +0000
Subject: Merge branch 'fix-busy-prompt-timers' into event-perf-branch: * Amend
 to timer-marker: dualize special state of timer-marker (to differentiate
 between timer generations), so:   INT2PTR(-1) - exec immediate (marker
 reached);   INT2PTR(-2) - check in the next-cycle (marker reached only if no
 other events available); Avoids permanent busy execution of prompt-events
 (always busy in timer), if they regenerate itself continuously for waiting
 for other events (like writable/readable), see e. g. socket-2.12.

---
 generic/tclNotify.c | 115 ++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 81 insertions(+), 34 deletions(-)

diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index 6e67ed9..01bf18f 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -577,6 +577,9 @@ Tcl_DeleteEvents(
 	    if (tsdPtr->markerEventPtr == evPtr) {
 		tsdPtr->markerEventPtr = prevPtr;
 	    }
+	    if (tsdPtr->timerMarkerPtr == evPtr) {
+		tsdPtr->timerMarkerPtr = prevPtr;
+	    }
 
 	    /*
 	     * Delete the event data structure.
@@ -628,7 +631,7 @@ Tcl_ServiceEvent(
 {
     Tcl_Event *evPtr, *prevPtr;
     Tcl_EventProc *proc;
-    int result = 0;
+    int result;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
@@ -645,22 +648,25 @@ Tcl_ServiceEvent(
      * queue.
      */
 
-    if ((flags & TCL_ASYNC_EVENTS) && Tcl_AsyncReady()) {
-	(void) Tcl_AsyncInvoke(NULL, 0);
-	return 1;
-    }
-
-    /* Async only */
-    if ((flags & TCL_ALL_EVENTS) == TCL_ASYNC_EVENTS) {
-	return 0;
+    if ((flags & TCL_ASYNC_EVENTS)) {
+	if (Tcl_AsyncReady()) {
+	    (void) Tcl_AsyncInvoke(NULL, 0);
+	    return 1;
+	}
+	/* Async only */
+	if ((flags & TCL_ALL_EVENTS) == TCL_ASYNC_EVENTS) {
+	    return 0;
+	}
     }
 
     /*
      * If timer marker reached, process timer events now.
      */
-    if ( tsdPtr->timerMarkerPtr == INT2PTR(-1)
-      || !tsdPtr->firstEventPtr
-      || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS)
+    if ( (flags & TCL_TIMER_EVENTS) /* timer allowed */
+      && ( tsdPtr->timerMarkerPtr == INT2PTR(-1) /* timer-event reached */
+	|| !tsdPtr->firstEventPtr		 /* no another events at all */
+	|| ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
+      )
     ) {
 	goto timer;
     }
@@ -761,26 +767,56 @@ Tcl_ServiceEvent(
     }
     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
 
-timer:
     /*
      * Process timer queue, if alloved and timers are enabled.
      */
-    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr) {
-	/* reset marker */
-	tsdPtr->timerMarkerPtr = NULL;
 
-	result = TclServiceTimerEvents();
-	if (result < 0) {
-	    /* events processed, but marker to process still pending timers */
-	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
-	    result = 1;
+    if (flags & TCL_TIMER_EVENTS) {
+timer:
+	/* If available pending timer-events of new generation */
+	if (tsdPtr->timerMarkerPtr == INT2PTR(-2)) {
+	    /* if other events available */
+	    if ((tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
+		/* process timer-events after it (next cycle) */
+		return 0;
+	    }
+	    /* no other events - process timer-events now */
+	    goto processTimer;
+        }
+
+	if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) {
+
+	  processTimer:
+	    /* reset marker */
+	    tsdPtr->timerMarkerPtr = NULL;
+
+	    result = TclServiceTimerEvents();
+	    if (result < 0) {
+		/* 
+		 * Events processed, but still pending timers (of new generation)
+		 * set marker to process timer, if setup- resp. check-proc will
+		 * not generate new events.
+		 */
+		if (tsdPtr->timerMarkerPtr == NULL) {
+		    /* marker to last event in the queue */
+		    if (!(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
+			/* 
+			 * Marker as "now" - queue is empty, so timers events are first,
+			 * if setup-proc resp. check-proc will not generate new events.
+			 */
+			tsdPtr->timerMarkerPtr = INT2PTR(-2);
+		    };
+		}
+		result = 1;
+	    }
+	    return result;
 	}
     }
 
-
-    return result;
+    return 0;
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -847,7 +883,8 @@ TclPeekEventQueued(
 
     return 0;
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -873,12 +910,16 @@ TclSetTimerEventMarker(
     if (tsdPtr->timerMarkerPtr == NULL) {
 	/* marker to last event in the queue */
 	if (head || !(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
-	    /* marker as "now" - queue is empty, so timers events are first */
-	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
+	    /* 
+	     * Marker as "now" - queue is empty, so timers events are first,
+	     * if setup-proc resp. check-proc will not generate new events.
+	     */
+	    tsdPtr->timerMarkerPtr = INT2PTR(-2);
 	};
     }
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -902,7 +943,8 @@ Tcl_GetServiceMode(void)
 
     return tsdPtr->serviceMode;
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -934,7 +976,8 @@ Tcl_SetServiceMode(
     }
     return oldMode;
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -978,7 +1021,8 @@ Tcl_SetMaxBlockTime(
 	Tcl_SetTimer(&tsdPtr->blockTime);
     }
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1199,7 +1243,8 @@ Tcl_DoOneEvent(
     tsdPtr->serviceMode = oldMode;
     return result;
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1284,7 +1329,8 @@ Tcl_ServiceAll(void)
     tsdPtr->serviceMode = TCL_SERVICE_ALL;
     return result;
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1325,7 +1371,8 @@ Tcl_ThreadAlert(
     }
     Tcl_MutexUnlock(&listLock);
 }
-
+
+
 /*
  * Local Variables:
  * mode: c
-- 
cgit v0.12


From e7a4988c734f8a14028c271d4c6b147cbc6e635a Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:31:40 +0000
Subject: interim commit: trying to pass test-cases - timer-3.*, chan-io-29.34,
 socket-2.12 (busy prompt timer, unexpected too early timer event, wrong
 timer-marker usage)

---
 generic/tclIO.c     |   2 +-
 generic/tclNotify.c | 127 +++++++++++++++++++++++++++++++++++-----------------
 generic/tclTimer.c  |  49 ++++++++++++--------
 3 files changed, 118 insertions(+), 60 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index e4bfd35..aa22698 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -8138,7 +8138,7 @@ ChannelTimerProc(
 	 * before UpdateInterest gets called by Tcl_NotifyChannel.
 	 */
 
-	statePtr->timer = TclpProlongTimerEvent(statePtr->timer, 0, 0);
+	statePtr->timer = TclpProlongTimerEvent(statePtr->timer, 0, TCL_TMREV_PROMPT);
 	if (!statePtr->timer) {
 	    statePtr->timer = TclpCreatePromptTimerEvent(ChannelTimerProc,
 		FreeChannelTimerProc, 0, TCL_TMREV_PROMPT);
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index 01bf18f..c6978cb 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -32,6 +32,14 @@ typedef struct EventSource {
 } EventSource;
 
 /*
+ * Used for performance purposes, threshold to bypass check source (if don't wait)
+ * Values under 1000 should be approximately under 1ms, e. g. 5 is ca. 0.005ms
+ */
+#ifndef TCL_CHECK_EVENT_SOURCE_THRESHOLD
+    #define TCL_CHECK_EVENT_SOURCE_THRESHOLD 5
+#endif
+
+/*
  * The following structure keeps track of the state of the notifier on a
  * per-thread basis. The first three elements keep track of the event queue.
  * In addition to the first (next to be serviced) and last events in the
@@ -72,25 +80,20 @@ typedef struct ThreadSpecificData {
 				/* Next notifier in global list of notifiers.
 				 * Access is controlled by the listLock global
 				 * mutex. */
-#ifndef TCL_WIDE_CLICKS		/* Last "time" source checked, used as threshold */
+#if TCL_CHECK_EVENT_SOURCE_THRESHOLD
+				/* Last "time" source checked, used as threshold
+				 * to avoid checking for events too often */
+  #ifndef TCL_WIDE_CLICKS
     unsigned long lastCheckClicks;
-#else
+  #else
     Tcl_WideInt lastCheckClicks;
+  #endif
 #endif
 } ThreadSpecificData;
 
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * Used for performance purposes, threshold to bypass check source (if don't wait)
- * Values under 1000 should be approximately under 1ms, e. g. 10 is ca. 0.01ms
- */
-#ifndef CHECK_EVENT_SOURCE_THRESHOLD
-    #define CHECK_EVENT_SOURCE_THRESHOLD 10
-#endif
-
-
-/*
  * Global list of notifiers. Access to this list is controlled by the listLock
  * mutex. If this becomes a performance bottleneck, this could be replaced
  * with a hashtable.
@@ -662,13 +665,17 @@ Tcl_ServiceEvent(
     /*
      * If timer marker reached, process timer events now.
      */
-    if ( (flags & TCL_TIMER_EVENTS) /* timer allowed */
-      && ( tsdPtr->timerMarkerPtr == INT2PTR(-1) /* timer-event reached */
-	|| !tsdPtr->firstEventPtr		 /* no another events at all */
-	|| ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
-      )
-    ) {
-	goto timer;
+    if (flags & TCL_TIMER_EVENTS) { /* timer allowed */
+	if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) { /* timer-event reached */
+	    goto processTimer;
+	}
+#if 0
+	if ( !tsdPtr->firstEventPtr		 /* no another events at all */
+	  || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
+	) {
+	    goto timer;
+	}
+#endif
     }
 
     /*
@@ -681,13 +688,6 @@ Tcl_ServiceEvent(
 	    evPtr = evPtr->nextPtr) {
 	
 	/*
-	* If timer marker reached, next cycle will process timer events.
-	*/
-	if (evPtr == tsdPtr->timerMarkerPtr) {
-	    tsdPtr->timerMarkerPtr = INT2PTR(-1);
-	}
-
-	/*
 	 * Call the handler for the event. If it actually handles the event
 	 * then free the storage for the event. There are two tricky things
 	 * here, both stemming from the fact that the event code may be
@@ -725,6 +725,9 @@ Tcl_ServiceEvent(
 	     * The event was processed, so remove it from the queue.
 	     */
 
+	    if (tsdPtr->timerMarkerPtr == evPtr) {
+		tsdPtr->timerMarkerPtr = INT2PTR(-1); /* timer marker reached */
+	    }
 	    if (tsdPtr->firstEventPtr == evPtr) {
 		tsdPtr->firstEventPtr = evPtr->nextPtr;
 		if (evPtr->nextPtr == NULL) {
@@ -773,8 +776,36 @@ Tcl_ServiceEvent(
 
     if (flags & TCL_TIMER_EVENTS) {
 timer:
+#if 1
 	/* If available pending timer-events of new generation */
 	if (tsdPtr->timerMarkerPtr == INT2PTR(-2)) {
+	    /* no other events - process timer-events (next cycle) */
+	    if (!tsdPtr->lastEventPtr) { /* no other events */
+		goto processTimer;
+	    } else {
+	    	tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr;
+	    }
+	    return 0;
+	}
+#else
+#if 1
+	/* If available pending timer-events of new generation */
+	if ( tsdPtr->timerMarkerPtr == INT2PTR(-2)
+	  || !tsdPtr->firstEventPtr /* no other events */
+	) {
+	    /* no other events - process timer-events (next cycle) */
+	    if (tsdPtr->timerMarkerPtr == INT2PTR(-2)) {
+		tsdPtr->timerMarkerPtr = INT2PTR(-1);
+	    } else {
+		tsdPtr->timerMarkerPtr = INT2PTR(-2);
+	    }
+	    return 0;
+	}
+#else
+	/* If available pending timer-events of new generation */
+	if ( tsdPtr->timerMarkerPtr == INT2PTR(-2)
+	  || !tsdPtr->lastEventPtr
+	) {
 	    /* if other events available */
 	    if ((tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
 		/* process timer-events after it (next cycle) */
@@ -783,7 +814,8 @@ timer:
 	    /* no other events - process timer-events now */
 	    goto processTimer;
         }
-
+#endif
+#endif
 	if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) {
 
 	  processTimer:
@@ -850,23 +882,31 @@ TclPeekEventQueued(
     	 */
 	if ( Tcl_AsyncReady()
 	  || (tsdPtr->firstEventPtr)
-	  || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr)
+	  || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr == INT2PTR(-1))
 	) {
 	    return 1;
 	}
 
+	/* once from here */
+	if (!repeat) {
+	    break;
+	}
+
 	if (flags & TCL_DONT_WAIT) {
+    #if TCL_CHECK_EVENT_SOURCE_THRESHOLD
 	    /* don't need to wait/check for events too often */
-#ifndef TCL_WIDE_CLICKS
-	    unsigned long clicks = TclpGetClicks();
-#else
-	    Tcl_WideInt clicks = TclpGetWideClicks();
-#endif
-
-	    if ((clicks - tsdPtr->lastCheckClicks) <= CHECK_EVENT_SOURCE_THRESHOLD) {
+	#ifndef TCL_WIDE_CLICKS
+	    unsigned long clickdiff, clicks = TclpGetClicks();
+	#else
+	    Tcl_WideInt clickdiff, clicks = TclpGetWideClicks();
+	#endif
+	    /* considering possible clicks-jump */
+	    if ( (clickdiff = (clicks - tsdPtr->lastCheckClicks)) >= 0 
+	      && clickdiff <= TCL_CHECK_EVENT_SOURCE_THRESHOLD) {
 		return 0;
 	    }
 	    tsdPtr->lastCheckClicks = clicks;
+    #endif
 	}
 
 	/*
@@ -907,7 +947,7 @@ TclSetTimerEventMarker(
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
-    if (tsdPtr->timerMarkerPtr == NULL) {
+    if (tsdPtr->timerMarkerPtr == NULL || tsdPtr->timerMarkerPtr == INT2PTR(-2)) {
 	/* marker to last event in the queue */
 	if (head || !(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
 	    /* 
@@ -1133,16 +1173,21 @@ Tcl_DoOneEvent(
 	 */
 
 	if (flags & TCL_DONT_WAIT) {
+
 	    /* don't need to wait/check for events too often */
-#ifndef TCL_WIDE_CLICKS
-	    unsigned long clicks = TclpGetClicks();
-#else
-	    Tcl_WideInt clicks = TclpGetWideClicks();
-#endif
-	    if ((clicks - tsdPtr->lastCheckClicks) <= CHECK_EVENT_SOURCE_THRESHOLD) {
+    #if TCL_CHECK_EVENT_SOURCE_THRESHOLD
+	#ifndef TCL_WIDE_CLICKS
+	    unsigned long clickdiff, clicks = TclpGetClicks();
+	#else
+	    Tcl_WideInt clickdiff, clicks = TclpGetWideClicks();
+	#endif
+	    /* considering possible clicks-jump */
+	    if ( (clickdiff = (clicks - tsdPtr->lastCheckClicks)) >= 0 
+	      && clickdiff <= TCL_CHECK_EVENT_SOURCE_THRESHOLD) {
 		goto idleEvents;
 	    }
 	    tsdPtr->lastCheckClicks = clicks;
+    #endif
 
 	    tsdPtr->blockTime.sec = 0;
 	    tsdPtr->blockTime.usec = 0;
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index e6b0799..bb13c39 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -270,7 +270,7 @@ AttachTimerEvent(
 	/* attach to the prompt queue */
 	TclSpliceTailEx(tmrEvent, tsdPtr->promptList, tsdPtr->promptTail);
 	/* execute immediately: signal pending and set timer marker */
-	tsdPtr->timerPending++;
+	tsdPtr->timerPending = 1;
 	TclSetTimerEventMarker(0);
 	return;
     } 
@@ -918,10 +918,11 @@ TimerSetupProc(
 {
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
+    Tcl_WideInt entryTime = 0;
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
-    if ( ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)
+    if ( ((flags & TCL_TIMER_EVENTS) && (tsdPtr->timerPending || tsdPtr->promptList))
       || ((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList )
     ) {
 	/*
@@ -940,7 +941,7 @@ TimerSetupProc(
 	 */
 
 	Tcl_WideInt now = TclpGetMicroseconds();
-	Tcl_WideInt entryTime = 0x7FFFFFFFFFFFFFFFL;
+	entryTime = 0x7FFFFFFFFFFFFFFFL;
 
 	if (tsdPtr->relTimerList) {
 	    entryTime = TimerGetDueTime(tsdPtr,
@@ -968,18 +969,18 @@ TimerSetupProc(
 	    blockTime.usec = 0;
 	}
 	
-	/*
-	* If the first timer has expired, stick an event on the queue right now.
-	*/
-	if (!tsdPtr->timerPending && entryTime <= 0) {
-	    TclSetTimerEventMarker(0);
-	    tsdPtr->timerPending = 1;
-	}
-    
     } else {
 	return;
     }
 
+    /*
+     * If the first timer has expired, stick an event on the queue right now.
+     */
+    if (!tsdPtr->timerPending && entryTime <= 0) {
+	TclSetTimerEventMarker(0);
+	tsdPtr->timerPending = 1;
+    }
+
     Tcl_SetMaxBlockTime(&blockTime);
 }
 
@@ -1005,7 +1006,7 @@ TimerCheckProc(
     ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_WideInt now, entryTime = 0x7FFFFFFFFFFFFFFFL;
+    Tcl_WideInt now, entryTime = 0;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
 
     if (!(flags & TCL_TIMER_EVENTS)) {
@@ -1015,13 +1016,20 @@ TimerCheckProc(
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
     /* If already pending (or no timer-events) */
-    if (tsdPtr->timerPending || !tsdPtr->relTimerList) {
-    	return;
+    if (tsdPtr->timerPending) {
+	return;
+    }
+    if (tsdPtr->promptList) {
+	goto mark;
+    }
+    if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
+	return;
     }
 
     /*
      * Verify the first timer on the queue.
      */
+    entryTime = 0x7FFFFFFFFFFFFFFFL;
     now = TclpGetMicroseconds();
     if (tsdPtr->relTimerList) {
 	entryTime = TimerGetDueTime(tsdPtr,
@@ -1043,7 +1051,8 @@ TimerCheckProc(
     /*
     * If the first timer has expired, stick an event on the queue.
     */
-    if (entryTime <= 0) {
+    if (!tsdPtr->timerPending && entryTime <= 0) {
+  mark:
 	TclSetTimerEventMarker(0);
 	tsdPtr->timerPending = 1;
     }
@@ -1076,6 +1085,7 @@ TclServiceTimerEvents(void)
 {
     TclTimerEvent *tmrEvent, *relTimerList, *absTimerList;
     size_t currentGeneration, currentEpoch;
+    int result = 0;
     int prevTmrPending;
     ThreadSpecificData *tsdPtr = InitTimer();
 
@@ -1107,6 +1117,7 @@ TclServiceTimerEvents(void)
      */
 
     currentGeneration = tsdPtr->timerGeneration++;
+    tsdPtr->timerPending = 0;
 
     /* First process all prompt (immediate) events */
     while ((tmrEvent = tsdPtr->promptList) != NULL
@@ -1121,6 +1132,7 @@ TclServiceTimerEvents(void)
 	tsdPtr->timerPending = 0;
 	/* execute event */
 	(*tmrEvent->proc)(tmrEvent->clientData);
+	result = 1;
 	/* restore current timer pending */
 	tsdPtr->timerPending += prevTmrPending;
 	/* unfreeze / if used somewhere else (nested) or prolongation (reattached) */
@@ -1207,6 +1219,7 @@ TclServiceTimerEvents(void)
 	tsdPtr->timerPending = 0;
 	/* invoke timer proc */
 	(*tmrEvent->proc)(tmrEvent->clientData);
+	result = 1;
 	/* restore current timer pending */
 	tsdPtr->timerPending += prevTmrPending;
 	/* unfreeze / if used somewhere else (nested) or prolongation (reattached) */
@@ -1230,20 +1243,20 @@ TclServiceTimerEvents(void)
     }
 
     /* pending timer events, so mark (queue) timer events  */
-    if (tsdPtr->timerPending > 1) {
+    if (tsdPtr->timerPending >= 1) {
     	tsdPtr->timerPending = 1;
     	return -1;
     }
 
     /* Reset generation if both timer queue are empty */
-    if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
+    if (!tsdPtr->promptList && !tsdPtr->relTimerList && !tsdPtr->absTimerList) {
 	tsdPtr->timerGeneration = 0;
     }
 
     /* Compute the next timeout (later via TimerSetupProc using the first timer). */
     tsdPtr->timerPending = 0;
 
-    return 1; /* processing done, again later via TimerCheckProc */
+    return result; /* processing done, again later via TimerCheckProc */
 }
 
 /*
-- 
cgit v0.12


From 06f9fcd88b1e4a25a0a4c87a3ed1e7ec2e0ebf31 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:31:45 +0000
Subject: fixed timer-marker handling: timer should be always executed after
 queued event (of the same generation), it was marked (be sure it marked to
 immediate execution in corresponding checkProc only). tclIO: scheduled event
 rewritten using Tcl_Event instead of timer event (IO is not timer, e. g.
 executed also by usage of `vwait -notimer ...`, etc).

---
 generic/tclIO.c     | 131 +++++++++++++---------------
 generic/tclIO.h     |   2 +-
 generic/tclInt.h    |   3 +-
 generic/tclNotify.c | 244 +++++++++++++++++++++++++++++++---------------------
 generic/tclTimer.c  |  29 ++-----
 tests/io.test       |  18 +++-
 6 files changed, 230 insertions(+), 197 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index aa22698..8d8f211 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -167,8 +167,7 @@ static void		PreserveChannelBuffer(ChannelBuffer *bufPtr);
 static void		ReleaseChannelBuffer(ChannelBuffer *bufPtr);
 static int		IsShared(ChannelBuffer *bufPtr);
 static void		ChannelFree(Channel *chanPtr);
-static void		FreeChannelTimerProc(ClientData clientData);
-static void		ChannelTimerProc(ClientData clientData);
+static int		ChannelScheduledProc(Tcl_Event *evPtr, int flags);
 static int		ChanRead(Channel *chanPtr, char *dst, int dstSize);
 static int		CheckChannelErrors(ChannelState *statePtr,
 			    int direction);
@@ -1587,7 +1586,7 @@ Tcl_CreateChannel(
     statePtr->interestMask	= 0;
     statePtr->scriptRecordPtr	= NULL;
     statePtr->bufSize		= CHANNELBUFFER_DEFAULT_SIZE;
-    statePtr->timer		= NULL;
+    statePtr->schedEvent	= NULL;
     statePtr->csPtrR		= NULL;
     statePtr->csPtrW		= NULL;
     statePtr->outputStage	= NULL;
@@ -2966,12 +2965,12 @@ CloseChannel(
     }
 
     /*
-     * Cancel any outstanding timer.
+     * Cancel any outstanding scheduled event.
      */
 
-    if (statePtr->timer) {
-	TclpDeleteTimerEvent(statePtr->timer);
-	statePtr->timer = NULL;
+    if (statePtr->schedEvent) {
+	TclpCancelEvent(statePtr->schedEvent);
+	statePtr->schedEvent = NULL;
     }
 
     /*
@@ -3451,12 +3450,12 @@ Tcl_ClearChannelHandlers(
     chanPtr = statePtr->topChanPtr;
 
     /*
-     * Cancel any outstanding timer.
+     * Cancel any outstanding scheduled event.
      */
 
-    if (statePtr->timer) {
-	TclpDeleteTimerEvent(statePtr->timer);
-	statePtr->timer = NULL;
+    if (statePtr->schedEvent) {
+	TclpCancelEvent(statePtr->schedEvent);
+	statePtr->schedEvent = NULL;
     }
 
     /*
@@ -4391,7 +4390,7 @@ Tcl_GetsObj(
     /*
      * We didn't get a complete line so we need to indicate to UpdateInterest
      * that the gets blocked. It will wait for more data instead of firing a
-     * timer, avoiding a busy wait. This is where we are assuming that the
+     * event, avoiding a busy wait. This is where we are assuming that the
      * next operation is a gets. No more file events will be delivered on this
      * channel until new data arrives or some operation is performed on the
      * channel (e.g. gets, read, fconfigure) that changes the blocking state.
@@ -4672,7 +4671,7 @@ TclGetsObjBinary(
     /*
      * We didn't get a complete line so we need to indicate to UpdateInterest
      * that the gets blocked. It will wait for more data instead of firing a
-     * timer, avoiding a busy wait. This is where we are assuming that the
+     * event, avoiding a busy wait. This is where we are assuming that the
      * next operation is a gets. No more file events will be delivered on this
      * channel until new data arrives or some operation is performed on the
      * channel (e.g. gets, read, fconfigure) that changes the blocking state.
@@ -7989,7 +7988,7 @@ Tcl_NotifyChannel(
  *	None.
  *
  * Side effects:
- *	May schedule a timer or driver handler.
+ *	May schedule a event or driver handler.
  *
  *----------------------------------------------------------------------
  */
@@ -8018,7 +8017,7 @@ UpdateInterest(
 
     /*
      * If there is data in the input queue, and we aren't waiting for more
-     * data, then we need to schedule a timer so we don't block in the
+     * data, then we need to schedule an event so we don't block in the
      * notifier. Also, cancel the read interest so we don't get duplicate
      * events.
      */
@@ -8047,7 +8046,7 @@ UpdateInterest(
 	     *
 	     * - Tcl drops READABLE here, because it has data in its own
 	     *	 buffers waiting to be read by the extension.
-	     * - A READABLE event is syntesized via timer.
+	     * - A READABLE event is syntesized via tcl-event (on queue tail).
 	     * - The OS still reports the EXCEPTION condition on the file.
 	     * - And the extension gets the EXCPTION event first, and handles
 	     *	 this as EOF.
@@ -8069,12 +8068,13 @@ UpdateInterest(
 
 	    mask &= ~TCL_EXCEPTION;
 
-	    if (!statePtr->timer) {
-		statePtr->timer = TclpCreatePromptTimerEvent(ChannelTimerProc,
-			FreeChannelTimerProc, 0, TCL_TMREV_PROMPT);
-		if (statePtr->timer) {
-		    statePtr->timer->clientData = chanPtr;
-		}
+	    if (!statePtr->schedEvent) {
+		Tcl_Event *evPtr = (Tcl_Event *)ckalloc(
+			sizeof(Tcl_Event) + sizeof(Channel*));
+		*(Channel**)(evPtr+1) = chanPtr;
+		evPtr->proc = ChannelScheduledProc;
+		statePtr->schedEvent = evPtr;
+		Tcl_QueueEvent(evPtr, TCL_QUEUE_TAIL);
 	    }
 	}
     }
@@ -8084,32 +8084,9 @@ UpdateInterest(
 /*
  *----------------------------------------------------------------------
  *
- * FreeChannelTimerProc --
- *
- *	This function simply reset timer in channel state structure.
- *	It does *not* cancel the timer (called on execute/delete timer).
- *
- * Results:
- *	None.
+ * ChannelScheduledProc --
  *
- *----------------------------------------------------------------------
- */
-
-static void
-FreeChannelTimerProc(
-    ClientData clientData)		/* Channel handle. */
-{
-    Channel *chanPtr = clientData;
-    ChannelState *statePtr = chanPtr->state;
-    statePtr->timer = NULL; /* timer deleted */
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ChannelTimerProc --
- *
- *	Timer handler scheduled by UpdateInterest to monitor the channel
+ *	Event handler scheduled by UpdateInterest to monitor the channel
  *	buffers until they are empty.
  *
  * Results:
@@ -8121,38 +8098,41 @@ FreeChannelTimerProc(
  *----------------------------------------------------------------------
  */
 
-static void
-ChannelTimerProc(
-    ClientData clientData)
+static int
+ChannelScheduledProc(
+    Tcl_Event *evPtr, int flags)
 {
-    Channel *chanPtr = clientData;
-    ChannelState *statePtr = chanPtr->state;
-				/* State info for channel */
+    Channel *chanPtr = *(Channel**)(evPtr+1);
+    ChannelState *statePtr; /* State info for channel */
+
+    if (!chanPtr) {
+	return 1;
+    }
+
+    statePtr = chanPtr->state;
 
     if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
 	    && (statePtr->interestMask & TCL_READABLE)
 	    && (statePtr->inQueueHead != NULL)
 	    && IsBufferReady(statePtr->inQueueHead)) {
+
 	/*
-	 * Prolong the timer in case a channel handler reenters the event loop
+	 * Prolong the event in case a channel handler reenters the event loop
 	 * before UpdateInterest gets called by Tcl_NotifyChannel.
 	 */
 
-	statePtr->timer = TclpProlongTimerEvent(statePtr->timer, 0, TCL_TMREV_PROMPT);
-	if (!statePtr->timer) {
-	    statePtr->timer = TclpCreatePromptTimerEvent(ChannelTimerProc,
-		FreeChannelTimerProc, 0, TCL_TMREV_PROMPT);
-	    if (statePtr->timer) {
-		statePtr->timer->clientData = chanPtr;
-	    }
-	}
+	statePtr->schedEvent->proc = ChannelScheduledProc; /* reattach to tail */
+
 	Tcl_Preserve(statePtr);
 	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
 	Tcl_Release(statePtr);
-    } else {
-	statePtr->timer = NULL;
-	UpdateInterest(chanPtr);
+
+	return 1;
     }
+
+    statePtr->schedEvent = NULL; /* event done. */
+    UpdateInterest(chanPtr);
+    return 1;
 }
 
 /*
@@ -8605,9 +8585,9 @@ Tcl_FileEventObjCmd(
 /*
  *----------------------------------------------------------------------
  *
- * ZeroTransferTimerProc --
+ * ZeroTransferEventProc --
  *
- *	Timer handler scheduled by TclCopyChannel so that -command is
+ *	Event handler scheduled by TclCopyChannel so that -command is
  *	called asynchronously even when -size is 0.
  *
  * Results:
@@ -8619,14 +8599,17 @@ Tcl_FileEventObjCmd(
  *----------------------------------------------------------------------
  */
 
-static void
-ZeroTransferTimerProc(
-    ClientData clientData)
+static int
+ZeroTransferEventProc(
+    Tcl_Event *evPtr, int flags)
 {
     /* calling CopyData with mask==0 still implies immediate invocation of the
      *  -command callback, and completion of the fcopy.
      */
+    ClientData clientData = *(ClientData*)(evPtr+1);
     CopyData(clientData, 0);
+
+    return 1;
 }
 
 /*
@@ -8743,9 +8726,11 @@ TclCopyChannel(
      */
 
     if ((nonBlocking == CHANNEL_NONBLOCKING) && (toRead == 0)) {
-        TclTimerEvent *timer = TclpCreatePromptTimerEvent(ZeroTransferTimerProc,
-        	NULL, 0, TCL_TMREV_PROMPT);
-        timer->clientData = csPtr;
+	Tcl_Event *evPtr = (Tcl_Event *)ckalloc(
+		sizeof(Tcl_Event) + sizeof(ClientData*));
+	*(ClientData*)(evPtr+1) = csPtr;
+	evPtr->proc = ZeroTransferEventProc;
+	Tcl_QueueEvent(evPtr, TCL_QUEUE_TAIL);
         return 0;
     }
 
diff --git a/generic/tclIO.h b/generic/tclIO.h
index 0b41f54..e779ffc 100644
--- a/generic/tclIO.h
+++ b/generic/tclIO.h
@@ -187,7 +187,7 @@ typedef struct ChannelState {
 				/* Chain of all scripts registered for event
 				 * handlers ("fileevent") on this channel. */
     int bufSize;		/* What size buffers to allocate? */
-    TclTimerEvent *timer;	/* Handle to wakeup timer for this channel. */
+    Tcl_Event *schedEvent;	/* Scheduler event to wakeup this channel. */
     struct CopyState *csPtrR;	/* State of background copy for which channel
 				 * is input, or NULL. */
     struct CopyState *csPtrW;	/* State of background copy for which channel
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 78c56e1..20d89ef 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2995,9 +2995,10 @@ MODULE_SCOPE int	Tcl_ConcatObjCmd(ClientData clientData,
 MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE void	TclSetTimerEventMarker(int head);
+MODULE_SCOPE void	TclSetTimerEventMarker(int flags);
 MODULE_SCOPE int	TclServiceTimerEvents(void);
 MODULE_SCOPE int	TclServiceIdleEx(int flags, int count);
+MODULE_SCOPE void	TclpCancelEvent(Tcl_Event *evPtr);
 MODULE_SCOPE TclTimerEvent* TclpCreateTimerEvent(Tcl_WideInt usec,
 			    Tcl_TimerProc *proc, Tcl_TimerDeleteProc *delProc,
 			    size_t extraDataSize, int flags);
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index c6978cb..e6480b2 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -496,6 +496,12 @@ QueueEvent(
 	    tsdPtr->lastEventPtr = evPtr;
 	}
 	tsdPtr->firstEventPtr = evPtr;
+
+	/* move timer event hereafter */
+	if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) {
+	    tsdPtr->timerMarkerPtr = evPtr;
+	}
+
     } else if (position == TCL_QUEUE_MARK) {
 	/*
 	 * Insert the event after the current marker event and advance the
@@ -513,10 +519,45 @@ QueueEvent(
 	if (evPtr->nextPtr == NULL) {
 	    tsdPtr->lastEventPtr = evPtr;
 	}
+
+	/* move timer event hereafter */
+	if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) {
+	    tsdPtr->timerMarkerPtr = evPtr;
+	}
     }
     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
 }
 
+static void
+UnlinkEvent(
+    ThreadSpecificData *tsdPtr,
+    Tcl_Event *evPtr,
+    Tcl_Event *prevPtr) {
+    /*
+     * Unlink it.
+     */
+
+    if (prevPtr == NULL) {
+	tsdPtr->firstEventPtr = evPtr->nextPtr;
+    } else {
+	prevPtr->nextPtr = evPtr->nextPtr;
+    }
+
+    /*
+     * Update 'last' and 'marker' events if either has been deleted.
+     */
+
+    if (evPtr->nextPtr == NULL) {
+	tsdPtr->lastEventPtr = prevPtr;
+    }
+    if (tsdPtr->markerEventPtr == evPtr) {
+	tsdPtr->markerEventPtr = prevPtr;
+    }
+    if (tsdPtr->timerMarkerPtr == evPtr) {
+	tsdPtr->timerMarkerPtr = prevPtr ? prevPtr : INT2PTR(-1);
+    }
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -545,7 +586,6 @@ Tcl_DeleteEvents(
     Tcl_Event *prevPtr;		/* Pointer to evPtr's predecessor, or NULL if
 				 * evPtr designates the first event in the
 				 * queue for the thread. */
-    Tcl_Event* hold;
 
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
@@ -559,50 +599,73 @@ Tcl_DeleteEvents(
     prevPtr = NULL;
     evPtr = tsdPtr->firstEventPtr;
     while (evPtr != NULL) {
+	Tcl_Event *nextPtr = evPtr->nextPtr;
 	if ((*proc)(evPtr, clientData) == 1) {
-	    /*
-	     * This event should be deleted. Unlink it.
-	     */
-
-	    if (prevPtr == NULL) {
-		tsdPtr->firstEventPtr = evPtr->nextPtr;
-	    } else {
-		prevPtr->nextPtr = evPtr->nextPtr;
-	    }
 
 	    /*
-	     * Update 'last' and 'marker' events if either has been deleted.
+	     * This event should be deleted. Unlink it.
 	     */
 
-	    if (evPtr->nextPtr == NULL) {
-		tsdPtr->lastEventPtr = prevPtr;
-	    }
-	    if (tsdPtr->markerEventPtr == evPtr) {
-		tsdPtr->markerEventPtr = prevPtr;
-	    }
-	    if (tsdPtr->timerMarkerPtr == evPtr) {
-		tsdPtr->timerMarkerPtr = prevPtr;
-	    }
+	    UnlinkEvent(tsdPtr, evPtr, prevPtr);
 
 	    /*
 	     * Delete the event data structure.
 	     */
 
-	    hold = evPtr;
-	    evPtr = evPtr->nextPtr;
-	    ckfree((char *) hold);
+	    ckfree((char *) evPtr);
 	} else {
 	    /*
 	     * Event is to be retained.
 	     */
 
 	    prevPtr = evPtr;
-	    evPtr = evPtr->nextPtr;
 	}
+	evPtr = nextPtr;
     }
     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
 }
 
+void
+TclpCancelEvent(
+    Tcl_Event *evPtr)		/* Event to remove from queue. */
+{
+    Tcl_Event *prevPtr = NULL;
+
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    Tcl_MutexLock(&(tsdPtr->queueMutex));
+
+    /*
+     * Search event to unlink from queue.
+     */
+
+    if (evPtr != tsdPtr->firstEventPtr) {
+	for (prevPtr = tsdPtr->firstEventPtr;
+		prevPtr && prevPtr->nextPtr != evPtr;
+		prevPtr = prevPtr->nextPtr) {
+	    /* Empty loop body. */
+	}
+	if (!prevPtr) {
+	    evPtr = NULL; /* not in queue (already removed) */
+	}
+    }
+
+    if (evPtr) {
+	/*
+	 * Unlink it.
+	 */
+
+	UnlinkEvent(tsdPtr, evPtr, prevPtr);
+
+	/*
+	 * Delete the event data structure.
+	 */
+	ckfree((char *) evPtr);
+    }
+
+    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -632,7 +695,7 @@ Tcl_ServiceEvent(
 				 * matching this will be skipped for
 				 * processing later. */
 {
-    Tcl_Event *evPtr, *prevPtr;
+    Tcl_Event *evPtr, *prevPtr = NULL;
     Tcl_EventProc *proc;
     int result;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -666,16 +729,13 @@ Tcl_ServiceEvent(
      * If timer marker reached, process timer events now.
      */
     if (flags & TCL_TIMER_EVENTS) { /* timer allowed */
-	if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) { /* timer-event reached */
-	    goto processTimer;
-	}
-#if 0
-	if ( !tsdPtr->firstEventPtr		 /* no another events at all */
-	  || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
+	if ( tsdPtr->timerMarkerPtr == INT2PTR(-1) /* timer-event reached */
+	  || ( tsdPtr->timerMarkerPtr == INT2PTR(-2) /* next cycle, but ... */
+	    && ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
+	  )
 	) {
-	    goto timer;
+	    goto processTimer;
 	}
-#endif
     }
 
     /*
@@ -684,9 +744,15 @@ Tcl_ServiceEvent(
      */
 
     Tcl_MutexLock(&(tsdPtr->queueMutex));
-    for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL;
-	    evPtr = evPtr->nextPtr) {
+    for (evPtr = tsdPtr->firstEventPtr;
+	 evPtr != NULL && tsdPtr->timerMarkerPtr != INT2PTR(-1);
+	 evPtr = evPtr->nextPtr
+    ) {
 	
+	if (tsdPtr->timerMarkerPtr == evPtr) {
+	    tsdPtr->timerMarkerPtr = INT2PTR(-1); /* timer marker reached */
+	}
+
 	/*
 	 * Call the handler for the event. If it actually handles the event
 	 * then free the storage for the event. There are two tricky things
@@ -705,6 +771,7 @@ Tcl_ServiceEvent(
 
 	proc = evPtr->proc;
 	if (proc == NULL) {
+	    prevPtr = evPtr;
 	    continue;
 	}
 	evPtr->proc = NULL;
@@ -721,41 +788,48 @@ Tcl_ServiceEvent(
 	Tcl_MutexLock(&(tsdPtr->queueMutex));
 
 	if (result) {
+
 	    /*
 	     * The event was processed, so remove it from the queue.
 	     */
 
-	    if (tsdPtr->timerMarkerPtr == evPtr) {
-		tsdPtr->timerMarkerPtr = INT2PTR(-1); /* timer marker reached */
-	    }
-	    if (tsdPtr->firstEventPtr == evPtr) {
-		tsdPtr->firstEventPtr = evPtr->nextPtr;
-		if (evPtr->nextPtr == NULL) {
-		    tsdPtr->lastEventPtr = NULL;
-		}
-		if (tsdPtr->markerEventPtr == evPtr) {
-		    tsdPtr->markerEventPtr = NULL;
-		}
-	    } else {
+	    prevPtr = NULL;
+	    if (evPtr != tsdPtr->firstEventPtr) {
 		for (prevPtr = tsdPtr->firstEventPtr;
 			prevPtr && prevPtr->nextPtr != evPtr;
 			prevPtr = prevPtr->nextPtr) {
 		    /* Empty loop body. */
 		}
-		if (prevPtr) {
-		    prevPtr->nextPtr = evPtr->nextPtr;
-		    if (evPtr->nextPtr == NULL) {
-			tsdPtr->lastEventPtr = prevPtr;
-		    }
-		    if (tsdPtr->markerEventPtr == evPtr) {
-			tsdPtr->markerEventPtr = prevPtr;
-		    }
-		} else {
+		if (!prevPtr) {
 		    evPtr = NULL;
 		}
 	    }
 	    if (evPtr) {
-		ckfree((char *) evPtr);
+		/* Detach event from queue */
+		UnlinkEvent(tsdPtr, evPtr, prevPtr);
+
+		/* If wanted to prolong (repeat) */
+		if (evPtr->proc) {
+		    /*
+		     * Event was restored (prolonged) - sign to reattach to tail
+		     */
+		    if (evPtr != tsdPtr->lastEventPtr) {
+			/* detach event from queue */
+			UnlinkEvent(tsdPtr, evPtr, prevPtr);
+			/* attach to tail */
+			evPtr->nextPtr = NULL;
+			if (tsdPtr->firstEventPtr == NULL) {
+			    tsdPtr->firstEventPtr = evPtr;
+			} else {
+			    tsdPtr->lastEventPtr->nextPtr = evPtr;
+			}
+			tsdPtr->lastEventPtr = evPtr;
+		    }
+		} else {
+		    /* Free event */
+		    UnlinkEvent(tsdPtr, evPtr, prevPtr);
+		    ckfree((char *) evPtr);
+		}
 	    }
 	    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
 	    return 1;
@@ -775,50 +849,19 @@ Tcl_ServiceEvent(
      */
 
     if (flags & TCL_TIMER_EVENTS) {
-timer:
-#if 1
-	/* If available pending timer-events of new generation */
-	if (tsdPtr->timerMarkerPtr == INT2PTR(-2)) {
-	    /* no other events - process timer-events (next cycle) */
-	    if (!tsdPtr->lastEventPtr) { /* no other events */
-		goto processTimer;
-	    } else {
-	    	tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr;
-	    }
-	    return 0;
-	}
-#else
-#if 1
+
 	/* If available pending timer-events of new generation */
-	if ( tsdPtr->timerMarkerPtr == INT2PTR(-2)
-	  || !tsdPtr->firstEventPtr /* no other events */
-	) {
+	if (tsdPtr->timerMarkerPtr == INT2PTR(-2)) { /* pending */
 	    /* no other events - process timer-events (next cycle) */
-	    if (tsdPtr->timerMarkerPtr == INT2PTR(-2)) {
+	    if (!(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) { /* no other events */
 		tsdPtr->timerMarkerPtr = INT2PTR(-1);
-	    } else {
-		tsdPtr->timerMarkerPtr = INT2PTR(-2);
 	    }
 	    return 0;
 	}
-#else
-	/* If available pending timer-events of new generation */
-	if ( tsdPtr->timerMarkerPtr == INT2PTR(-2)
-	  || !tsdPtr->lastEventPtr
-	) {
-	    /* if other events available */
-	    if ((tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
-		/* process timer-events after it (next cycle) */
-		return 0;
-	    }
-	    /* no other events - process timer-events now */
-	    goto processTimer;
-        }
-#endif
-#endif
+
 	if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) {
 
-	  processTimer:
+      processTimer:
 	    /* reset marker */
 	    tsdPtr->timerMarkerPtr = NULL;
 
@@ -833,7 +876,7 @@ timer:
 		    /* marker to last event in the queue */
 		    if (!(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
 			/* 
-			 * Marker as "now" - queue is empty, so timers events are first,
+			 * Marker as "pending" - queue is empty, so timers events are first,
 			 * if setup-proc resp. check-proc will not generate new events.
 			 */
 			tsdPtr->timerMarkerPtr = INT2PTR(-2);
@@ -882,7 +925,7 @@ TclPeekEventQueued(
     	 */
 	if ( Tcl_AsyncReady()
 	  || (tsdPtr->firstEventPtr)
-	  || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr == INT2PTR(-1))
+	  || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr)
 	) {
 	    return 1;
 	}
@@ -943,18 +986,21 @@ TclPeekEventQueued(
 
 void
 TclSetTimerEventMarker(
-    int head)
+    int flags)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (tsdPtr->timerMarkerPtr == NULL || tsdPtr->timerMarkerPtr == INT2PTR(-2)) {
 	/* marker to last event in the queue */
-	if (head || !(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) {
+	if ( !(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr) /* no other events */
+	  || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
+	) {
 	    /* 
-	     * Marker as "now" - queue is empty, so timers events are first,
+	     * Marker as "pending" - queue is empty, so timers events are first,
 	     * if setup-proc resp. check-proc will not generate new events.
+	     * Force timer execution if flags specified (from checkProc).
 	     */
-	    tsdPtr->timerMarkerPtr = INT2PTR(-2);
+	    tsdPtr->timerMarkerPtr = flags ? INT2PTR(-1) : INT2PTR(-2);
 	};
     }
 }
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index bb13c39..9c80332 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -918,7 +918,6 @@ TimerSetupProc(
 {
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
-    Tcl_WideInt entryTime = 0;
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
@@ -941,7 +940,7 @@ TimerSetupProc(
 	 */
 
 	Tcl_WideInt now = TclpGetMicroseconds();
-	entryTime = 0x7FFFFFFFFFFFFFFFL;
+	Tcl_WideInt entryTime = 0x7FFFFFFFFFFFFFFFL;
 
 	if (tsdPtr->relTimerList) {
 	    entryTime = TimerGetDueTime(tsdPtr,
@@ -973,14 +972,6 @@ TimerSetupProc(
 	return;
     }
 
-    /*
-     * If the first timer has expired, stick an event on the queue right now.
-     */
-    if (!tsdPtr->timerPending && entryTime <= 0) {
-	TclSetTimerEventMarker(0);
-	tsdPtr->timerPending = 1;
-    }
-
     Tcl_SetMaxBlockTime(&blockTime);
 }
 
@@ -1015,20 +1006,18 @@ TimerCheckProc(
 
     if (tsdPtr == NULL) { tsdPtr = InitTimer(); };
 
-    /* If already pending (or no timer-events) */
-    if (tsdPtr->timerPending) {
-	return;
-    }
-    if (tsdPtr->promptList) {
+    /* If already pending (or prompt-events) */
+    if (tsdPtr->timerPending || tsdPtr->promptList) {
 	goto mark;
     }
-    if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
-	return;
-    }
 
     /*
      * Verify the first timer on the queue.
      */
+
+    if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
+	return;
+    }
     entryTime = 0x7FFFFFFFFFFFFFFFL;
     now = TclpGetMicroseconds();
     if (tsdPtr->relTimerList) {
@@ -1051,9 +1040,9 @@ TimerCheckProc(
     /*
     * If the first timer has expired, stick an event on the queue.
     */
-    if (!tsdPtr->timerPending && entryTime <= 0) {
+    if (entryTime <= 0) {
   mark:
-	TclSetTimerEventMarker(0);
+	TclSetTimerEventMarker(flags); /* force timer execution */
 	tsdPtr->timerPending = 1;
     }
 }
diff --git a/tests/io.test b/tests/io.test
index 7275b42..c560010 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -2881,7 +2881,8 @@ test io-29.33 {Tcl_Flush, implicit flush on exit} {exec} {
     close $f
     set r
 } "hello\nbye\nstrange\n"
-test io-29.34 {Tcl_Close, async flush on close, using sockets} {socket tempNotMac fileevent} {
+
+proc io-29.34 {wait} {
     variable c 0
     variable x running
     set l abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
@@ -2910,14 +2911,25 @@ test io-29.34 {Tcl_Close, async flush on close, using sockets} {socket tempNotMa
     }
     set ss [socket -server [namespace code accept] -myaddr 127.0.0.1 0]
     set cs [socket 127.0.0.1 [lindex [fconfigure $ss -sockname] 2]]
-    vwait [namespace which -variable x]
+    {*}$wait [namespace which -variable x]
+    if {$x ne "accepted"} {error "timeout, state: $x"}
     fconfigure $cs -blocking off
     writelots $cs $l
     close $cs
     close $ss
-    vwait [namespace which -variable x]
+    {*}$wait [namespace which -variable x]
+    if {$x ne "done"} {error "timeout, state: $x"}
     set c
+}
+test io-29.34.1 {Tcl_Close, async flush on close, using sockets} {socket tempNotMac fileevent} {
+    io-29.34 {vwait 5000}
 } 9000
+
+test io-29.34.2 {same as io-29.34 / IO without timer events} {socket tempNotMac fileevent} {
+    # this test will fail if IO uses timer event for scheduled execution.
+    io-29.34 {vwait -notimer 5000}
+} 9000
+
 test io-29.35 {Tcl_Close vs fileevent vs multiple interpreters} {socket tempNotMac fileevent} {
     # On Mac, this test screws up sockets such that subsequent tests using port 2828
     # either cause errors or panic().
-- 
cgit v0.12


From bb5afa316b0e04d8a04e874a253dabc3babc52de Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:31:53 +0000
Subject: don't cancel scheduled event as long as the event list is not
 bidirectional (too slow by large queue) - rewritten to cancel delayed (by
 execute it).

---
 generic/tclIO.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 8d8f211..9f2a35e 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -2969,7 +2969,11 @@ CloseChannel(
      */
 
     if (statePtr->schedEvent) {
+	/* reset channel in event (cancel delayed) */
+	*(Channel**)(statePtr->schedEvent+1) = NULL;
+#if 0
 	TclpCancelEvent(statePtr->schedEvent);
+#endif
 	statePtr->schedEvent = NULL;
     }
 
@@ -3454,7 +3458,11 @@ Tcl_ClearChannelHandlers(
      */
 
     if (statePtr->schedEvent) {
+	/* reset channel in event (cancel delayed) */
+	*(Channel**)(statePtr->schedEvent+1) = NULL;
+#if 0
 	TclpCancelEvent(statePtr->schedEvent);
+#endif
 	statePtr->schedEvent = NULL;
     }
 
@@ -8105,7 +8113,7 @@ ChannelScheduledProc(
     Channel *chanPtr = *(Channel**)(evPtr+1);
     ChannelState *statePtr; /* State info for channel */
 
-    if (!chanPtr) {
+    if (!chanPtr) { /* channel deleted */
 	return 1;
     }
 
-- 
cgit v0.12


From 39f4dd98cf71565665bae01fadb2e87319dcd6da Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:02 +0000
Subject: Introduced monotonic time as ultimate fix for time-jump issue (fixed
 for windows and unix now, TIP #302 fully implemented now); Usage of monotonic
 time instead of adjustment via timeJump/timeJumpEpoch is more precise and
 effective. New sub-command "clock monotonic" to provide monotonic time
 facility for tcl-level.

---
 generic/tclClock.c  |  38 ++++++++++
 generic/tclEvent.c  |  30 +++-----
 generic/tclInt.h    |   7 +-
 generic/tclNotify.c |  23 ++++++
 generic/tclTimer.c  | 190 +++++++++++++++++++----------------------------
 library/init.tcl    |   2 +-
 unix/tclUnixEvent.c |  30 --------
 unix/tclUnixNotfy.c | 159 ++++++++++++++++++---------------------
 unix/tclUnixTime.c  |  62 +++++++++++++---
 win/tclWinNotify.c  |  79 +++++---------------
 win/tclWinTime.c    | 208 +++++++++++++++++++++++++---------------------------
 11 files changed, 393 insertions(+), 435 deletions(-)

diff --git a/generic/tclClock.c b/generic/tclClock.c
index b019ef9..090eac0 100644
--- a/generic/tclClock.c
+++ b/generic/tclClock.c
@@ -184,6 +184,9 @@ static int		ClockMicrosecondsObjCmd(
 static int		ClockMillisecondsObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
+static int		ClockMonotonicObjCmd(
+                            ClientData clientData, Tcl_Interp *interp,
+                            int objc, Tcl_Obj *const objv[]);
 static int		ClockParseformatargsObjCmd(
 			    ClientData clientData, Tcl_Interp* interp,
 			    int objc, Tcl_Obj *const objv[]);
@@ -212,6 +215,7 @@ static const struct ClockCommand clockCommands[] = {
     { "getenv",			ClockGetenvObjCmd },
     { "microseconds",		ClockMicrosecondsObjCmd },
     { "milliseconds",		ClockMillisecondsObjCmd },
+    { "monotonic",		ClockMonotonicObjCmd },
     { "seconds",		ClockSecondsObjCmd },
     { "Oldscan",		TclClockOldscanObjCmd },
     { "ConvertLocalToUTC",	ClockConvertlocaltoutcObjCmd },
@@ -1816,6 +1820,40 @@ ClockMicrosecondsObjCmd(
     return TCL_OK;
 }
 
+/*----------------------------------------------------------------------
+ *
+ * ClockMonotonicObjCmd -
+ *
+ *      Returns a count of microseconds since some starting point.
+ *      This represents monotonic time not affected from the time-jumps.
+ *
+ * Results:
+ *      Returns a standard Tcl result.
+ *
+ * Side effects:
+ *      None.
+ *
+ * This function implements the 'clock monotonic' Tcl command. Refer to the
+ * user documentation for details on what it does.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+ClockMonotonicObjCmd(
+    ClientData clientData,      /* Client data is unused */
+    Tcl_Interp* interp,         /* Tcl interpreter */
+    int objc,                   /* Parameter count */
+    Tcl_Obj* const* objv)       /* Parameter values */
+{
+    if (objc != 1) {
+	Tcl_WrongNumArgs(interp, 1, objv, NULL);
+	return TCL_ERROR;
+    }
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(TclpGetUTimeMonotonic()));
+    return TCL_OK;
+}
+
 /*
  *-----------------------------------------------------------------------------
  *
diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index dcd7e6b..4bc9219 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -1385,8 +1385,7 @@ Tcl_VwaitObjCmd(
     char *nameString;
     int optc = objc - 2; /* options count without cmd and varname */
     Tcl_WideInt usec = -1;
-    Tcl_WideInt lastNow = 0, wakeup = 0;
-    size_t timeJumpEpoch = 0;
+    Tcl_WideInt now = 0, wakeup = 0;
 
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?options? ?timeout? name");
@@ -1414,12 +1413,14 @@ Tcl_VwaitObjCmd(
 
     done = 0;
 
-    /* if timeout specified - create timer event or no-wait by 0ms */
+    /* 
+     * If timeout specified - create timer event or no-wait by 0ms.
+     * Note the time can be switched (time-jump), so use monotonic time here.
+     */
     if (usec != -1) {
 	if (usec > 0) {
-	    lastNow = TclpGetMicroseconds();
-	    timeJumpEpoch = TclpGetLastTimeJumpEpoch();
-	    wakeup = lastNow + usec;
+	    now = TclpGetUTimeMonotonic();
+	    wakeup = now + usec;
 	} else {
 	    flags |= TCL_DONT_WAIT;
 	}
@@ -1436,20 +1437,11 @@ Tcl_VwaitObjCmd(
     	/* if wait - set blocking time */
 	if (usec > 0) {
 	    Tcl_Time blockTime;
-	    Tcl_WideInt diff, now = TclpGetMicroseconds();
-	    /* 
-	     * Note time can be switched backwards, certainly adjust end-time
-	     * by possible time-jumps back.
-	     */
-	    
-	    if ( (diff = TclpGetLastTimeJump(&timeJumpEpoch)) != 0 
-	      || (diff = (now - lastNow)) < 0
-	    ) {
-		/* recognized time-jump - simply shift wakeup-time */
-		wakeup += diff;
-	    }
+	    Tcl_WideInt diff;
+
+	    now = TclpGetUTimeMonotonic();
+
 	    /* calculate blocking time */
-	    lastNow = now;
 	    diff = wakeup - now;
 	    diff -= 1; /* overhead for this code (e. g. Tcl_TraceVar/Tcl_UntraceVar) */
 	    /* be sure process at least one event */
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 20d89ef..ecfa96a 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2881,13 +2881,12 @@ MODULE_SCOPE double	TclpWideClickInMicrosec(void);
 #     endif
 #   endif
 #endif
-MODULE_SCOPE Tcl_WideInt TclpGetLastTimeJump(size_t *epoch);
-MODULE_SCOPE size_t	 TclpGetLastTimeJumpEpoch(void);
 MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
+MODULE_SCOPE Tcl_WideInt TclpGetUTimeMonotonic(void);
 
 MODULE_SCOPE int	TclpGetUTimeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, 
 			    Tcl_WideInt *timePtr, int factor);
-MODULE_SCOPE Tcl_WideInt TclpScaleUTime(Tcl_WideInt usec);
+MODULE_SCOPE void	TclpScaleUTime(Tcl_WideInt *usec);
 
 MODULE_SCOPE void	TclpUSleep(Tcl_WideInt usec);
 /*
@@ -2915,7 +2914,7 @@ MODULE_SCOPE void	TclpUSleep(Tcl_WideInt usec);
     (1000000*((Tcl_WideInt)(t1).sec - (Tcl_WideInt)(t2).sec) + \
 	    ((long)(t1).usec - (long)(t2).usec))
 #define TCL_TIME_TO_USEC(t) \
-    ((Tcl_WideInt)(t).sec * 1000000 + (t).usec)
+    (((Tcl_WideInt)(t).sec)*1000000 + (t).usec)
 
 static inline void
 TclTimeSetMilliseconds(
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index e6480b2..063954e 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -1465,6 +1465,29 @@ Tcl_ThreadAlert(
 
 
 /*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Sleep --
+ *
+ *	Delay execution for the specified number of milliseconds.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Time passes.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_Sleep(
+    int ms)			/* Number of milliseconds to sleep. */
+{
+    TclpUSleep((Tcl_WideInt)ms * 1000);
+}
+
+/*
  * Local Variables:
  * mode: c
  * c-basic-offset: 4
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 9c80332..074b61d 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -60,8 +60,6 @@ typedef struct AfterAssocData {
  */
 
 typedef struct {
-    Tcl_WideInt knownTime;	/* Last know time */
-    size_t knownTimeJumpEpoch;	/* Epoch of the last time-jump */
     Tcl_WideInt relTimerBase;	/* Time base of the first known relative */
 				/* timer, used to revert all events to the new
 				 * base after possible time-jump (adjustment).*/
@@ -361,7 +359,7 @@ TimerMakeRelativeTime(
     ThreadSpecificData *tsdPtr,
     Tcl_WideInt usec)
 {
-    Tcl_WideInt now = TclpGetMicroseconds();
+    Tcl_WideInt now = TclpGetUTimeMonotonic();
 
     /* 
      * We should have the ability to ajust end-time of relative events,
@@ -374,19 +372,11 @@ TimerMakeRelativeTime(
 	 * end-time = base + relative event-time, which corresponds 
 	 * original end-time.
 	 */
-	Tcl_WideInt diff;
-	if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
-	  || (diff = (tsdPtr->knownTime - now)) < 0
-	) { /* jump recognized */
-	    tsdPtr->relTimerBase += diff; /* shift the base of relative events */
-	}
 	usec += now - tsdPtr->relTimerBase;
     } else {
 	/* first event here - initial values (base/epoch) */
 	tsdPtr->relTimerBase = now;
-	tsdPtr->knownTimeJumpEpoch = TclpGetLastTimeJumpEpoch();
     }
-    tsdPtr->knownTime = now;
 
     return usec;
 }
@@ -850,8 +840,8 @@ TclpProlongTimerEvent(
  *
  * TimerGetDueTime --
  *
- *	Find the execution time of first relative or absolute timer starting
- *	from given heads.
+ *	Find the execution time offset of first relative or absolute timer 
+ *	starting from given heads.
  *
  * Results:
  *	A wide integer representing the due time (as microseconds) of first
@@ -866,33 +856,36 @@ TclpProlongTimerEvent(
 static Tcl_WideInt
 TimerGetDueTime(
     ThreadSpecificData *tsdPtr,
-    TclTimerEvent *relEvent,
-    Tcl_WideInt now)
+    TclTimerEvent *relTimerList,
+    TclTimerEvent *absTimerList,
+    TclTimerEvent **dueEventPtr)
 {
-    /* 
-     * Consider time-jump (especially back) - if the time jumped forwards (and
-     * it recognized) the base can be shifted, but not badly needed, because
-     * event will be nevertheless executed early as specified. But for backwards
-     * jumps it is very important and we should adjust relative base to avoid 
-     * too long waiting for relative events.
-     */
-    Tcl_WideInt diff;
-    if ( (diff = TclpGetLastTimeJump(&tsdPtr->knownTimeJumpEpoch)) != 0
-      || (diff = (now - tsdPtr->knownTime)) < 0 /* switched back */
-    ) {
-	/* 
-	 * If the real jump is unknown (resp. too complex to retrieve
-	 * accross all threads), we simply accept possible small increment
-	 * of the real wait-time.
-	 */
-	tsdPtr->relTimerBase += diff; /* shift the base */
+    TclTimerEvent *tmrEvent;
+    Tcl_WideInt timeOffs = 0x7FFFFFFFFFFFFFFFL;
+
+    /* find shortest due-time */
+    if ((tmrEvent = relTimerList) != NULL) {
+	/* offset to now (monotonic base) */
+	timeOffs = tsdPtr->relTimerBase + tmrEvent->time
+			    - TclpGetUTimeMonotonic();
+    }
+    if (absTimerList) {
+	Tcl_WideInt absOffs;
+	/* offset to now (real-time base) */
+	absOffs = absTimerList->time - TclpGetMicroseconds();
+	if (!tmrEvent || absOffs < timeOffs) {
+	    tmrEvent = absTimerList;
+	    timeOffs = absOffs;
+	}
     }
-    tsdPtr->knownTime = now;
 
-    /* end-time = base + relative event-time */
-    return tsdPtr->relTimerBase + relEvent->time;
+    if (dueEventPtr) {
+	*dueEventPtr = tmrEvent;
+    }
+    return timeOffs;
 }
-
+
+
 /*
  *----------------------------------------------------------------------
  *
@@ -938,30 +931,20 @@ TimerSetupProc(
 	/*
 	 * Compute the timeout for the next timer on the list.
 	 */
+	Tcl_WideInt timeOffs;
 
-	Tcl_WideInt now = TclpGetMicroseconds();
-	Tcl_WideInt entryTime = 0x7FFFFFFFFFFFFFFFL;
-
-	if (tsdPtr->relTimerList) {
-	    entryTime = TimerGetDueTime(tsdPtr,
-	    	tsdPtr->relTimerList, now);
-	}
-	/* if absolute timer before */
-	if (tsdPtr->absTimerList && tsdPtr->absTimerList->time < entryTime) {
-	    entryTime = tsdPtr->absTimerList->time;
-	}
-	/* as offset to now */
-	entryTime -= now;
+	timeOffs = TimerGetDueTime(tsdPtr,
+			tsdPtr->relTimerList, tsdPtr->absTimerList, NULL);
 
 	#ifdef TMR_RES_TOLERANCE
 	    /* consider timer resolution tolerance (avoid busy wait) */
-	    entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
+	    timeOffs -= ((timeOffs <= 1000000) ? timeOffs : 1000000) *
 				TMR_RES_TOLERANCE / 100;
 	#endif
 
-	if (entryTime > 0) {
-	    blockTime.sec = (long) (entryTime / 1000000);
-	    blockTime.usec = (unsigned long) (entryTime % 1000000);
+	if (timeOffs > 0) {
+	    blockTime.sec = (long) (timeOffs / 1000000);
+	    blockTime.usec = (unsigned long) (timeOffs % 1000000);
 
 	} else {
 	    blockTime.sec = 0;
@@ -997,7 +980,7 @@ TimerCheckProc(
     ClientData data,		/* Specific data. */
     int flags)			/* Event flags as passed to Tcl_DoOneEvent. */
 {
-    Tcl_WideInt now, entryTime = 0;
+    Tcl_WideInt timeOffs = 0;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)data;
 
     if (!(flags & TCL_TIMER_EVENTS)) {
@@ -1018,29 +1001,20 @@ TimerCheckProc(
     if (!tsdPtr->relTimerList && !tsdPtr->absTimerList) {
 	return;
     }
-    entryTime = 0x7FFFFFFFFFFFFFFFL;
-    now = TclpGetMicroseconds();
-    if (tsdPtr->relTimerList) {
-	entryTime = TimerGetDueTime(tsdPtr,
-	tsdPtr->relTimerList, now);
-    }
-    /* if absolute timer before */
-    if (tsdPtr->absTimerList && tsdPtr->absTimerList->time < entryTime) {
-	entryTime = tsdPtr->absTimerList->time;
-    }
-    /* as offset to now */
-    entryTime -= now;
-    
+
+    timeOffs = TimerGetDueTime(tsdPtr,
+			tsdPtr->relTimerList, tsdPtr->absTimerList, NULL);
+
 #ifdef TMR_RES_TOLERANCE
     /* consider timer resolution tolerance (avoid busy wait) */
-    entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
+    timeOffs -= ((timeOffs <= 1000000) ? timeOffs : 1000000) *
 			TMR_RES_TOLERANCE / 100;
 #endif
    
     /*
     * If the first timer has expired, stick an event on the queue.
     */
-    if (entryTime <= 0) {
+    if (timeOffs <= 0) {
   mark:
 	TclSetTimerEventMarker(flags); /* force timer execution */
 	tsdPtr->timerPending = 1;
@@ -1147,25 +1121,18 @@ TclServiceTimerEvents(void)
     relTimerList = tsdPtr->relTimerList;
     absTimerList = tsdPtr->absTimerList;
     while (relTimerList || absTimerList) {
-    	Tcl_WideInt entryTime = 0x7FFFFFFFFFFFFFFFL;
-	Tcl_WideInt now = TclpGetMicroseconds();
-	/* find shortest due-time */
-	if ((tmrEvent = relTimerList) != NULL) {
-	    entryTime = TimerGetDueTime(tsdPtr, tmrEvent, now);
-	}
-	if (absTimerList && (!tmrEvent || absTimerList->time < entryTime)) {
-	    tmrEvent = absTimerList;
-	    entryTime = absTimerList->time;
-	}
-	/* offset to now */
-	entryTime -= now;
+	Tcl_WideInt timeOffs;
+
+	/* find timer (absolute/relative) with shortest due-time */
+	timeOffs = TimerGetDueTime(tsdPtr,
+			relTimerList, absTimerList, &tmrEvent);
     	/* the same tolerance logic as in TimerSetupProc/TimerCheckProc */
     #ifdef TMR_RES_TOLERANCE
-	entryTime -= ((entryTime <= 1000000) ? entryTime : 1000000) *
+	timeOffs -= ((timeOffs <= 1000000) ? timeOffs : 1000000) *
 				TMR_RES_TOLERANCE / 100;
     #endif
 	/* still not reached */
-	if (entryTime > 0) {
+	if (timeOffs > 0) {
 	    break;
 	}
 
@@ -1788,9 +1755,8 @@ AfterDelay(
 {
     Interp *iPtr = (Interp *) interp;
 
-    Tcl_WideInt endTime, now, lastNow, diff;
+    Tcl_WideInt endTime, now, diff, limOffs = 0x7FFFFFFFFFFFFFFFL;
     long tolerance = 0;
-    size_t timeJumpEpoch = 0;
 
     if (usec <= 0) {
 	/* to cause a context switch only */
@@ -1803,61 +1769,55 @@ AfterDelay(
     tolerance = ((usec < 1000000) ? usec : 1000000) * TMR_RES_TOLERANCE / 100;
 #endif
 
-    lastNow = now = TclpGetMicroseconds();
-    endTime = usec;
-    timeJumpEpoch = TclpGetLastTimeJumpEpoch();
-
     if (!absolute) {
-	endTime += now;
-	if (endTime < now) { /* overflow */
+	/*
+	 * Note the time can be switched (time-jump), so use monotonic time here.
+	 */
+	now = TclpGetUTimeMonotonic();
+	if ((endTime = (now + usec)) < now) { /* overflow */
 	    endTime = 0x7FFFFFFFFFFFFFFFL;
 	}
+    } else {
+	now = TclpGetMicroseconds();
+	endTime = usec;
     }
-
     do {
 	if ( iPtr->limit.timeEvent != NULL
-	  && now > TCL_TIME_TO_USEC(iPtr->limit.time)
+	  && (limOffs = (TCL_TIME_TO_USEC(iPtr->limit.time)
+				- TclpGetMicroseconds())) <= 0
 	) {
 	    iPtr->limit.granularityTicker = 0;
 	    if (Tcl_LimitCheck(interp) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	}
-	if ( iPtr->limit.timeEvent == NULL
-	  || endTime < (diff = TCL_TIME_TO_USEC(iPtr->limit.time))
-	) {
-	    diff = endTime - now;
+	diff = endTime - now;
+	if (iPtr->limit.timeEvent == NULL || diff < limOffs) {
 	    if (diff > 0) {
 		TclpUSleep(diff);
-		now = TclpGetMicroseconds();
+		if (!absolute) {
+		    now = TclpGetUTimeMonotonic();
+		} else {
+		    now = TclpGetMicroseconds();
+		}
 	    }
 	} else {
-	    diff -= now;
+	    diff = limOffs;
 	    if (diff > 0) {
 		TclpUSleep(diff);
-		now = TclpGetMicroseconds();
+		if (!absolute) {
+		    now = TclpGetUTimeMonotonic();
+		} else {
+		    now = TclpGetMicroseconds();
+		}
 	    }
 	    if (Tcl_LimitCheck(interp) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	}
 
-	/* 
-	 * Note time can be switched backwards, certainly adjust end-time
-	 * by possible time-jumps (for relative sleep).
-	 */
-	if (!absolute
-	  && ( (diff = TclpGetLastTimeJump(&timeJumpEpoch)) != 0 
-	    || (diff = (now - lastNow)) < 0
-	  )
-	) {
-	    /* recognized time-jump - simply shift wakeup-time */
-	    endTime += diff;
-	}
-	lastNow = now;
-
 	/* consider timer resolution tolerance (avoid busy wait) */
-    } while (now < endTime);
+    } while (now < endTime - tolerance);
     return TCL_OK;
 }
 
diff --git a/library/init.tcl b/library/init.tcl
index aaf148b..ac00b2f 100644
--- a/library/init.tcl
+++ b/library/init.tcl
@@ -177,7 +177,7 @@ if {[interp issafe]} {
 	namespace eval ::tcl::clock [list namespace ensemble create -command \
 		[uplevel 1 [list namespace origin [lindex [info level 0] 0]]] \
 		-subcommands {
-		    add clicks format microseconds milliseconds scan seconds
+		    add clicks format microseconds milliseconds monotonic scan seconds
 		}]
 
 	# Auto-loading stubs for 'clock.tcl'
diff --git a/unix/tclUnixEvent.c b/unix/tclUnixEvent.c
index 7e75357..f24c9d1 100644
--- a/unix/tclUnixEvent.c
+++ b/unix/tclUnixEvent.c
@@ -13,36 +13,6 @@
 #ifndef HAVE_COREFOUNDATION	/* Darwin/Mac OS X CoreFoundation notifier is
 				 * in tclMacOSXNotify.c */
 
-/* declaration of TclpSleep() from tclUnixNotfy.c */
-void	TclpSleep(const Tcl_Time *timePtr);
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_Sleep --
- *
- *	Delay execution for the specified number of milliseconds.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Time passes.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_Sleep(
-    int ms)			/* Number of milliseconds to sleep. */
-{
-    Tcl_Time delay;
-
-    delay.sec = ms/1000;
-    delay.usec = (ms%1000)*1000;
-    TclpSleep(&delay);
-}
-
 #endif /* HAVE_COREFOUNDATION */
 /*
  * Local Variables:
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index a5ee159..f213ec5 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -845,9 +845,9 @@ NotifierProc(
 /*
  *----------------------------------------------------------------------
  *
- * TclpSleep --
+ * TclpUSleep --
  *
- *	Delay execution for the specified time.
+ *	Delay execution for the specified time (in microseconds).
  *
  * Results:
  *	None.
@@ -859,67 +859,68 @@ NotifierProc(
  */
 
 void
-TclpSleep(
-    const Tcl_Time *timePtr)	/* Time to sleep. */
+TclpUSleep(
+    Tcl_WideInt usec)	/* Time to sleep. */
 {
-    struct timeval delay;
-    Tcl_Time before, after, vdelay;
+    Tcl_WideInt now, desired, sleepTime;
 
+    if (usec < 0) {
+	usec = 0;
+    }
     /*
      * The only trick here is that select appears to return early under some
      * conditions, so we have to check to make sure that the right amount of
      * time really has elapsed.  If it's too early, go back to sleep again.
+     *
+     * Note the time can be switched (time-jump), so use monotonic time here.
      */
 
-    Tcl_GetTime(&before);
-    after = before;
-    if (timePtr) { /* if given calculate, otherwise - 0 usec */
+    now = TclpGetUTimeMonotonic();
+    if ((desired = (now + usec)) < now) { /* overflow */
+	desired = 0x7FFFFFFFFFFFFFFFL;
+    }
 
+    while (1) {
+	
 	/*
 	 * TIP #233: Scale from virtual time to real-time for select/usleep.
 	 */
+	TclpScaleUTime(&usec);
 
-	vdelay = *timePtr;
-	if ((vdelay.sec != 0) || (vdelay.usec != 0)) {
-	    tclScaleTimeProcPtr(&vdelay, tclTimeClientData);
-	}
+	if (usec >= TCL_TMR_MIN_DELAY) {
 
-	after.sec += vdelay.sec;
-	after.usec += vdelay.usec;
-	if (after.usec > 1000000) {
-	    after.usec -= 1000000;
-	    after.sec += 1;
-	}
-    }
-    while (1) {
-	vdelay.sec  = after.sec  - before.sec;
-	vdelay.usec = after.usec - before.usec;
+	    struct timeval delay;
 
-	if (vdelay.usec < 0) {
-	    vdelay.usec += 1000000;
-	    vdelay.sec  -= 1;
-	}
+	    delay.tv_sec  = usec / 1000000;
+	    delay.tv_usec = usec % 1000000;
 
-	delay.tv_sec  = vdelay.sec;
-	delay.tv_usec = vdelay.usec;
+	    sleepTime = usec;
+	    (void) select(0, (SELECT_MASK *) 0, (SELECT_MASK *) 0,
+		(SELECT_MASK *) 0, &delay);
 
-	/*
-	 * Special note: must convert delay.tv_sec to int before comparing to
-	 * zero, since delay.tv_usec is unsigned on some platforms.
-	 */
+	} else if (usec >= TCL_TMR_MIN_SLEEP) {
+	    sleepTime = usec - TCL_TMR_MIN_SLEEP;
+	    usleep(sleepTime);
+	} else {
+	    /* nanosleep has the same minimal sleep interval as usleep */
+#if 1
+	    sleepTime = 0;
+#else
+	    struct timespec delay;
 
-	if ((((int) delay.tv_sec) < 0)
-		|| ((delay.tv_usec == 0) && (delay.tv_sec == 0))) {
-	    break;
+	    delay.tv_sec  = usec / 1000000;
+	    delay.tv_nsec = (usec % 1000000) * 1000; /* usec to nsec */
+
+	    sleepTime = usec;
+	    nanosleep(&delay, NULL);
+#endif
 	}
+	
+	now = TclpGetUTimeMonotonic();
 
-	if (delay.tv_sec || delay.tv_usec >= TCL_TMR_MIN_DELAY) {
-	    (void) select(0, (SELECT_MASK *) 0, (SELECT_MASK *) 0,
-		(SELECT_MASK *) 0, &delay);
-	} else if (delay.tv_usec >= TCL_TMR_MIN_SLEEP) {
-	    usleep(delay.tv_usec - TCL_TMR_MIN_SLEEP);
+	if ((usec = (desired - now)) <= 0 /* or tolerance */) {
+	    break;
 	}
-	Tcl_GetTime(&before);
     }
 }
 
@@ -947,7 +948,7 @@ Tcl_WaitForEvent(
 {
     FileHandler *filePtr;
     int mask, canWait = 1;
-    Tcl_Time now, endTime, waitTime;
+    Tcl_WideInt endTime = 0, waitTime = 0;
 #ifdef TCL_THREADS
     int waitForFiles = 0;
 #ifdef __CYGWIN__
@@ -969,8 +970,6 @@ Tcl_WaitForEvent(
 	return tclStubs.tcl_WaitForEvent(timePtr);
     }
 
-    Tcl_GetTime(&now);
-
     tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
@@ -981,13 +980,13 @@ Tcl_WaitForEvent(
 
     if (timePtr != NULL) {
 
-	endTime = now;
-	endTime.sec += timePtr->sec;
-	endTime.usec += timePtr->usec;
-	if (endTime.usec > 1000000) {
-	    endTime.usec -= 1000000;
-	    endTime.sec++;
-	}
+	waitTime = TCL_TIME_TO_USEC(*timePtr);
+
+	/*
+	 * Note the time can be switched (time-jump), so use monotonic time here.
+	 */
+	endTime = TclpGetUTimeMonotonic() + waitTime;
+
 	/* 
 	 * If short wait or no wait at all, just process events already available
 	 * right now, avoid waiting too long somewhere (NRT-capability fix).
@@ -1076,25 +1075,14 @@ Tcl_WaitForEvent(
     while (!tsdPtr->eventReady) {
 
 	if (timePtr) {
-	    Tcl_GetTime(&now);
-	    waitTime = endTime;
-	    waitTime.sec -= now.sec;
-	    waitTime.usec -= now.usec;
-	    if (waitTime.usec < 0) {
-		waitTime.usec += 1000000;
-		waitTime.sec--;
-	    }
-	
-	    if (now.sec > endTime.sec) {
+
+	    waitTime = endTime - TclpGetUTimeMonotonic();
+
+	    if (waitTime <= 0) {
 		break; /* end of wait */
 	    }
-	    if (now.sec == endTime.sec) {
-	    	if (now.usec > endTime.usec) {
-		    break; /* end of wait */
-	    	}
-		if (now.usec > endTime.usec + TCL_TMR_OVERHEAD) {
-		    canWait = 0;
-		}
+	    if (waitTime <= TCL_TMR_OVERHEAD) {
+		canWait = 0;
 	    }
 	}
 
@@ -1104,9 +1092,9 @@ Tcl_WaitForEvent(
 
 	    if (timePtr) {
 		/* TIP #233: Scale from virtual time to real-time  */
-		tclScaleTimeProcPtr(&waitTime, tclTimeClientData);
+		TclpScaleUTime(&waitTime);
 
-		timeout = waitTime.sec * 1000 + waitTime.usec / 1000;
+		timeout = waitTime / 1000;
 	    } else {
 		timeout = 0xFFFFFFFF;
 	    }
@@ -1118,28 +1106,23 @@ Tcl_WaitForEvent(
 	/* prevent too long waiting (NRT-capability) */
 	if ( !canWait ) {
 	    /* short sleep */
-	    TclpSleep(&waitTime);
+	    TclpUSleep(waitTime);
 	    break; /* end of wait */
 	}
 	else
 	if (timePtr) {
 	    struct timespec ptime;
 
-#if 1
 	    /* TIP #233: Scale from virtual time to real-time  */
-	    tclScaleTimeProcPtr(&waitTime, tclTimeClientData);
+	    TclpScaleUTime(&waitTime);
 
-	    ptime.tv_sec = now.sec;
-	    ptime.tv_nsec = (now.usec + waitTime.usec);
-	    if (ptime.tv_nsec > 1000000) {
-		ptime.tv_nsec -= 1000000;
+	    clock_gettime(CLOCK_REALTIME, &ptime);
+	    ptime.tv_sec += waitTime / 1000000;
+	    ptime.tv_nsec += (waitTime % 1000000) * 1000;
+	    if (ptime.tv_nsec > 1000000*1000) {
+		ptime.tv_nsec -= 1000000*1000;
 		ptime.tv_sec++;
 	    }
-	    ptime.tv_nsec *= 1000; /* usec to nsec */
-#else
-	    ptime.tv_sec = endTime.sec;
-	    ptime.tv_nsec = 1000 * endTime.usec;
-#endif
 
 #if defined(__APPLE__) && defined(__LP64__)
 	    /*
@@ -1149,24 +1132,22 @@ Tcl_WaitForEvent(
 	     * time; as a workaround, when given a very brief timeout,
 	     * just increment a bit the waiting-time from now. [Bug 1457797]
 	     */
-	    if ( now.sec > endTime.sec 
-	     || (now.sec == endTime.sec && now.usec > endTime.usec)
-	    ) {
+	    if (waitTime <= 0) {
 		ptime.tv_sec = now.sec;
 		ptime.tv_nsec = 1000 * now.usec + 10; /* + 10 nanosecond */
 	    }
 #else
 	    /* remove overhead in nsec */
 	    if (ptime.tv_nsec < TCL_TMR_OVERHEAD * 1000) {
-	    	ptime.tv_nsec += 1000000000;
+	    	ptime.tv_nsec += 1000000*1000;
 	    	ptime.tv_sec--;
 	    }
 	    ptime.tv_nsec -= TCL_TMR_OVERHEAD * 1000;
 	    
 #endif /* __APPLE__ && __LP64__ */
 
-	    if (ptime.tv_nsec > 1000000000) {
-		ptime.tv_nsec -= 1000000000;
+	    if (ptime.tv_nsec > 1000000*1000) {
+		ptime.tv_nsec -= 1000000*1000;
 		ptime.tv_sec++;
 	    }
 	    if (pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex,
diff --git a/unix/tclUnixTime.c b/unix/tclUnixTime.c
index 7f22fab..f50a66f 100644
--- a/unix/tclUnixTime.c
+++ b/unix/tclUnixTime.c
@@ -104,10 +104,54 @@ TclpGetSeconds(void)
 Tcl_WideInt
 TclpGetMicroseconds(void)
 {
-    Tcl_Time time;
+    if (tclGetTimeProcPtr == NativeGetTime) {
+	struct timeval tv;
+
+	(void) gettimeofday(&tv, NULL);
+	return ((Tcl_WideInt)tv.tv_sec)*1000000 + tv.tv_usec;
+    } else {
+	Tcl_Time time;
+
+	tclGetTimeProcPtr(&time, tclTimeClientData);
+	return ((Tcl_WideInt)time.sec)*1000000 + time.usec;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpGetUTimeMonotonic --
+ *
+ *	This procedure returns the number of microseconds from some unspecified
+ *	starting point.
+ *	This time is monotonic (not affected by the time-jumps), so can be used
+ *	for relative wait purposes and relative time calculation.
+ *
+ * Results:
+ *	Monotonic time in microseconds.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_WideInt
+TclpGetUTimeMonotonic(void)
+{
+    struct timespec mntv;
+    if ( tclGetTimeProcPtr == NativeGetTime
+      && clock_gettime(CLOCK_MONOTONIC, &mntv) == 0
+    ) {
+	/* monotonic time since some starting point in microseconds */
+	return ((Tcl_WideInt)mntv.tv_sec)*1000000 + mntv.tv_nsec / 1000;
+    } else {
+    	/* fallback via tclGetTimeProcPtr */
+	Tcl_Time time;
 
-    tclGetTimeProcPtr(&time, tclTimeClientData);
-    return ((Tcl_WideInt)time.sec)*1000000 + time.usec;
+	tclGetTimeProcPtr(&time, tclTimeClientData);
+	return ((Tcl_WideInt)time.sec)*1000000 + time.usec;
+    }
 }
 
 /*
@@ -641,19 +685,19 @@ NativeScaleTime(
  *
  *----------------------------------------------------------------------
  */
-Tcl_WideInt
+void
 TclpScaleUTime(
-    Tcl_WideInt usec)
+    Tcl_WideInt *usec)
 {
     /* Native scale is 1:1. */
     if (tclScaleTimeProcPtr != NativeScaleTime) {
-	return usec;
+	return;
     } else {
 	Tcl_Time scTime;
-	scTime.sec = usec / 1000000;
-	scTime.usec = usec % 1000000;
+	scTime.sec = *usec / 1000000;
+	scTime.usec = *usec % 1000000;
 	tclScaleTimeProcPtr(&scTime, tclTimeClientData);
-	return ((Tcl_WideInt)scTime.sec) * 1000000 + scTime.usec;
+	*usec = ((Tcl_WideInt)scTime.sec) * 1000000 + scTime.usec;
     }
 }
 
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index bd3b384..d0d2560 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -634,10 +634,9 @@ Tcl_WaitForEvent(
     DWORD timeout = INFINITE, result = WAIT_TIMEOUT;
     int status = 0;
     Tcl_WideInt waitTime = 0;
-    Tcl_WideInt lastNow = 0, endTime = 0;
+    Tcl_WideInt endTime = 0;
     long tolerance = 0;
     unsigned long actualResolution = 0;
-    size_t timeJumpEpoch = 0;
 
     /*
      * Allow the notifier to be hooked. This may not make sense on windows,
@@ -654,7 +653,7 @@ Tcl_WaitForEvent(
 
     if (timePtr) {
 
-	waitTime = timePtr->sec * 1000000 + timePtr->usec;
+	waitTime = TCL_TIME_TO_USEC(*timePtr);
 
 	/* if no wait */
 	if (waitTime <= 0) {
@@ -662,10 +661,10 @@ Tcl_WaitForEvent(
 	    goto peek;
 	}
 
-	/* calculate end of wait */
-	lastNow = TclpGetMicroseconds();
-	endTime = lastNow + waitTime;
-	timeJumpEpoch = TclpGetLastTimeJumpEpoch();
+	/*
+	 * Note the time can be switched (time-jump), so use monotonic time here.
+	 */
+	endTime = TclpGetUTimeMonotonic() + waitTime;
 
 	if (timerResolution.available == -1) {
 	    InitTimerResolution();
@@ -685,7 +684,7 @@ Tcl_WaitForEvent(
 	* TIP #233 (Virtualized Time). Convert virtual domain delay to
 	* real-time.
 	*/
-	waitTime = TclpScaleUTime(waitTime);
+	TclpScaleUTime(&waitTime);
 
 	/* No wait if timeout too small (because windows may wait too long) */
 	if (waitTime < (long)timerResolution.minDelay) {
@@ -789,27 +788,8 @@ Tcl_WaitForEvent(
     else
     if (result == WAIT_TIMEOUT && timeout != INFINITE) {
 	/* Check the wait should be repeated, and correct time for wait */
-	Tcl_WideInt now;
-
-	now = TclpGetMicroseconds();
-	/* 
-	 * Note time can be switched backwards, certainly adjust end-time
-	 * by possible time-jumps.
-	 */
-	if ((waitTime = TclpGetLastTimeJump(&timeJumpEpoch)) != 0) {
-	    /* we know time-jump, adjust end-time using this offset */
-	    endTime += waitTime;
-	}
-	else
-	if ((waitTime = (now - lastNow)) < 0) {
-	    /* recognized backwards time-jump - simply shift wakeup-time *
-	     * considering timeout also, assume we've reached it completely */
-	    endTime += (waitTime - (timeout * 1000));
-	}
-	lastNow = now;
 
-	/* calculate new waitTime */
-	waitTime = endTime - now;
+	waitTime = endTime - TclpGetUTimeMonotonic();
 	if (waitTime <= tolerance) {
 	    goto end;
 	}
@@ -831,9 +811,9 @@ Tcl_WaitForEvent(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_Sleep --, TclpUSleep --
+ * TclpUSleep --
  *
- *	Delay execution for the specified number of milliseconds (or microsec.).
+ *	Delay execution for the specified number of microseconds.
  *
  *	TclpUSleep in contrast to Tcl_Sleep is more precise (microseconds).
  *
@@ -847,13 +827,6 @@ Tcl_WaitForEvent(
  */
 
 void
-Tcl_Sleep(
-    int ms)			/* Number of milliseconds to sleep. */
-{
-    TclpUSleep((Tcl_WideInt)ms * 1000);
-}
-
-void
 TclpUSleep(
     Tcl_WideInt usec)		/* Number of microseconds to sleep. */
 {
@@ -867,12 +840,10 @@ TclpUSleep(
      * requisite amount.
      */
 
-    Tcl_WideInt lastNow, now;	/* Current wall clock time. */
     Tcl_WideInt desired;	/* Desired wakeup time. */
     DWORD sleepTime;		/* Time to sleep, real-time */
     long tolerance = 0;
     unsigned long actualResolution = 0;
-    size_t timeJumpEpoch = 0;
 
     if (usec <= 9) { /* too short to start whole sleep process */
 	do {
@@ -886,9 +857,10 @@ TclpUSleep(
 	InitTimerResolution();
     }
 
-    lastNow = now = TclpGetMicroseconds();
-    desired = now + usec;
-    timeJumpEpoch = TclpGetLastTimeJumpEpoch();
+    /*
+     * Note the time can be switched (time-jump), so use monotonic time here.
+     */
+    desired = TclpGetUTimeMonotonic() + usec;
 
   #ifdef TMR_RES_TOLERANCE
     /* calculate possible maximal tolerance (in usec) of original wait-time */
@@ -904,7 +876,7 @@ TclpUSleep(
 	/*
 	 * TIP #233: Scale delay from virtual to real-time.
 	 */
-	usec = TclpScaleUTime(usec);
+	TclpScaleUTime(&usec);
 
 	/* No wait if sleep time too small (because windows may wait too long) */
 	if (usec < (long)timerResolution.minDelay) {
@@ -940,24 +912,11 @@ TclpUSleep(
 
     wait:
 	Sleep(sleepTime);
-	now = TclpGetMicroseconds();
-	/* 
-	 * Note time can be switched backwards, certainly adjust end-time
-	 * by possible time-jumps.
-	 */
-	if ((usec = TclpGetLastTimeJump(&timeJumpEpoch)) != 0) {
-	    /* we know time-jump, adjust end-time using this offset */
-	    desired += usec;
-	}
-	else
-	if ((usec = (now - lastNow)) < 0) {
-	    /* recognized backwards time-jump - simply shift wakeup-time *
-	     * considering sleep-time also, assume we've reached it completely */
-	    desired += (usec - (sleepTime * 1000));
-	}
-	lastNow = now;
 
-	if ((usec = (desired - now)) <= tolerance) {
+	/* new difference to now (monotonic base) */
+	usec = desired - TclpGetUTimeMonotonic();
+	
+	if (usec <= tolerance) {
 	    break;
 	}
     }
diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index 4835bf1..1dbcc27 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -44,6 +44,7 @@ static Tcl_ThreadDataKey dataKey;
 typedef struct TimeCalibInfo {
     LONGLONG perfCounter;	/* QPC value of last calibrated virtual time */
     Tcl_WideInt virtTimeBase;	/* Last virtual time base (in 100-ns) */
+    Tcl_WideInt monoTimeBase;	/* Last monotonic time base (in 100-ns) */
     Tcl_WideInt sysTime;	/* Last real system time (in 100-ns),
 				   truncated to VT_SYSTMR_DIST (100ms) */
 } TimeCalibInfo;
@@ -101,10 +102,8 @@ typedef struct TimeInfo {
 				 * calibration process. */
     volatile LONG lastCIEpoch;	/* Calibration epoch (increased each 100ms) */
     
-    size_t lastUsedTime;	/* Last known (caller) offset to virtual time
+    size_t lastUsedTime;	/* Last known (caller) offset to time base
 				 * (used to avoid back-drifts after calibrate) */
-    size_t lastTimeJumpEpoch;	/* Last known epoch since last time-jump. */
-    Tcl_WideInt lastTimeJump;	/* Last known time-jump of thread. */
 } TimeInfo;
 
 static TimeInfo timeInfo = {
@@ -147,7 +146,7 @@ static struct {
 static struct tm *	ComputeGMT(const time_t *tp);
 static void		NativeScaleTime(Tcl_Time* timebuf,
 			    ClientData clientData);
-static Tcl_WideInt	NativeGetMicroseconds(void);
+static Tcl_WideInt	NativeGetMicroseconds(int monotonic);
 static void		NativeGetTime(Tcl_Time* timebuf,
 			    ClientData clientData);
 
@@ -189,13 +188,15 @@ NativePerformanceCounter(void) {
 /*
  *----------------------------------------------------------------------
  *
- * NativeCalc100NsTicks --
+ * NativeCalc100NsOffs --
  *
- *	Calculate the current system time in 100-ns ticks since posix epoch,
+ *	Calculate the current system time in 100-ns ticks since some base,
  *	for current performance counter (curCounter), using given calibrated values.
  *
- *	vt = lastCI.virtTimeBase
- *		+ (curCounter - lastCI.perfCounter) * 10000000 / nominalFreq
+ *	offs = (curCounter - lastCI.perfCounter) * 10000000 / nominalFreq
+ *
+ *	vt = lastCI.virtTimeBase + offs
+ *	mt = lastCI.monoTimeBase + offs
  *
  * Results:
  *	Returns the wide integer with number of 100-ns ticks from the epoch.
@@ -207,17 +208,16 @@ NativePerformanceCounter(void) {
  */
 
 static inline Tcl_WideInt
-NativeCalc100NsTicks(
-    ULONGLONG ciVirtTimeBase,
+NativeCalc100NsOffs(
     LONGLONG ciPerfCounter,
     LONGLONG curCounter
 ) {
     curCounter -= ciPerfCounter; /* current distance */
     if (!curCounter) {
-    	return ciVirtTimeBase; /* virtual time without offset */
+    	return 0; /* virtual time without offset */
     }
     /* virtual time with offset */
-    return ciVirtTimeBase + curCounter * 10000000 / timeInfo.nominalFreq;
+    return curCounter * 10000000 / timeInfo.nominalFreq;
 }
 
 /*
@@ -256,13 +256,9 @@ GetSystemTimeAsVirtual(void)
 unsigned long
 TclpGetSeconds(void)
 {
-    Tcl_WideInt usecSincePosixEpoch;
-
     /* Try to use high resolution timer */
-    if ( tclGetTimeProcPtr == NativeGetTime
-      && (usecSincePosixEpoch = NativeGetMicroseconds())
-    ) {
-	return usecSincePosixEpoch / 1000000;
+    if (tclGetTimeProcPtr == NativeGetTime) {
+	return NativeGetMicroseconds(0) / 1000000;
     } else {
 	Tcl_Time t;
 
@@ -293,13 +289,9 @@ TclpGetSeconds(void)
 unsigned long
 TclpGetClicks(void)
 {
-    Tcl_WideInt usecSincePosixEpoch;
-
     /* Try to use high resolution timer */
-    if ( tclGetTimeProcPtr == NativeGetTime
-      && (usecSincePosixEpoch = NativeGetMicroseconds())
-    ) {
-	return (unsigned long)usecSincePosixEpoch;
+    if (tclGetTimeProcPtr == NativeGetTime) {
+	return (unsigned long)NativeGetMicroseconds(1);
     } else {
 	/*
 	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
@@ -416,10 +408,9 @@ TclpWideClickInMicrosec(void)
 Tcl_WideInt 
 TclpGetMicroseconds(void)
 {
-#if 1
     /* Use high resolution timer if possible */
     if (tclGetTimeProcPtr == NativeGetTime) {
-    	return NativeGetMicroseconds();
+    	return NativeGetMicroseconds(0);
     } else {
 	/*
 	 * Use the Tcl_GetTime abstraction to get the time in microseconds, as
@@ -431,18 +422,31 @@ TclpGetMicroseconds(void)
 	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
 	return TCL_TIME_TO_USEC(now);
     }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpGetMicroseconds --
+ *
+ *	This procedure returns a WideInt value that represents the highest
+ *	resolution clock in microseconds available on the system.
+ *
+ * Results:
+ *	Number of microseconds (from the epoch).
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
 
-#else
-    static Tcl_WideInt prevUS = 0;
-
-    Tcl_WideInt usecSincePosixEpoch;
-
-    /* Try to use high resolution timer */
+Tcl_WideInt 
+TclpGetUTimeMonotonic(void)
+{
+    /* Use high resolution timer if possible */
     if (tclGetTimeProcPtr == NativeGetTime) {
-	if ( !(usecSincePosixEpoch = NativeGetMicroseconds()) ) {
-	    usecSincePosixEpoch = GetSystemTimeAsVirtual() / 10; /* in 100-ns */
-	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!no-native-ms!!!!!!!!!!!\n");
-	}
+    	return NativeGetMicroseconds(1); /* monotonic based time */
     } else {
 	/*
 	 * Use the Tcl_GetTime abstraction to get the time in microseconds, as
@@ -452,18 +456,8 @@ TclpGetMicroseconds(void)
 	Tcl_Time now;
 
 	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
-	usecSincePosixEpoch = (((Tcl_WideInt)now.sec) * 1000000) + now.usec;
-	printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!no-native-ms!!!!!!!!!!!\n");
+	return TCL_TIME_TO_USEC(now);
     }
-
-    	if (prevUS && usecSincePosixEpoch < prevUS) {
-	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! prev: %I64d - now: %I64d (%I64d usec)\n", prevUS, usecSincePosixEpoch, usecSincePosixEpoch - prevUS);
-	    Tcl_Panic("Time running backwards!!!");
-    	}
-    	prevUS = usecSincePosixEpoch;
-
-	return usecSincePosixEpoch;
-#endif
 }
 
 /*
@@ -521,14 +515,11 @@ void
 Tcl_GetTime(
     Tcl_Time *timePtr)		/* Location to store time information. */
 {
-    Tcl_WideInt usecSincePosixEpoch;
-
     /* Try to use high resolution timer */
-    if ( tclGetTimeProcPtr == NativeGetTime
-      && (usecSincePosixEpoch = NativeGetMicroseconds())
-    ) {
-	timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
-	timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
+    if ( tclGetTimeProcPtr == NativeGetTime) {
+    	Tcl_WideInt now = NativeGetMicroseconds(0);
+	timePtr->sec = (long) (now / 1000000);
+	timePtr->usec = (unsigned long) (now % 1000000);
     } else {
     	tclGetTimeProcPtr(timePtr, tclTimeClientData);
     }
@@ -573,19 +564,19 @@ NativeScaleTime(
  *
  *----------------------------------------------------------------------
  */
-Tcl_WideInt
+void
 TclpScaleUTime(
-    Tcl_WideInt usec)
+    Tcl_WideInt *usec)
 {
     /* Native scale is 1:1. */
-    if (tclScaleTimeProcPtr == NativeScaleTime) {
-	return usec;
+    if (tclScaleTimeProcPtr != NativeScaleTime) {
+	return;
     } else {
 	Tcl_Time scTime;
-	scTime.sec = usec / 1000000;
-	scTime.usec = usec % 1000000;
+	scTime.sec = *usec / 1000000;
+	scTime.usec = *usec % 1000000;
 	tclScaleTimeProcPtr(&scTime, tclTimeClientData);
-	return ((Tcl_WideInt)scTime.sec) * 1000000 + scTime.usec;
+	*usec = ((Tcl_WideInt)scTime.sec) * 1000000 + scTime.usec;
     }
 }
 
@@ -613,7 +604,8 @@ TclpScaleUTime(
  */
 
 static Tcl_WideInt
-NativeGetMicroseconds(void)
+NativeGetMicroseconds(
+    int monotonic)
 {
     static size_t nomObtainSTPerfCntrDist = 0;
 				/* Nominal distance in perf-counter ticks to
@@ -745,10 +737,13 @@ NativeGetMicroseconds(void)
 		InitializeCriticalSection(&timeInfo.cs);
 
 		timeInfo.lastCI.perfCounter = NativePerformanceCounter();
+		/* base of the real-time (and last known system time) */
 		timeInfo.lastCI.sysTime =
 		    timeInfo.lastCI.virtTimeBase = GetSystemTimeAsVirtual();
 
-		timeInfo.lastTimeJumpEpoch = 1; /* let the caller know we've epoch */
+		/* base of the monotonic time */
+		timeInfo.lastCI.monoTimeBase = NativeCalc100NsOffs(
+			0, timeInfo.lastCI.perfCounter);
 	    }
 	    timeInfo.initialized = TRUE;
 	}
@@ -815,12 +810,13 @@ NativeGetMicroseconds(void)
 	     * Recalibration / Adjustment of base values.
 	     */
 
-	    Tcl_WideInt vt0;		/* Desired virtual time */
+	    Tcl_WideInt vt0, vt1;	/* Desired virtual time */
 	    Tcl_WideInt tdiff;		/* Time difference to the system time */
 	    Tcl_WideInt lastTime;	/* Used to compare with last known time */
 
 	    /* New desired virtual time using current base values */
-	    vt0 = NativeCalc100NsTicks(ci.virtTimeBase, ci.perfCounter, curCounter);
+	    vt1 = vt0 = ci.virtTimeBase
+		+ NativeCalc100NsOffs(ci.perfCounter, curCounter);
 
 	    tdiff = vt0 - sysTime;
 	    /* If we can adjust offsets (not a jump to new system time) */
@@ -829,11 +825,15 @@ NativeGetMicroseconds(void)
 		/* Allow small drift if discrepancy larger as expected */
 //!!!		printf("************* tdiff: %I64d\n", tdiff);
 		if (tdiff <= MsToT100ns(-VT_MAX_DISCREPANCY)) {
-		   vt0 += MsToT100ns(VT_MAX_DRIFT_TIME);
+		    vt0 += MsToT100ns(VT_MAX_DRIFT_TIME);
+		}
+		else
+		if (tdiff <= MsToT100ns(-VT_MAX_DRIFT_TIME)) {
+		    vt0 -= tdiff / 2; /* small drift forwards */
 		}
 		else
 		if (tdiff >= MsToT100ns(VT_MAX_DISCREPANCY)) {
-		   vt0 -= MsToT100ns(VT_MAX_DRIFT_TIME);
+		    vt0 -= MsToT100ns(VT_MAX_DRIFT_TIME);
 		}
 		
 		/*
@@ -850,17 +850,30 @@ NativeGetMicroseconds(void)
 //!!!		    printf("************* forwards 1: %I64d, last-time: %I64d, distance: %I64d\n", lastTime, ci.virtTimeBase, (vt0 - trSysTime));
 		}
 
+		/* difference for addjustment of monotonic base */
+		tdiff = vt0 - vt1;
+
 	    } else {
 		/* 
 		 * The time-jump (reset or initial), we should use system time
 		 * instead of virtual to recalibrate offsets (let the time jump).
 		 */
-		timeInfo.lastTimeJump = T100nsToUs(sysTime - vt0); /* 100-ns */;
-		timeInfo.lastTimeJumpEpoch++;
 		vt0 = sysTime;
+		tdiff = 0;
 //!!!		printf("************* reset time: %I64d *****************\n", vt0);
 	    }
 
+	    /*
+	     * Now adjust monotonic time base, note this time should absolutely
+	     * never ticks backwards (relative the last known monotonic time).
+	     */
+	    ci.monoTimeBase += NativeCalc100NsOffs(ci.perfCounter, curCounter);
+	    ci.monoTimeBase += tdiff;
+	    lastTime = (timeInfo.lastCI.monoTimeBase + timeInfo.lastUsedTime);
+	    if (ci.monoTimeBase < lastTime) {
+		ci.monoTimeBase = lastTime; /* freeze monotonic time a bit */
+	    }
+
 	    /* 
 	     * Adjustment of current base for virtual time. This will also
 	     * prevent too large counter difference (resp. max distance ~ 100ms).
@@ -882,12 +895,20 @@ NativeGetMicroseconds(void)
 	  LeaveCriticalSection(&timeInfo.cs);
 	} /* common info lastCI contains actual data */
 	
-    calcVT:	
-	/* Calculate actual virtual time now using performance counter */
-	curTime = NativeCalc100NsTicks(ci.virtTimeBase, ci.perfCounter, curCounter);
-
-	/* Save last used time (offset) and return virtual time */
-	timeInfo.lastUsedTime = (size_t)(curTime - ci.virtTimeBase);
+    calcVT:
+
+	/* Calculate actual time-offset using performance counter */
+	curTime = NativeCalc100NsOffs(ci.perfCounter, curCounter);
+	/* Save last used time (offset) */
+	timeInfo.lastUsedTime = (size_t)curTime;
+	if (monotonic) {
+	    /* Use monotonic time base */
+	    curTime += ci.monoTimeBase;
+	} else {
+	    /* Use real-time base */
+	    curTime += ci.virtTimeBase;
+	}
+	/* Return virtual time */
 	return T100nsToUs(curTime); /* 100-ns to microseconds */
     }
 
@@ -921,25 +942,11 @@ NativeGetTime(
     Tcl_Time *timePtr,
     ClientData clientData)
 {
-    Tcl_WideInt usecSincePosixEpoch;
-
-    /*
-     * Try to use high resolution timer.
-     */
-    if ( (usecSincePosixEpoch = NativeGetMicroseconds()) ) {
-	timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
-	timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
-    } else {
-	/*
-	* High resolution timer is not available. Just use ftime.
-	*/
-
-	struct _timeb t;
+    Tcl_WideInt now;
 
-	_ftime(&t);
-	timePtr->sec = (long)t.time;
-	timePtr->usec = t.millitm * 1000;
-    }
+    now = NativeGetMicroseconds(0);
+    timePtr->sec = (long) (now / 1000000);
+    timePtr->usec = (unsigned long) (now % 1000000);
 }
 
 /*
@@ -1373,21 +1380,6 @@ Tcl_QueryTimeProc(
     }
 }
 
-Tcl_WideInt
-TclpGetLastTimeJump(size_t *epoch)
-{
-    if (timeInfo.lastTimeJumpEpoch > *epoch) {
-    	*epoch = timeInfo.lastTimeJumpEpoch;
-	return timeInfo.lastTimeJump;
-    };
-    return 0;
-}
-size_t
-TclpGetLastTimeJumpEpoch(void)
-{
-    return timeInfo.lastTimeJumpEpoch;
-}
-
 /*
  * Local Variables:
  * mode: c
-- 
cgit v0.12


From dab0a79344efad3e9025d0ab454383ded8fc7b37 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:06 +0000
Subject: [unix] fixes conditional-wait: timeout is monotonic based;

---
 unix/tclUnixNotfy.c | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index f213ec5..db10512 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -110,6 +110,7 @@ typedef struct ThreadSpecificData {
     pthread_cond_t waitCV;	/* Any other thread alerts a notifier that an
 				 * event is ready to be processed by signaling
 				 * this condition variable. */
+    int waitCVMono;		/* Mark wait monotonic based */
 #endif /* __CYGWIN__ */
     int waitCVinitialized;	/* Variable to flag initialization of the structure */
     int eventReady;		/* > 0 if an event is ready to be processed.
@@ -332,6 +333,7 @@ ClientData
 Tcl_InitNotifier(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    pthread_condattr_t wcvAttr, *wcvAttrPtr = NULL;
 
 #ifdef TCL_THREADS
     tsdPtr->eventReady = 0;
@@ -361,7 +363,14 @@ Tcl_InitNotifier(void)
 	tsdPtr->event = CreateEventW(NULL, 1 /* manual */,
 		0 /* !signaled */, NULL);
 #else
-	pthread_cond_init(&tsdPtr->waitCV, NULL);
+	pthread_condattr_init(&wcvAttr);
+        if (pthread_condattr_setclock(&wcvAttr, CLOCK_MONOTONIC) == 0) {
+	    /* we can use conditional wait monotonic based */
+	    wcvAttrPtr = &wcvAttr;
+	    tsdPtr->waitCVMono = 1;
+        }
+	pthread_cond_init(&tsdPtr->waitCV, wcvAttrPtr);
+        (void)pthread_condattr_destroy(&wcvAttr);
 #endif /* __CYGWIN__ */
 	tsdPtr->waitCVinitialized = 1;
     }
@@ -1116,7 +1125,8 @@ Tcl_WaitForEvent(
 	    /* TIP #233: Scale from virtual time to real-time  */
 	    TclpScaleUTime(&waitTime);
 
-	    clock_gettime(CLOCK_REALTIME, &ptime);
+	    clock_gettime(tsdPtr->waitCVMono ? 
+		CLOCK_MONOTONIC : CLOCK_REALTIME, &ptime);
 	    ptime.tv_sec += waitTime / 1000000;
 	    ptime.tv_nsec += (waitTime % 1000000) * 1000;
 	    if (ptime.tv_nsec > 1000000*1000) {
@@ -1151,7 +1161,7 @@ Tcl_WaitForEvent(
 		ptime.tv_sec++;
 	    }
 	    if (pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex,
-	    		&ptime) == ETIMEDOUT) {
+			&ptime) == ETIMEDOUT) {
 		continue; /* repeat wait (if not yet real timeout) */
 	    };
 	} else {
-- 
cgit v0.12


From 721593c904f93af0626b02b5dd6e0a0a571f3b48 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:11 +0000
Subject: unix: implements wide-clicks on unix (1 wide-click == 0.001
 microseconds (1 nanosecond)), so more precise now (e. g. by time measurement
 etc.); unix/configure: regenerated (autoconf)

---
 unix/configure     | 20988 ++++++++++++++++-----------------------------------
 unix/configure.in  |     7 +-
 unix/tclUnixTime.c |    76 +-
 3 files changed, 6371 insertions(+), 14700 deletions(-)

diff --git a/unix/configure b/unix/configure
index 7ff9f72..014e36e 100755
--- a/unix/configure
+++ b/unix/configure
@@ -1,81 +1,459 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.59 for tcl 8.5.
+# Generated by GNU Autoconf 2.69 for tcl 8.5.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
 #
-# Copyright (C) 2003 Free Software Foundation, Inc.
 # This configure script is free software; the Free Software Foundation
 # gives unlimited permission to copy, distribute and modify it.
-## --------------------- ##
-## M4sh Initialization.  ##
-## --------------------- ##
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
 
-# Be Bourne compatible
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
   emulate sh
   NULLCMD=:
-  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
   # is contrary to our usage.  Disable this feature.
   alias -g '${1+"$@"}'='"$@"'
-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
-  set -o posix
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
 fi
-DUALCASE=1; export DUALCASE # for MKS sh
 
-# Support unset when possible.
-if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
-  as_unset=unset
-else
-  as_unset=false
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
 fi
 
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
 
-# Work around bugs in pre-3.0 UWIN ksh.
-$as_unset ENV MAIL MAILPATH
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
 PS1='$ '
 PS2='> '
 PS4='+ '
 
 # NLS nuisances.
-for as_var in \
-  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
-  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
-  LC_TELEPHONE LC_TIME
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 do
-  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
-    eval $as_var=C; export $as_var
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
   else
-    $as_unset $as_var
+    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
+$0: including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
   fi
-done
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
 
-# Required to use basename.
-if expr a : '\(a\)' >/dev/null 2>&1; then
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
   as_expr=expr
 else
   as_expr=false
 fi
 
-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
   as_basename=basename
 else
   as_basename=false
 fi
 
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
 
-# Name of the executable.
-as_me=`$as_basename "$0" ||
+as_me=`$as_basename -- "$0" ||
 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)$' \| \
-	 .     : '\(.\)' 2>/dev/null ||
-echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
-  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
-  	  /^X\/\(\/\).*/{ s//\1/; q; }
-  	  s/.*/./; q'`
-
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
 
-# PATH needs CR, and LINENO needs CR and PATH.
 # Avoid depending upon Character Ranges.
 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -83,146 +461,91 @@ as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 as_cr_digits='0123456789'
 as_cr_alnum=$as_cr_Letters$as_cr_digits
 
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  echo "#! /bin/sh" >conf$$.sh
-  echo  "exit 0"   >>conf$$.sh
-  chmod +x conf$$.sh
-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
-    PATH_SEPARATOR=';'
-  else
-    PATH_SEPARATOR=:
-  fi
-  rm -f conf$$.sh
-fi
-
-
-  as_lineno_1=$LINENO
-  as_lineno_2=$LINENO
-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
-  test "x$as_lineno_1" != "x$as_lineno_2" &&
-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
-  # Find who we are.  Look in the path if we contain no path at all
-  # relative or not.
-  case $0 in
-    *[\\/]* ) as_myself=$0 ;;
-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-done
-
-       ;;
-  esac
-  # We did not find ourselves, most probably we were run as `sh COMMAND'
-  # in which case we are not to be found in the path.
-  if test "x$as_myself" = x; then
-    as_myself=$0
-  fi
-  if test ! -f "$as_myself"; then
-    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
-   { (exit 1); exit 1; }; }
-  fi
-  case $CONFIG_SHELL in
-  '')
-    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  for as_base in sh bash ksh sh5; do
-	 case $as_dir in
-	 /*)
-	   if ("$as_dir/$as_base" -c '
-  as_lineno_1=$LINENO
-  as_lineno_2=$LINENO
-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
-  test "x$as_lineno_1" != "x$as_lineno_2" &&
-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
-	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
-	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
-	     CONFIG_SHELL=$as_dir/$as_base
-	     export CONFIG_SHELL
-	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
-	   fi;;
-	 esac
-       done
-done
-;;
-  esac
 
-  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
-  # uniformly replaced by the line number.  The first 'sed' inserts a
-  # line-number line before each line; the second 'sed' does the real
-  # work.  The second script uses 'N' to pair each line-number line
-  # with the numbered line, and appends trailing '-' during
-  # substitution so that $LINENO is not a special case at line end.
-  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
-  sed '=' <$as_myself |
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
     sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
       N
-      s,$,-,
-      : loop
-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
       t loop
-      s,-$,,
-      s,^['$as_cr_digits']*\n,,
+      s/-\n.*//
     ' >$as_me.lineno &&
-  chmod +x $as_me.lineno ||
-    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
-   { (exit 1); exit 1; }; }
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
   # Don't try to exec as it changes $[0], causing all sort of problems
   # (the dirname of $[0] is not the place where we might find the
-  # original and so on.  Autoconf is especially sensible to this).
-  . ./$as_me.lineno
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
   # Exit status is that of the last command.
   exit
 }
 
-
-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
-  *c*,-n*) ECHO_N= ECHO_C='
-' ECHO_T='	' ;;
-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
 esac
 
-if expr a : '\(a\)' >/dev/null 2>&1; then
-  as_expr=expr
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
 else
-  as_expr=false
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
 fi
-
-rm -f conf$$ conf$$.exe conf$$.file
-echo >conf$$.file
-if ln -s conf$$.file conf$$ 2>/dev/null; then
-  # We could just check for DJGPP; but this test a) works b) is more generic
-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
-  if test -f conf$$.exe; then
-    # Don't use ln at all; we don't have any links
-    as_ln_s='cp -p'
-  else
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
     as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
   fi
-elif ln conf$$.file conf$$ 2>/dev/null; then
-  as_ln_s=ln
 else
-  as_ln_s='cp -p'
+  as_ln_s='cp -pR'
 fi
-rm -f conf$$ conf$$.exe conf$$.file
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
 
 if mkdir -p . 2>/dev/null; then
-  as_mkdir_p=:
+  as_mkdir_p='mkdir -p "$as_dir"'
 else
   test -d ./-p && rmdir ./-p
   as_mkdir_p=false
 fi
 
-as_executable_p="test -f"
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
 
 # Sed expression to map a string onto a valid CPP name.
 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
@@ -231,38 +554,25 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 
 
-# IFS
-# We need space, tab and new line, in precisely that order.
-as_nl='
-'
-IFS=" 	$as_nl"
-
-# CDPATH.
-$as_unset CDPATH
-
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
 
 # Name of the host.
-# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
 # so uname gets run too.
 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 
-exec 6>&1
-
 #
 # Initializations.
 #
 ac_default_prefix=/usr/local
+ac_clean_files=
 ac_config_libobj_dir=.
+LIBOBJS=
 cross_compiling=no
 subdirs=
 MFLAGS=
 MAKEFLAGS=
-SHELL=${CONFIG_SHELL-/bin/sh}
-
-# Maximum number of lines to put in a shell here document.
-# This variable seems obsolete.  It should probably be removed, and
-# only ac_max_sed_lines should be used.
-: ${ac_max_here_lines=38}
 
 # Identity of this package.
 PACKAGE_NAME='tcl'
@@ -270,50 +580,207 @@ PACKAGE_TARNAME='tcl'
 PACKAGE_VERSION='8.5'
 PACKAGE_STRING='tcl 8.5'
 PACKAGE_BUGREPORT=''
+PACKAGE_URL=''
 
 # Factoring default headers for most tests.
 ac_includes_default="\
 #include <stdio.h>
-#if HAVE_SYS_TYPES_H
+#ifdef HAVE_SYS_TYPES_H
 # include <sys/types.h>
 #endif
-#if HAVE_SYS_STAT_H
+#ifdef HAVE_SYS_STAT_H
 # include <sys/stat.h>
 #endif
-#if STDC_HEADERS
+#ifdef STDC_HEADERS
 # include <stdlib.h>
 # include <stddef.h>
 #else
-# if HAVE_STDLIB_H
+# ifdef HAVE_STDLIB_H
 #  include <stdlib.h>
 # endif
 #endif
-#if HAVE_STRING_H
-# if !STDC_HEADERS && HAVE_MEMORY_H
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
 #  include <memory.h>
 # endif
 # include <string.h>
 #endif
-#if HAVE_STRINGS_H
+#ifdef HAVE_STRINGS_H
 # include <strings.h>
 #endif
-#if HAVE_INTTYPES_H
+#ifdef HAVE_INTTYPES_H
 # include <inttypes.h>
-#else
-# if HAVE_STDINT_H
-#  include <stdint.h>
-# endif
 #endif
-#if HAVE_UNISTD_H
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif"
 
-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS MAN_FLAGS CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CPP EGREP TCL_THREADS RANLIB ac_ct_RANLIB AR ac_ct_AR TCL_LIBS DL_LIBS DL_OBJS PLAT_OBJS PLAT_SRCS LDAIX_SRC CFLAGS_DEBUG CFLAGS_OPTIMIZE CFLAGS_WARNING LDFLAGS_DEBUG LDFLAGS_OPTIMIZE CC_SEARCH_FLAGS LD_SEARCH_FLAGS STLIB_LD SHLIB_LD TCL_SHLIB_LD_EXTRAS TK_SHLIB_LD_EXTRAS SHLIB_LD_LIBS SHLIB_CFLAGS SHLIB_SUFFIX MAKE_LIB MAKE_STUB_LIB INSTALL_LIB DLL_INSTALL_DIR INSTALL_STUB_LIB CFLAGS_DEFAULT LDFLAGS_DEFAULT LIBOBJS DTRACE TCL_VERSION TCL_MAJOR_VERSION TCL_MINOR_VERSION TCL_PATCH_LEVEL TCL_YEAR TCL_LIB_FILE TCL_LIB_FLAG TCL_LIB_SPEC TCL_STUB_LIB_FILE TCL_STUB_LIB_FLAG TCL_STUB_LIB_SPEC TCL_STUB_LIB_PATH TCL_INCLUDE_SPEC TCL_BUILD_STUB_LIB_SPEC TCL_BUILD_STUB_LIB_PATH TCL_SRC_DIR CFG_TCL_SHARED_LIB_SUFFIX CFG_TCL_UNSHARED_LIB_SUFFIX TCL_SHARED_BUILD LD_LIBRARY_PATH_VAR TCL_BUILD_LIB_SPEC TCL_LIB_VERSIONS_OK TCL_SHARED_LIB_SUFFIX TCL_UNSHARED_LIB_SUFFIX TCL_HAS_LONGLONG INSTALL_TZDATA DTRACE_SRC DTRACE_HDR DTRACE_OBJ MAKEFILE_SHELL BUILD_DLTEST TCL_PACKAGE_PATH TCL_MODULE_PATH TCL_LIBRARY PRIVATE_INCLUDE_DIR HTML_DIR EXTRA_CC_SWITCHES EXTRA_APP_CC_SWITCHES EXTRA_INSTALL EXTRA_INSTALL_BINARIES EXTRA_BUILD_HTML EXTRA_TCLSH_LIBS DLTEST_LD DLTEST_SUFFIX'
+ac_subst_vars='DLTEST_SUFFIX
+DLTEST_LD
+EXTRA_TCLSH_LIBS
+EXTRA_BUILD_HTML
+EXTRA_INSTALL_BINARIES
+EXTRA_INSTALL
+EXTRA_APP_CC_SWITCHES
+EXTRA_CC_SWITCHES
+HTML_DIR
+PRIVATE_INCLUDE_DIR
+TCL_LIBRARY
+TCL_MODULE_PATH
+TCL_PACKAGE_PATH
+BUILD_DLTEST
+MAKEFILE_SHELL
+DTRACE_OBJ
+DTRACE_HDR
+DTRACE_SRC
+INSTALL_TZDATA
+TCL_HAS_LONGLONG
+TCL_UNSHARED_LIB_SUFFIX
+TCL_SHARED_LIB_SUFFIX
+TCL_LIB_VERSIONS_OK
+TCL_BUILD_LIB_SPEC
+LD_LIBRARY_PATH_VAR
+TCL_SHARED_BUILD
+CFG_TCL_UNSHARED_LIB_SUFFIX
+CFG_TCL_SHARED_LIB_SUFFIX
+TCL_SRC_DIR
+TCL_BUILD_STUB_LIB_PATH
+TCL_BUILD_STUB_LIB_SPEC
+TCL_INCLUDE_SPEC
+TCL_STUB_LIB_PATH
+TCL_STUB_LIB_SPEC
+TCL_STUB_LIB_FLAG
+TCL_STUB_LIB_FILE
+TCL_LIB_SPEC
+TCL_LIB_FLAG
+TCL_LIB_FILE
+TCL_YEAR
+TCL_PATCH_LEVEL
+TCL_MINOR_VERSION
+TCL_MAJOR_VERSION
+TCL_VERSION
+DTRACE
+LIBOBJS
+LDFLAGS_DEFAULT
+CFLAGS_DEFAULT
+INSTALL_STUB_LIB
+DLL_INSTALL_DIR
+INSTALL_LIB
+MAKE_STUB_LIB
+MAKE_LIB
+SHLIB_SUFFIX
+SHLIB_CFLAGS
+SHLIB_LD_LIBS
+TK_SHLIB_LD_EXTRAS
+TCL_SHLIB_LD_EXTRAS
+SHLIB_LD
+STLIB_LD
+LD_SEARCH_FLAGS
+CC_SEARCH_FLAGS
+LDFLAGS_OPTIMIZE
+LDFLAGS_DEBUG
+CFLAGS_WARNING
+CFLAGS_OPTIMIZE
+CFLAGS_DEBUG
+LDAIX_SRC
+PLAT_SRCS
+PLAT_OBJS
+DL_OBJS
+DL_LIBS
+TCL_LIBS
+AR
+RANLIB
+TCL_THREADS
+EGREP
+GREP
+CPP
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+MAN_FLAGS
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+runstatedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
 ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_man_symlinks
+enable_man_compression
+enable_man_suffix
+enable_threads
+with_encoding
+enable_shared
+enable_64bit
+enable_64bit_vis
+enable_rpath
+enable_corefoundation
+enable_load
+enable_symbols
+enable_langinfo
+enable_dll_unloading
+with_tzdata
+enable_dtrace
+enable_framework
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CPP'
+
 
 # Initialize some variables set by options.
 ac_init_help=
 ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
 # The variables have the same names as the options, with
 # dashes changed to underlines.
 cache_file=/dev/null
@@ -336,34 +803,50 @@ x_libraries=NONE
 # and all the variables that are supposed to be based on exec_prefix
 # by default will actually change.
 # Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
 bindir='${exec_prefix}/bin'
 sbindir='${exec_prefix}/sbin'
 libexecdir='${exec_prefix}/libexec'
-datadir='${prefix}/share'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
 sysconfdir='${prefix}/etc'
 sharedstatedir='${prefix}/com'
 localstatedir='${prefix}/var'
-libdir='${exec_prefix}/lib'
+runstatedir='${localstatedir}/run'
 includedir='${prefix}/include'
 oldincludedir='/usr/include'
-infodir='${prefix}/info'
-mandir='${prefix}/man'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
 
 ac_prev=
+ac_dashdash=
 for ac_option
 do
   # If the previous option needs an argument, assign it.
   if test -n "$ac_prev"; then
-    eval "$ac_prev=\$ac_option"
+    eval $ac_prev=\$ac_option
     ac_prev=
     continue
   fi
 
-  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
 
   # Accept the important Cygnus configure options, so we can diagnose typos.
 
-  case $ac_option in
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
 
   -bindir | --bindir | --bindi | --bind | --bin | --bi)
     ac_prev=bindir ;;
@@ -385,33 +868,59 @@ do
   --config-cache | -C)
     cache_file=config.cache ;;
 
-  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
+  -datadir | --datadir | --datadi | --datad)
     ac_prev=datadir ;;
-  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
-  | --da=*)
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
     datadir=$ac_optarg ;;
 
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
   -disable-* | --disable-*)
-    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
     # Reject names that are not valid shell variable names.
-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
-      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
-   { (exit 1); exit 1; }; }
-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
-    eval "enable_$ac_feature=no" ;;
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
 
   -enable-* | --enable-*)
-    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
     # Reject names that are not valid shell variable names.
-    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
-      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
-   { (exit 1); exit 1; }; }
-    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
-    case $ac_option in
-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
-      *) ac_optarg=yes ;;
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
     esac
-    eval "enable_$ac_feature='$ac_optarg'" ;;
+    eval enable_$ac_useropt=\$ac_optarg ;;
 
   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
@@ -438,6 +947,12 @@ do
   -host=* | --host=* | --hos=* | --ho=*)
     host_alias=$ac_optarg ;;
 
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
   -includedir | --includedir | --includedi | --included | --include \
   | --includ | --inclu | --incl | --inc)
     ac_prev=includedir ;;
@@ -462,13 +977,16 @@ do
   | --libexe=* | --libex=* | --libe=*)
     libexecdir=$ac_optarg ;;
 
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
   -localstatedir | --localstatedir | --localstatedi | --localstated \
-  | --localstate | --localstat | --localsta | --localst \
-  | --locals | --local | --loca | --loc | --lo)
+  | --localstate | --localstat | --localsta | --localst | --locals)
     ac_prev=localstatedir ;;
   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
-  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
-  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
     localstatedir=$ac_optarg ;;
 
   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
@@ -533,10 +1051,29 @@ do
   | --progr-tra=* | --program-tr=* | --program-t=*)
     program_transform_name=$ac_optarg ;;
 
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
   | -silent | --silent | --silen | --sile | --sil)
     silent=yes ;;
 
+  -runstatedir | --runstatedir | --runstatedi | --runstated \
+  | --runstate | --runstat | --runsta | --runst | --runs \
+  | --run | --ru | --r)
+    ac_prev=runstatedir ;;
+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+  | --run=* | --ru=* | --r=*)
+    runstatedir=$ac_optarg ;;
+
   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
     ac_prev=sbindir ;;
   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
@@ -583,26 +1120,36 @@ do
     ac_init_version=: ;;
 
   -with-* | --with-*)
-    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
     # Reject names that are not valid shell variable names.
-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
-      { echo "$as_me: error: invalid package name: $ac_package" >&2
-   { (exit 1); exit 1; }; }
-    ac_package=`echo $ac_package| sed 's/-/_/g'`
-    case $ac_option in
-      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
-      *) ac_optarg=yes ;;
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
     esac
-    eval "with_$ac_package='$ac_optarg'" ;;
+    eval with_$ac_useropt=\$ac_optarg ;;
 
   -without-* | --without-*)
-    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
     # Reject names that are not valid shell variable names.
-    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
-      { echo "$as_me: error: invalid package name: $ac_package" >&2
-   { (exit 1); exit 1; }; }
-    ac_package=`echo $ac_package | sed 's/-/_/g'`
-    eval "with_$ac_package=no" ;;
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
 
   --x)
     # Obsolete; use --with-x.
@@ -622,27 +1169,26 @@ do
   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
     x_libraries=$ac_optarg ;;
 
-  -*) { echo "$as_me: error: unrecognized option: $ac_option
-Try \`$0 --help' for more information." >&2
-   { (exit 1); exit 1; }; }
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
     ;;
 
   *=*)
     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
     # Reject names that are not valid shell variable names.
-    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
-      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
-   { (exit 1); exit 1; }; }
-    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
-    eval "$ac_envvar='$ac_optarg'"
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
     export $ac_envvar ;;
 
   *)
     # FIXME: should be removed in autoconf 3.0.
-    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
-      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
-    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
     ;;
 
   esac
@@ -650,31 +1196,36 @@ done
 
 if test -n "$ac_prev"; then
   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
-  { echo "$as_me: error: missing argument to $ac_option" >&2
-   { (exit 1); exit 1; }; }
+  as_fn_error $? "missing argument to $ac_option"
 fi
 
-# Be sure to have absolute paths.
-for ac_var in exec_prefix prefix
-do
-  eval ac_val=$`echo $ac_var`
-  case $ac_val in
-    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
-   { (exit 1); exit 1; }; };;
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
   esac
-done
+fi
 
-# Be sure to have absolute paths.
-for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
-	      localstatedir libdir includedir oldincludedir infodir mandir
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir runstatedir
 do
-  eval ac_val=$`echo $ac_var`
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
   case $ac_val in
-    [\\/$]* | ?:[\\/]* ) ;;
-    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
-   { (exit 1); exit 1; }; };;
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
   esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
 done
 
 # There might be people who depend on the old broken behavior: `$host'
@@ -688,8 +1239,6 @@ target=$target_alias
 if test "x$host_alias" != x; then
   if test "x$build_alias" = x; then
     cross_compiling=maybe
-    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
-    If a cross compiler is detected then cross compile mode will be used." >&2
   elif test "x$build_alias" != "x$host_alias"; then
     cross_compiling=yes
   fi
@@ -701,74 +1250,72 @@ test -n "$host_alias" && ac_tool_prefix=$host_alias-
 test "$silent" = yes && exec 6>/dev/null
 
 
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
 # Find the source files, if location was not specified.
 if test -z "$srcdir"; then
   ac_srcdir_defaulted=yes
-  # Try the directory containing this script, then its parent.
-  ac_confdir=`(dirname "$0") 2>/dev/null ||
-$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$0" : 'X\(//\)[^/]' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| \
-	 .     : '\(.\)' 2>/dev/null ||
-echo X"$0" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
-  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
-  	  /^X\(\/\/\)$/{ s//\1/; q; }
-  	  /^X\(\/\).*/{ s//\1/; q; }
-  	  s/.*/./; q'`
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
   srcdir=$ac_confdir
-  if test ! -r $srcdir/$ac_unique_file; then
+  if test ! -r "$srcdir/$ac_unique_file"; then
     srcdir=..
   fi
 else
   ac_srcdir_defaulted=no
 fi
-if test ! -r $srcdir/$ac_unique_file; then
-  if test "$ac_srcdir_defaulted" = yes; then
-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
-   { (exit 1); exit 1; }; }
-  else
-    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
-   { (exit 1); exit 1; }; }
-  fi
-fi
-(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
-  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
-   { (exit 1); exit 1; }; }
-srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
-ac_env_build_alias_set=${build_alias+set}
-ac_env_build_alias_value=$build_alias
-ac_cv_env_build_alias_set=${build_alias+set}
-ac_cv_env_build_alias_value=$build_alias
-ac_env_host_alias_set=${host_alias+set}
-ac_env_host_alias_value=$host_alias
-ac_cv_env_host_alias_set=${host_alias+set}
-ac_cv_env_host_alias_value=$host_alias
-ac_env_target_alias_set=${target_alias+set}
-ac_env_target_alias_value=$target_alias
-ac_cv_env_target_alias_set=${target_alias+set}
-ac_cv_env_target_alias_value=$target_alias
-ac_env_CC_set=${CC+set}
-ac_env_CC_value=$CC
-ac_cv_env_CC_set=${CC+set}
-ac_cv_env_CC_value=$CC
-ac_env_CFLAGS_set=${CFLAGS+set}
-ac_env_CFLAGS_value=$CFLAGS
-ac_cv_env_CFLAGS_set=${CFLAGS+set}
-ac_cv_env_CFLAGS_value=$CFLAGS
-ac_env_LDFLAGS_set=${LDFLAGS+set}
-ac_env_LDFLAGS_value=$LDFLAGS
-ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
-ac_cv_env_LDFLAGS_value=$LDFLAGS
-ac_env_CPPFLAGS_set=${CPPFLAGS+set}
-ac_env_CPPFLAGS_value=$CPPFLAGS
-ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
-ac_cv_env_CPPFLAGS_value=$CPPFLAGS
-ac_env_CPP_set=${CPP+set}
-ac_env_CPP_value=$CPP
-ac_cv_env_CPP_set=${CPP+set}
-ac_cv_env_CPP_value=$CPP
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
 
 #
 # Report the --help message.
@@ -791,20 +1338,17 @@ Configuration:
       --help=short        display options specific to this package
       --help=recursive    display the short help of all the included packages
   -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking...' messages
+  -q, --quiet, --silent   do not print \`checking ...' messages
       --cache-file=FILE   cache test results in FILE [disabled]
   -C, --config-cache      alias for \`--cache-file=config.cache'
   -n, --no-create         do not create output files
       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 
-_ACEOF
-
-  cat <<_ACEOF
 Installation directories:
   --prefix=PREFIX         install architecture-independent files in PREFIX
-			  [$ac_default_prefix]
+                          [$ac_default_prefix]
   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
-			  [PREFIX]
+                          [PREFIX]
 
 By default, \`make install' will install all the files in
 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
@@ -814,18 +1358,26 @@ for instance \`--prefix=\$HOME'.
 For better control, use the options below.
 
 Fine tuning of the installation directories:
-  --bindir=DIR           user executables [EPREFIX/bin]
-  --sbindir=DIR          system admin executables [EPREFIX/sbin]
-  --libexecdir=DIR       program executables [EPREFIX/libexec]
-  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
-  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
-  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
-  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
-  --libdir=DIR           object code libraries [EPREFIX/lib]
-  --includedir=DIR       C header files [PREFIX/include]
-  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
-  --infodir=DIR          info documentation [PREFIX/info]
-  --mandir=DIR           man documentation [PREFIX/man]
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/tcl]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
 _ACEOF
 
   cat <<\_ACEOF
@@ -839,6 +1391,7 @@ if test -n "$ac_init_help"; then
   cat <<\_ACEOF
 
 Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
   --enable-man-symlinks   use symlinks for the manpages (default: off)
@@ -876,160 +1429,593 @@ Some influential environment variables:
   CFLAGS      C compiler flags
   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
               nonstandard directory <lib dir>
-  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
-              headers in a nonstandard directory <include dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
   CPP         C preprocessor
 
 Use these variables to override the choices made by `configure' or to help
 it to find libraries and programs with nonstandard names/locations.
 
+Report bugs to the package provider.
 _ACEOF
+ac_status=$?
 fi
 
 if test "$ac_init_help" = "recursive"; then
   # If there are subdirs, report their specific --help.
-  ac_popdir=`pwd`
   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
-    test -d $ac_dir || continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
     ac_builddir=.
 
-if test "$ac_dir" != .; then
-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
-  # A "../" for each directory in $ac_dir_suffix.
-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
-else
-  ac_dir_suffix= ac_top_builddir=
-fi
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
 
 case $srcdir in
-  .)  # No --srcdir option.  We are building in place.
+  .)  # We are building in place.
     ac_srcdir=.
-    if test -z "$ac_top_builddir"; then
-       ac_top_srcdir=.
-    else
-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
-    fi ;;
-  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
     ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir ;;
-  *) # Relative path.
-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
-esac
-
-# Do not use `cd foo && pwd` to compute absolute paths, because
-# the directories may not exist.
-case `pwd` in
-.) ac_abs_builddir="$ac_dir";;
-*)
-  case "$ac_dir" in
-  .) ac_abs_builddir=`pwd`;;
-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_top_builddir=${ac_top_builddir}.;;
-*)
-  case ${ac_top_builddir}. in
-  .) ac_abs_top_builddir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_srcdir=$ac_srcdir;;
-*)
-  case $ac_srcdir in
-  .) ac_abs_srcdir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_top_srcdir=$ac_top_srcdir;;
-*)
-  case $ac_top_srcdir in
-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
-  esac;;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
 esac
-
-    cd $ac_dir
-    # Check for guested configure; otherwise get Cygnus style configure.
-    if test -f $ac_srcdir/configure.gnu; then
-      echo
-      $SHELL $ac_srcdir/configure.gnu  --help=recursive
-    elif test -f $ac_srcdir/configure; then
-      echo
-      $SHELL $ac_srcdir/configure  --help=recursive
-    elif test -f $ac_srcdir/configure.ac ||
-	   test -f $ac_srcdir/configure.in; then
-      echo
-      $ac_configure --help
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
     else
-      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-    fi
-    cd $ac_popdir
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
   done
 fi
 
-test -n "$ac_init_help" && exit 0
+test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
 tcl configure 8.5
-generated by GNU Autoconf 2.59
+generated by GNU Autoconf 2.69
 
-Copyright (C) 2003 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
 _ACEOF
-  exit 0
+  exit
 fi
-exec 5>config.log
-cat >&5 <<_ACEOF
-This file contains any messages produced by compilers while
-running configure, to aid debugging if configure makes a mistake.
-
-It was created by tcl $as_me 8.5, which was
-generated by GNU Autoconf 2.59.  Invocation command line was
 
-  $ $0 $@
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
 
-_ACEOF
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
 {
-cat <<_ASUNAME
-## --------- ##
-## Platform. ##
-## --------- ##
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
 
-hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
 
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+} # ac_fn_c_try_compile
 
-/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
-hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
-/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
-/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
 
-_ASUNAME
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
 
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  echo "PATH: $as_dir"
-done
+} # ac_fn_c_try_cpp
+
+# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_c_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if eval \${$3+:} false; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_mongrel
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $2 (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+
+# ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES
+# ----------------------------------------------------
+# Tries to find if the field MEMBER exists in type AGGR, after including
+# INCLUDES, setting cache variable VAR accordingly.
+ac_fn_c_check_member ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5
+$as_echo_n "checking for $2.$3... " >&6; }
+if eval \${$4+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$5
+int
+main ()
+{
+static $2 ac_aggr;
+if (ac_aggr.$3)
+return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$4=yes"
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$5
+int
+main ()
+{
+static $2 ac_aggr;
+if (sizeof ac_aggr.$3)
+return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$4=yes"
+else
+  eval "$4=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$4
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_member
+
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof ($2))
+	 return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof (($2)))
+	    return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  eval "$3=yes"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_type
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by tcl $as_me 8.5, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
 
 } >&5
 
@@ -1051,7 +2037,6 @@ _ACEOF
 ac_configure_args=
 ac_configure_args0=
 ac_configure_args1=
-ac_sep=
 ac_must_keep_next=false
 for ac_pass in 1 2
 do
@@ -1062,13 +2047,13 @@ do
     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
     | -silent | --silent | --silen | --sile | --sil)
       continue ;;
-    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
-      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
     esac
     case $ac_pass in
-    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
     2)
-      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
+      as_fn_append ac_configure_args1 " '$ac_arg'"
       if test $ac_must_keep_next = true; then
 	ac_must_keep_next=false # Got value, back to normal.
       else
@@ -1084,104 +2069,115 @@ do
 	  -* ) ac_must_keep_next=true ;;
 	esac
       fi
-      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
-      # Get rid of the leading space.
-      ac_sep=" "
+      as_fn_append ac_configure_args " '$ac_arg'"
       ;;
     esac
   done
 done
-$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
-$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
 
 # When interrupted or exit'd, cleanup temporary files, and complete
 # config.log.  We remove comments because anyway the quotes in there
 # would cause problems or look ugly.
-# WARNING: Be sure not to use single quotes in there, as some shells,
-# such as our DU 5.0 friend, will then `close' the trap.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
 trap 'exit_status=$?
   # Save into config.log some information that might help in debugging.
   {
     echo
 
-    cat <<\_ASBOX
-## ---------------- ##
+    $as_echo "## ---------------- ##
 ## Cache variables. ##
-## ---------------- ##
-_ASBOX
+## ---------------- ##"
     echo
     # The following way of writing the cache mishandles newlines in values,
-{
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
   (set) 2>&1 |
-    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
-    *ac_space=\ *)
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
       sed -n \
-	"s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
-      ;;
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
     *)
-      sed -n \
-	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
       ;;
-    esac;
-}
+    esac |
+    sort
+)
     echo
 
-    cat <<\_ASBOX
-## ----------------- ##
+    $as_echo "## ----------------- ##
 ## Output variables. ##
-## ----------------- ##
-_ASBOX
+## ----------------- ##"
     echo
     for ac_var in $ac_subst_vars
     do
-      eval ac_val=$`echo $ac_var`
-      echo "$ac_var='"'"'$ac_val'"'"'"
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
     done | sort
     echo
 
     if test -n "$ac_subst_files"; then
-      cat <<\_ASBOX
-## ------------- ##
-## Output files. ##
-## ------------- ##
-_ASBOX
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
       echo
       for ac_var in $ac_subst_files
       do
-	eval ac_val=$`echo $ac_var`
-	echo "$ac_var='"'"'$ac_val'"'"'"
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
       done | sort
       echo
     fi
 
     if test -s confdefs.h; then
-      cat <<\_ASBOX
-## ----------- ##
+      $as_echo "## ----------- ##
 ## confdefs.h. ##
-## ----------- ##
-_ASBOX
+## ----------- ##"
       echo
-      sed "/^$/d" confdefs.h | sort
+      cat confdefs.h
       echo
     fi
     test "$ac_signal" != 0 &&
-      echo "$as_me: caught signal $ac_signal"
-    echo "$as_me: exit $exit_status"
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
   } >&5
-  rm -f core *.core &&
-  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
     exit $exit_status
-     ' 0
+' 0
 for ac_signal in 1 2 13 15; do
-  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
 done
 ac_signal=0
 
 # confdefs.h avoids OS command line length limits that DEFS can exceed.
-rm -rf conftest* confdefs.h
-# AIX cpp loses on an empty file, so make sure it contains at least a newline.
-echo >confdefs.h
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
 
 # Predefined preprocessor variables.
 
@@ -1189,112 +2185,137 @@ cat >>confdefs.h <<_ACEOF
 #define PACKAGE_NAME "$PACKAGE_NAME"
 _ACEOF
 
-
 cat >>confdefs.h <<_ACEOF
 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
 _ACEOF
 
-
 cat >>confdefs.h <<_ACEOF
 #define PACKAGE_VERSION "$PACKAGE_VERSION"
 _ACEOF
 
-
 cat >>confdefs.h <<_ACEOF
 #define PACKAGE_STRING "$PACKAGE_STRING"
 _ACEOF
 
-
 cat >>confdefs.h <<_ACEOF
 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
 _ACEOF
 
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
 
 # Let the site file select an alternate cache file if it wants to.
-# Prefer explicitly selected file to automatically selected ones.
-if test -z "$CONFIG_SITE"; then
-  if test "x$prefix" != xNONE; then
-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
-  else
-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
-  fi
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
 fi
-for ac_site_file in $CONFIG_SITE; do
-  if test -r "$ac_site_file"; then
-    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
-echo "$as_me: loading site script $ac_site_file" >&6;}
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
     sed 's/^/| /' "$ac_site_file" >&5
-    . "$ac_site_file"
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
   fi
 done
 
 if test -r "$cache_file"; then
-  # Some versions of bash will fail to source /dev/null (special
-  # files actually), so we avoid doing that.
-  if test -f "$cache_file"; then
-    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
-echo "$as_me: loading cache $cache_file" >&6;}
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
     case $cache_file in
-      [\\/]* | ?:[\\/]* ) . $cache_file;;
-      *)                      . ./$cache_file;;
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
     esac
   fi
 else
-  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
-echo "$as_me: creating cache $cache_file" >&6;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
   >$cache_file
 fi
 
 # Check that the precious variables saved in the cache have kept the same
 # value.
 ac_cache_corrupted=false
-for ac_var in `(set) 2>&1 |
-	       sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
+for ac_var in $ac_precious_vars; do
   eval ac_old_set=\$ac_cv_env_${ac_var}_set
   eval ac_new_set=\$ac_env_${ac_var}_set
-  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
-  eval ac_new_val="\$ac_env_${ac_var}_value"
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
   case $ac_old_set,$ac_new_set in
     set,)
-      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
-echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
       ac_cache_corrupted=: ;;
     ,set)
-      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
-echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
       ac_cache_corrupted=: ;;
     ,);;
     *)
       if test "x$ac_old_val" != "x$ac_new_val"; then
-	{ echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
-echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-	{ echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
-echo "$as_me:   former value:  $ac_old_val" >&2;}
-	{ echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
-echo "$as_me:   current value: $ac_new_val" >&2;}
-	ac_cache_corrupted=:
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
       fi;;
   esac
   # Pass precious variables to config.status.
   if test "$ac_new_set" = set; then
     case $ac_new_val in
-    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
-      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
     *) ac_arg=$ac_var=$ac_new_val ;;
     esac
     case " $ac_configure_args " in
       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
-      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
     esac
   fi
 done
 if $ac_cache_corrupted; then
-  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
-echo "$as_me: error: changes in the environment can compromise the build" >&2;}
-  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
-echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
-   { (exit 1); exit 1; }; }
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
 fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
 
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
@@ -1307,31 +2328,6 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 TCL_VERSION=8.5
 TCL_MAJOR_VERSION=8
 TCL_MINOR_VERSION=5
@@ -1357,62 +2353,60 @@ TCL_SRC_DIR="`cd "$srcdir"/..; pwd`"
 #------------------------------------------------------------------------
 
 
-    echo "$as_me:$LINENO: checking whether to use symlinks for manpages" >&5
-echo $ECHO_N "checking whether to use symlinks for manpages... $ECHO_C" >&6
-    # Check whether --enable-man-symlinks or --disable-man-symlinks was given.
-if test "${enable_man_symlinks+set}" = set; then
-  enableval="$enable_man_symlinks"
-  test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --symlinks"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use symlinks for manpages" >&5
+$as_echo_n "checking whether to use symlinks for manpages... " >&6; }
+    # Check whether --enable-man-symlinks was given.
+if test "${enable_man_symlinks+set}" = set; then :
+  enableval=$enable_man_symlinks; test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --symlinks"
 else
   enableval="no"
-fi;
-    echo "$as_me:$LINENO: result: $enableval" >&5
-echo "${ECHO_T}$enableval" >&6
-
-    echo "$as_me:$LINENO: checking whether to compress the manpages" >&5
-echo $ECHO_N "checking whether to compress the manpages... $ECHO_C" >&6
-    # Check whether --enable-man-compression or --disable-man-compression was given.
-if test "${enable_man_compression+set}" = set; then
-  enableval="$enable_man_compression"
-  case $enableval in
-	    yes) { { echo "$as_me:$LINENO: error: missing argument to --enable-man-compression" >&5
-echo "$as_me: error: missing argument to --enable-man-compression" >&2;}
-   { (exit 1); exit 1; }; };;
+fi
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5
+$as_echo "$enableval" >&6; }
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to compress the manpages" >&5
+$as_echo_n "checking whether to compress the manpages... " >&6; }
+    # Check whether --enable-man-compression was given.
+if test "${enable_man_compression+set}" = set; then :
+  enableval=$enable_man_compression; case $enableval in
+	    yes) as_fn_error $? "missing argument to --enable-man-compression" "$LINENO" 5;;
 	    no)  ;;
 	    *)   MAN_FLAGS="$MAN_FLAGS --compress $enableval";;
 	esac
 else
   enableval="no"
-fi;
-    echo "$as_me:$LINENO: result: $enableval" >&5
-echo "${ECHO_T}$enableval" >&6
+fi
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5
+$as_echo "$enableval" >&6; }
     if test "$enableval" != "no"; then
-	echo "$as_me:$LINENO: checking for compressed file suffix" >&5
-echo $ECHO_N "checking for compressed file suffix... $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for compressed file suffix" >&5
+$as_echo_n "checking for compressed file suffix... " >&6; }
 	touch TeST
 	$enableval TeST
 	Z=`ls TeST* | sed 's/^....//'`
 	rm -f TeST*
 	MAN_FLAGS="$MAN_FLAGS --extension $Z"
-	echo "$as_me:$LINENO: result: $Z" >&5
-echo "${ECHO_T}$Z" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $Z" >&5
+$as_echo "$Z" >&6; }
     fi
 
-    echo "$as_me:$LINENO: checking whether to add a package name suffix for the manpages" >&5
-echo $ECHO_N "checking whether to add a package name suffix for the manpages... $ECHO_C" >&6
-    # Check whether --enable-man-suffix or --disable-man-suffix was given.
-if test "${enable_man_suffix+set}" = set; then
-  enableval="$enable_man_suffix"
-  case $enableval in
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to add a package name suffix for the manpages" >&5
+$as_echo_n "checking whether to add a package name suffix for the manpages... " >&6; }
+    # Check whether --enable-man-suffix was given.
+if test "${enable_man_suffix+set}" = set; then :
+  enableval=$enable_man_suffix; case $enableval in
 	    yes) enableval="tcl" MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
 	    no)  ;;
 	    *)   MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
 	esac
 else
   enableval="no"
-fi;
-    echo "$as_me:$LINENO: result: $enableval" >&5
-echo "${ECHO_T}$enableval" >&6
+fi
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5
+$as_echo "$enableval" >&6; }
 
 
 
@@ -1435,10 +2429,10 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 if test -n "$ac_tool_prefix"; then
   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
 set dummy ${ac_tool_prefix}gcc; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_CC+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1448,35 +2442,37 @@ for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_prog_CC="${ac_tool_prefix}gcc"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
 fi
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:$LINENO: result: $CC" >&5
-echo "${ECHO_T}$CC" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
+
 fi
 if test -z "$ac_cv_prog_CC"; then
   ac_ct_CC=$CC
   # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
@@ -1486,39 +2482,50 @@ for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_prog_ac_ct_CC="gcc"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
 fi
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
-echo "${ECHO_T}$ac_ct_CC" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
-  CC=$ac_ct_CC
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
 else
   CC="$ac_cv_prog_CC"
 fi
 
 if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
 set dummy ${ac_tool_prefix}cc; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_CC+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1528,77 +2535,37 @@ for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_prog_CC="${ac_tool_prefix}cc"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
 fi
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:$LINENO: result: $CC" >&5
-echo "${ECHO_T}$CC" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
+
+  fi
 fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
+if test -z "$CC"; then
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="cc"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-done
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
-echo "${ECHO_T}$ac_ct_CC" >&6
-else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
-fi
-
-  CC=$ac_ct_CC
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-fi
-if test -z "$CC"; then
-  # Extract the first word of "cc", so it can be a program name with args.
-set dummy cc; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_CC+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1609,18 +2576,19 @@ for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
        ac_prog_rejected=yes
        continue
      fi
     ac_cv_prog_CC="cc"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
 if test $ac_prog_rejected = yes; then
   # We found a bogon in the path, so make sure we never use it.
@@ -1638,24 +2606,25 @@ fi
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:$LINENO: result: $CC" >&5
-echo "${ECHO_T}$CC" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
+
 fi
 if test -z "$CC"; then
   if test -n "$ac_tool_prefix"; then
-  for ac_prog in cl
+  for ac_prog in cl.exe
   do
     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_CC+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
@@ -1665,39 +2634,41 @@ for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
 fi
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:$LINENO: result: $CC" >&5
-echo "${ECHO_T}$CC" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
+
     test -n "$CC" && break
   done
 fi
 if test -z "$CC"; then
   ac_ct_CC=$CC
-  for ac_prog in cl
+  for ac_prog in cl.exe
 do
   # Extract the first word of "$ac_prog", so it can be a program name with args.
 set dummy $ac_prog; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
@@ -1707,66 +2678,78 @@ for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_prog_ac_ct_CC="$ac_prog"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
 fi
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
-  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
-echo "${ECHO_T}$ac_ct_CC" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
+
   test -n "$ac_ct_CC" && break
 done
 
-  CC=$ac_ct_CC
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
 fi
 
 fi
 
 
-test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
-See \`config.log' for more details." >&5
-echo "$as_me: error: no acceptable C compiler found in \$PATH
-See \`config.log' for more details." >&2;}
-   { (exit 1); exit 1; }; }
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
 
 # Provide some information about the compiler.
-echo "$as_me:$LINENO:" \
-     "checking for C compiler version" >&5
-ac_compiler=`set X $ac_compile; echo $2`
-{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
-  (eval $ac_compiler --version </dev/null >&5) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }
-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
-  (eval $ac_compiler -v </dev/null >&5) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }
-{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
-  (eval $ac_compiler -V </dev/null >&5) 2>&5
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
   ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
 
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -1778,112 +2761,108 @@ main ()
 }
 _ACEOF
 ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files a.out a.exe b.out"
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
 # Try to create an executable without -o first, disregard a.out.
 # It will help us diagnose broken compilers, and finding out an intuition
 # of exeext.
-echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
-echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
-ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
-  (eval $ac_link_default) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; then
-  # Find the output, starting from the most likely.  This scheme is
-# not robust to junk in `.', hence go to wildcards (a.*) only as a last
-# resort.
-
-# Be careful to initialize this variable, since it used to be cached.
-# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
-ac_cv_exeext=
-# b.out is created by i960 compilers.
-for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
 do
   test -f "$ac_file" || continue
   case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
-	;;
-    conftest.$ac_ext )
-	# This is the source file.
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
 	;;
     [ab].out )
 	# We found the default executable, but exeext='' is most
 	# certainly right.
 	break;;
     *.* )
-	ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	# FIXME: I believe we export ac_cv_exeext for Libtool,
-	# but it would be cool to find out if it's true.  Does anybody
-	# maintain Libtool? --akim.
-	export ac_cv_exeext
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
 	break;;
     * )
 	break;;
   esac
 done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
 else
-  echo "$as_me: failed program was:" >&5
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
-See \`config.log' for more details." >&5
-echo "$as_me: error: C compiler cannot create executables
-See \`config.log' for more details." >&2;}
-   { (exit 77); exit 77; }; }
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
 fi
-
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
 ac_exeext=$ac_cv_exeext
-echo "$as_me:$LINENO: result: $ac_file" >&5
-echo "${ECHO_T}$ac_file" >&6
-
-# Check the compiler produces executables we can run.  If not, either
-# the compiler is broken, or we cross compile.
-echo "$as_me:$LINENO: checking whether the C compiler works" >&5
-echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
-# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
-# If not cross compiling, check that we can run a simple program.
-if test "$cross_compiling" != yes; then
-  if { ac_try='./$ac_file'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-    cross_compiling=no
-  else
-    if test "$cross_compiling" = maybe; then
-	cross_compiling=yes
-    else
-	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details." >&5
-echo "$as_me: error: cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details." >&2;}
-   { (exit 1); exit 1; }; }
-    fi
-  fi
-fi
-echo "$as_me:$LINENO: result: yes" >&5
-echo "${ECHO_T}yes" >&6
 
-rm -f a.out a.exe conftest$ac_cv_exeext b.out
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
 ac_clean_files=$ac_clean_files_save
-# Check the compiler produces executables we can run.  If not, either
-# the compiler is broken, or we cross compile.
-echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
-echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
-echo "$as_me:$LINENO: result: $cross_compiling" >&5
-echo "${ECHO_T}$cross_compiling" >&6
-
-echo "$as_me:$LINENO: checking for suffix of executables" >&5
-echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
   ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; then
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
   # If both `conftest.exe' and `conftest' are `present' (well, observable)
 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
 # work properly (i.e., refer to `conftest.exe'), while it won't with
@@ -1891,38 +2870,90 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 for ac_file in conftest.exe conftest conftest.*; do
   test -f "$ac_file" || continue
   case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	  export ac_cv_exeext
 	  break;;
     * ) break;;
   esac
 done
 else
-  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details." >&5
-echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details." >&2;}
-   { (exit 1); exit 1; }; }
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
 fi
-
-rm -f conftest$ac_cv_exeext
-echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
-echo "${ECHO_T}$ac_cv_exeext" >&6
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
 
 rm -f conftest.$ac_ext
 EXEEXT=$ac_cv_exeext
 ac_exeext=$EXEEXT
-echo "$as_me:$LINENO: checking for suffix of object files" >&5
-echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
-if test "${ac_cv_objext+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -1934,45 +2965,46 @@ main ()
 }
 _ACEOF
 rm -f conftest.o conftest.obj
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; then
-  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
   case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
        break;;
   esac
 done
 else
-  echo "$as_me: failed program was:" >&5
+  $as_echo "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
-See \`config.log' for more details." >&5
-echo "$as_me: error: cannot compute suffix of object files: cannot compile
-See \`config.log' for more details." >&2;}
-   { (exit 1); exit 1; }; }
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
 fi
-
 rm -f conftest.$ac_cv_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
-echo "${ECHO_T}$ac_cv_objext" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
 OBJEXT=$ac_cv_objext
 ac_objext=$OBJEXT
-echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
-echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
-if test "${ac_cv_c_compiler_gnu+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -1986,55 +3018,34 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   ac_compiler_gnu=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_compiler_gnu=no
+  ac_compiler_gnu=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 ac_cv_c_compiler_gnu=$ac_compiler_gnu
 
 fi
-echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
-echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
-GCC=`test $ac_compiler_gnu = yes && echo yes`
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
 ac_test_CFLAGS=${CFLAGS+set}
 ac_save_CFLAGS=$CFLAGS
-CFLAGS="-g"
-echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
-echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
-if test "${ac_cv_prog_cc_g+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -2045,39 +3056,49 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   ac_cv_prog_cc_g=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
 
-ac_cv_prog_cc_g=no
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
 fi
-echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
-echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
 if test "$ac_test_CFLAGS" = set; then
   CFLAGS=$ac_save_CFLAGS
 elif test $ac_cv_prog_cc_g = yes; then
@@ -2093,23 +3114,18 @@ else
     CFLAGS=
   fi
 fi
-echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
-echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
-if test "${ac_cv_prog_cc_stdc+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  ac_cv_prog_cc_stdc=no
+  ac_cv_prog_cc_c89=no
 ac_save_CC=$CC
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <stdarg.h>
 #include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+struct stat;
 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
 struct buf { int x; };
 FILE * (*rcsopen) (struct buf *, struct stat *, int);
@@ -2132,12 +3148,17 @@ static char *f (char * (*g) (char **, int), char **p, ...)
 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
    function prototypes and stuff, but not '\xHH' hex character constants.
    These don't provoke an error unfortunately, instead are silently treated
-   as 'x'.  The following induces an error, until -std1 is added to get
+   as 'x'.  The following induces an error, until -std is added to get
    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
    array size at least.  It's necessary to write '\x00'==0 to get something
-   that's true only with -std1.  */
+   that's true only with -std.  */
 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
 
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
 int test (int i, double x);
 struct s1 {int (*f) (int a);};
 struct s2 {int (*f) (double a);};
@@ -2152,205 +3173,37 @@ return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
   return 0;
 }
 _ACEOF
-# Don't try gcc -ansi; that turns off useful extensions and
-# breaks some systems' header files.
-# AIX			-qlanglvl=ansi
-# Ultrix and OSF/1	-std1
-# HP-UX 10.20 and later	-Ae
-# HP-UX older versions	-Aa -D_HPUX_SOURCE
-# SVR4			-Xc -D__EXTENSIONS__
-for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
 do
   CC="$ac_save_CC $ac_arg"
-  rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_prog_cc_stdc=$ac_arg
-break
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
 fi
-rm -f conftest.err conftest.$ac_objext
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
 done
-rm -f conftest.$ac_ext conftest.$ac_objext
+rm -f conftest.$ac_ext
 CC=$ac_save_CC
 
 fi
-
-case "x$ac_cv_prog_cc_stdc" in
-  x|xno)
-    echo "$as_me:$LINENO: result: none needed" >&5
-echo "${ECHO_T}none needed" >&6 ;;
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
   *)
-    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
-echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
-    CC="$CC $ac_cv_prog_cc_stdc" ;;
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
 esac
-
-# Some people use a C++ compiler to compile C.  Since we use `exit',
-# in C++ we need to declare it.  In case someone uses the same compiler
-# for both compiling C and C++ we need to have the C++ compiler decide
-# the declaration of exit, since it's the most demanding environment.
-cat >conftest.$ac_ext <<_ACEOF
-#ifndef __cplusplus
-  choke me
-#endif
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  for ac_declaration in \
-   '' \
-   'extern "C" void std::exit (int) throw (); using std::exit;' \
-   'extern "C" void std::exit (int); using std::exit;' \
-   'extern "C" void exit (int) throw ();' \
-   'extern "C" void exit (int);' \
-   'void exit (int);'
-do
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_declaration
-#include <stdlib.h>
-int
-main ()
-{
-exit (42);
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  :
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-continue
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_declaration
-int
-main ()
-{
-exit (42);
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  break
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+if test "x$ac_cv_prog_cc_c89" != xno; then :
 
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-done
-rm -f conftest*
-if test -n "$ac_declaration"; then
-  echo '#ifdef __cplusplus' >>confdefs.h
-  echo $ac_declaration      >>confdefs.h
-  echo '#endif'             >>confdefs.h
-fi
-
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -2358,18 +3211,14 @@ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
-echo "$as_me:$LINENO: checking for inline" >&5
-echo $ECHO_N "checking for inline... $ECHO_C" >&6
-if test "${ac_cv_c_inline+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
+$as_echo_n "checking for inline... " >&6; }
+if ${ac_cv_c_inline+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_cv_c_inline=no
 for ac_kw in inline __inline__ __inline; do
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #ifndef __cplusplus
 typedef int foo_t;
@@ -2378,41 +3227,16 @@ $ac_kw foo_t foo () {return 0; }
 #endif
 
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_c_inline=$ac_kw; break
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_inline=$ac_kw
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  test "$ac_cv_c_inline" != no && break
 done
 
 fi
-echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
-echo "${ECHO_T}$ac_cv_c_inline" >&6
-
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
+$as_echo "$ac_cv_c_inline" >&6; }
 
 case $ac_cv_c_inline in
   inline | yes) ;;
@@ -2444,15 +3268,15 @@ ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
-echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
-echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
   CPP=
 fi
 if test -z "$CPP"; then
-  if test "${ac_cv_prog_CPP+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
       # Double quotes because CPP needs to be expanded
     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
@@ -2466,11 +3290,7 @@ do
   # <limits.h> exists even on freestanding compilers.
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp. "Syntax error" is here to catch this case.
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #ifdef __STDC__
 # include <limits.h>
@@ -2479,78 +3299,34 @@ cat >>conftest.$ac_ext <<_ACEOF
 #endif
 		     Syntax error
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  :
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+if ac_fn_c_try_cpp "$LINENO"; then :
 
+else
   # Broken: fails on valid input.
 continue
 fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err conftest.i conftest.$ac_ext
 
-  # OK, works on sane cases.  Now check whether non-existent headers
+  # OK, works on sane cases.  Now check whether nonexistent headers
   # can be detected and how.
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <ac_nonexistent.h>
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
+if ac_fn_c_try_cpp "$LINENO"; then :
   # Broken: success on invalid input.
 continue
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
   # Passes both tests.
 ac_preproc_ok=:
 break
 fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err conftest.i conftest.$ac_ext
 
 done
 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
   break
 fi
 
@@ -2562,8 +3338,8 @@ fi
 else
   ac_cv_prog_CPP=$CPP
 fi
-echo "$as_me:$LINENO: result: $CPP" >&5
-echo "${ECHO_T}$CPP" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
 ac_preproc_ok=false
 for ac_c_preproc_warn_flag in '' yes
 do
@@ -2573,11 +3349,7 @@ do
   # <limits.h> exists even on freestanding compilers.
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp. "Syntax error" is here to catch this case.
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #ifdef __STDC__
 # include <limits.h>
@@ -2586,85 +3358,40 @@ cat >>conftest.$ac_ext <<_ACEOF
 #endif
 		     Syntax error
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  :
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+if ac_fn_c_try_cpp "$LINENO"; then :
 
+else
   # Broken: fails on valid input.
 continue
 fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err conftest.i conftest.$ac_ext
 
-  # OK, works on sane cases.  Now check whether non-existent headers
+  # OK, works on sane cases.  Now check whether nonexistent headers
   # can be detected and how.
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <ac_nonexistent.h>
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
+if ac_fn_c_try_cpp "$LINENO"; then :
   # Broken: success on invalid input.
 continue
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
   # Passes both tests.
 ac_preproc_ok=:
 break
 fi
-rm -f conftest.err conftest.$ac_ext
+rm -f conftest.err conftest.i conftest.$ac_ext
 
 done
 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then
-  :
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
 else
-  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
-See \`config.log' for more details." >&5
-echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
-See \`config.log' for more details." >&2;}
-   { (exit 1); exit 1; }; }
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
 fi
 
 ac_ext=c
@@ -2674,31 +3401,142 @@ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
-echo "$as_me:$LINENO: checking for egrep" >&5
-echo $ECHO_N "checking for egrep... $ECHO_C" >&6
-if test "${ac_cv_prog_egrep+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
-    then ac_cv_prog_egrep='grep -E'
-    else ac_cv_prog_egrep='egrep'
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
     fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
 fi
-echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
-echo "${ECHO_T}$ac_cv_prog_egrep" >&6
- EGREP=$ac_cv_prog_egrep
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
 
 
-echo "$as_me:$LINENO: checking for ANSI C header files" >&5
-echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
-if test "${ac_cv_header_stdc+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <stdlib.h>
 #include <stdarg.h>
@@ -2713,51 +3551,23 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   ac_cv_header_stdc=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_header_stdc=no
+  ac_cv_header_stdc=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
 if test $ac_cv_header_stdc = yes; then
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <string.h>
 
 _ACEOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "memchr" >/dev/null 2>&1; then
-  :
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
 else
   ac_cv_header_stdc=no
 fi
@@ -2767,18 +3577,14 @@ fi
 
 if test $ac_cv_header_stdc = yes; then
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <stdlib.h>
 
 _ACEOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "free" >/dev/null 2>&1; then
-  :
+  $EGREP "free" >/dev/null 2>&1; then :
+
 else
   ac_cv_header_stdc=no
 fi
@@ -2788,16 +3594,13 @@ fi
 
 if test $ac_cv_header_stdc = yes; then
   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
-  if test "$cross_compiling" = yes; then
+  if test "$cross_compiling" = yes; then :
   :
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <ctype.h>
+#include <stdlib.h>
 #if ((' ' & 0x0FF) == 0x020)
 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
@@ -2817,109 +3620,39 @@ main ()
   for (i = 0; i < 256; i++)
     if (XOR (islower (i), ISLOWER (i))
 	|| toupper (i) != TOUPPER (i))
-      exit(2);
-  exit (0);
+      return 2;
+  return 0;
 }
 _ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  :
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+if ac_fn_c_try_run "$LINENO"; then :
 
-( exit $ac_status )
-ac_cv_header_stdc=no
+else
+  ac_cv_header_stdc=no
 fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
+
 fi
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
-echo "${ECHO_T}$ac_cv_header_stdc" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
 if test $ac_cv_header_stdc = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define STDC_HEADERS 1
-_ACEOF
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
 
 fi
 
 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
-
-
-
-
-
-
-
-
-
 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
 		  inttypes.h stdint.h unistd.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-
-#include <$ac_header>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_Header=yes"
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_Header=no"
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
   cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
 _ACEOF
 
 fi
@@ -2928,17 +3661,13 @@ done
 
 
 
-    echo "$as_me:$LINENO: checking dirent.h" >&5
-echo $ECHO_N "checking dirent.h... $ECHO_C" >&6
-if test "${tcl_cv_dirent_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking dirent.h" >&5
+$as_echo_n "checking dirent.h... " >&6; }
+if ${tcl_cv_dirent_h+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/types.h>
 #include <dirent.h>
@@ -2968,3793 +3697,1350 @@ closedir(d);
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_dirent_h=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_dirent_h=no
+  tcl_cv_dirent_h=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_dirent_h" >&5
-echo "${ECHO_T}$tcl_cv_dirent_h" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_dirent_h" >&5
+$as_echo "$tcl_cv_dirent_h" >&6; }
 
     if test $tcl_cv_dirent_h = no; then
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_DIRENT_H 1
-_ACEOF
+$as_echo "#define NO_DIRENT_H 1" >>confdefs.h
 
     fi
 
-    if test "${ac_cv_header_float_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for float.h" >&5
-echo $ECHO_N "checking for float.h... $ECHO_C" >&6
-if test "${ac_cv_header_float_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_float_h" >&5
-echo "${ECHO_T}$ac_cv_header_float_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking float.h usability" >&5
-echo $ECHO_N "checking float.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <float.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
+    ac_fn_c_check_header_mongrel "$LINENO" "float.h" "ac_cv_header_float_h" "$ac_includes_default"
+if test "x$ac_cv_header_float_h" = xyes; then :
+
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
+$as_echo "#define NO_FLOAT_H 1" >>confdefs.h
 
-# Is the header present?
-echo "$as_me:$LINENO: checking float.h presence" >&5
-echo $ECHO_N "checking float.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <float.h>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
 fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: float.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: float.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: float.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: float.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: float.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: float.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: float.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: float.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: float.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: float.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: float.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: float.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: float.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: float.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: float.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: float.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for float.h" >&5
-echo $ECHO_N "checking for float.h... $ECHO_C" >&6
-if test "${ac_cv_header_float_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_cv_header_float_h=$ac_header_preproc
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_float_h" >&5
-echo "${ECHO_T}$ac_cv_header_float_h" >&6
+    ac_fn_c_check_header_mongrel "$LINENO" "values.h" "ac_cv_header_values_h" "$ac_includes_default"
+if test "x$ac_cv_header_values_h" = xyes; then :
 
-fi
-if test $ac_cv_header_float_h = yes; then
-  :
 else
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_FLOAT_H 1
-_ACEOF
+$as_echo "#define NO_VALUES_H 1" >>confdefs.h
 
 fi
 
 
-    if test "${ac_cv_header_values_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for values.h" >&5
-echo $ECHO_N "checking for values.h... $ECHO_C" >&6
-if test "${ac_cv_header_values_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_values_h" >&5
-echo "${ECHO_T}$ac_cv_header_values_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking values.h usability" >&5
-echo $ECHO_N "checking values.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <values.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+    ac_fn_c_check_header_mongrel "$LINENO" "limits.h" "ac_cv_header_limits_h" "$ac_includes_default"
+if test "x$ac_cv_header_limits_h" = xyes; then :
 
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
+$as_echo "#define HAVE_LIMITS_H 1" >>confdefs.h
 
-# Is the header present?
-echo "$as_me:$LINENO: checking values.h presence" >&5
-echo $ECHO_N "checking values.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <values.h>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-  ac_header_preproc=no
+$as_echo "#define NO_LIMITS_H 1" >>confdefs.h
+
 fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: values.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: values.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: values.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: values.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: values.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: values.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: values.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: values.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: values.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: values.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: values.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: values.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: values.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: values.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: values.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: values.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for values.h" >&5
-echo $ECHO_N "checking for values.h... $ECHO_C" >&6
-if test "${ac_cv_header_values_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+
+    ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
+if test "x$ac_cv_header_stdlib_h" = xyes; then :
+  tcl_ok=1
 else
-  ac_cv_header_values_h=$ac_header_preproc
+  tcl_ok=0
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_values_h" >&5
-echo "${ECHO_T}$ac_cv_header_values_h" >&6
 
-fi
-if test $ac_cv_header_values_h = yes; then
-  :
-else
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_VALUES_H 1
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
 _ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strtol" >/dev/null 2>&1; then :
 
+else
+  tcl_ok=0
 fi
+rm -f conftest*
 
-
-    if test "${ac_cv_header_limits_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for limits.h" >&5
-echo $ECHO_N "checking for limits.h... $ECHO_C" >&6
-if test "${ac_cv_header_limits_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_limits_h" >&5
-echo "${ECHO_T}$ac_cv_header_limits_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking limits.h usability" >&5
-echo $ECHO_N "checking limits.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
-#include <limits.h>
+#include <stdlib.h>
+
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strtoul" >/dev/null 2>&1; then :
 
-ac_header_compiler=no
+else
+  tcl_ok=0
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
+rm -f conftest*
 
-# Is the header present?
-echo "$as_me:$LINENO: checking limits.h presence" >&5
-echo $ECHO_N "checking limits.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#include <limits.h>
+#include <stdlib.h>
+
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strtod" >/dev/null 2>&1; then :
+
 else
-  ac_cpp_err=yes
+  tcl_ok=0
 fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+rm -f conftest*
 
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
+    if test $tcl_ok = 0; then
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: limits.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: limits.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: limits.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: limits.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: limits.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: limits.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: limits.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: limits.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: limits.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: limits.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: limits.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: limits.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: limits.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: limits.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: limits.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: limits.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for limits.h" >&5
-echo $ECHO_N "checking for limits.h... $ECHO_C" >&6
-if test "${ac_cv_header_limits_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+$as_echo "#define NO_STDLIB_H 1" >>confdefs.h
+
+    fi
+    ac_fn_c_check_header_mongrel "$LINENO" "string.h" "ac_cv_header_string_h" "$ac_includes_default"
+if test "x$ac_cv_header_string_h" = xyes; then :
+  tcl_ok=1
 else
-  ac_cv_header_limits_h=$ac_header_preproc
+  tcl_ok=0
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_limits_h" >&5
-echo "${ECHO_T}$ac_cv_header_limits_h" >&6
 
-fi
-if test $ac_cv_header_limits_h = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_LIMITS_H 1
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
 _ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strstr" >/dev/null 2>&1; then :
 
 else
+  tcl_ok=0
+fi
+rm -f conftest*
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_LIMITS_H 1
 _ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strerror" >/dev/null 2>&1; then :
 
+else
+  tcl_ok=0
 fi
+rm -f conftest*
 
 
-    if test "${ac_cv_header_stdlib_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for stdlib.h" >&5
-echo $ECHO_N "checking for stdlib.h... $ECHO_C" >&6
-if test "${ac_cv_header_stdlib_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_stdlib_h" >&5
-echo "${ECHO_T}$ac_cv_header_stdlib_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking stdlib.h usability" >&5
-echo $ECHO_N "checking stdlib.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <stdlib.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+    # See also memmove check below for a place where NO_STRING_H can be
+    # set and why.
 
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
+    if test $tcl_ok = 0; then
 
-# Is the header present?
-echo "$as_me:$LINENO: checking stdlib.h presence" >&5
-echo $ECHO_N "checking stdlib.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <stdlib.h>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+$as_echo "#define NO_STRING_H 1" >>confdefs.h
 
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
+    fi
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: stdlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: stdlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: stdlib.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: stdlib.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: stdlib.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: stdlib.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: stdlib.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: stdlib.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: stdlib.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: stdlib.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: stdlib.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: stdlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: stdlib.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: stdlib.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: stdlib.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: stdlib.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for stdlib.h" >&5
-echo $ECHO_N "checking for stdlib.h... $ECHO_C" >&6
-if test "${ac_cv_header_stdlib_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_cv_header_stdlib_h=$ac_header_preproc
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_stdlib_h" >&5
-echo "${ECHO_T}$ac_cv_header_stdlib_h" >&6
+    ac_fn_c_check_header_mongrel "$LINENO" "sys/wait.h" "ac_cv_header_sys_wait_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_wait_h" = xyes; then :
 
-fi
-if test $ac_cv_header_stdlib_h = yes; then
-  tcl_ok=1
 else
-  tcl_ok=0
+
+$as_echo "#define NO_SYS_WAIT_H 1" >>confdefs.h
+
 fi
 
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <stdlib.h>
+    ac_fn_c_check_header_mongrel "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default"
+if test "x$ac_cv_header_dlfcn_h" = xyes; then :
 
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "strtol" >/dev/null 2>&1; then
-  :
 else
-  tcl_ok=0
-fi
-rm -f conftest*
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <stdlib.h>
+$as_echo "#define NO_DLFCN_H 1" >>confdefs.h
 
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "strtoul" >/dev/null 2>&1; then
-  :
-else
-  tcl_ok=0
 fi
-rm -f conftest*
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <stdlib.h>
 
+
+    # OS/390 lacks sys/param.h (and doesn't need it, by chance).
+    for ac_header in sys/param.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "sys/param.h" "ac_cv_header_sys_param_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_param_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_SYS_PARAM_H 1
 _ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "strtod" >/dev/null 2>&1; then
-  :
-else
-  tcl_ok=0
+
 fi
-rm -f conftest*
 
-    if test $tcl_ok = 0; then
+done
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_STDLIB_H 1
-_ACEOF
 
-    fi
-    if test "${ac_cv_header_string_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for string.h" >&5
-echo $ECHO_N "checking for string.h... $ECHO_C" >&6
-if test "${ac_cv_header_string_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_string_h" >&5
-echo "${ECHO_T}$ac_cv_header_string_h" >&6
+
+#------------------------------------------------------------------------
+# If we're using GCC, see if the compiler understands -pipe.  If so, use it.
+# It makes compiling go faster.  (This is only a performance feature.)
+#------------------------------------------------------------------------
+
+if test -z "$no_pipe" && test -n "$GCC"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the compiler understands -pipe" >&5
+$as_echo_n "checking if the compiler understands -pipe... " >&6; }
+if ${tcl_cv_cc_pipe+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking string.h usability" >&5
-echo $ECHO_N "checking string.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+
+	hold_cflags=$CFLAGS; CFLAGS="$CFLAGS -pipe"
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
-#include <string.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
+int
+main ()
+{
 
-# Is the header present?
-echo "$as_me:$LINENO: checking string.h presence" >&5
-echo $ECHO_N "checking string.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <string.h>
+  ;
+  return 0;
+}
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_cc_pipe=yes
 else
-  ac_cpp_err=yes
+  tcl_cv_cc_pipe=no
 fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+	CFLAGS=$hold_cflags
 fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: string.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: string.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: string.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: string.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: string.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: string.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: string.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: string.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: string.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: string.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: string.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: string.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: string.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: string.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: string.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: string.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for string.h" >&5
-echo $ECHO_N "checking for string.h... $ECHO_C" >&6
-if test "${ac_cv_header_string_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_cv_header_string_h=$ac_header_preproc
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cc_pipe" >&5
+$as_echo "$tcl_cv_cc_pipe" >&6; }
+    if test $tcl_cv_cc_pipe = yes; then
+	CFLAGS="$CFLAGS -pipe"
+    fi
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_string_h" >&5
-echo "${ECHO_T}$ac_cv_header_string_h" >&6
 
-fi
-if test $ac_cv_header_string_h = yes; then
-  tcl_ok=1
+#------------------------------------------------------------------------
+# Threads support
+#------------------------------------------------------------------------
+
+
+    # Check whether --enable-threads was given.
+if test "${enable_threads+set}" = set; then :
+  enableval=$enable_threads; tcl_ok=$enableval
 else
-  tcl_ok=0
+  tcl_ok=no
 fi
 
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <string.h>
+    if test "${TCL_THREADS}" = 1; then
+	tcl_threaded_core=1;
+    fi
 
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "strstr" >/dev/null 2>&1; then
-  :
-else
-  tcl_ok=0
-fi
-rm -f conftest*
+    if test "$tcl_ok" = "yes" -o "${TCL_THREADS}" = 1; then
+	TCL_THREADS=1
+	# USE_THREAD_ALLOC tells us to try the special thread-based
+	# allocator that significantly reduces lock contention
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <string.h>
+$as_echo "#define USE_THREAD_ALLOC 1" >>confdefs.h
 
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "strerror" >/dev/null 2>&1; then
-  :
-else
-  tcl_ok=0
-fi
-rm -f conftest*
 
+$as_echo "#define _REENTRANT 1" >>confdefs.h
 
-    # See also memmove check below for a place where NO_STRING_H can be
-    # set and why.
+	if test "`uname -s`" = "SunOS" ; then
 
-    if test $tcl_ok = 0; then
+$as_echo "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_STRING_H 1
-_ACEOF
+	fi
 
-    fi
+$as_echo "#define _THREAD_SAFE 1" >>confdefs.h
 
-    if test "${ac_cv_header_sys_wait_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for sys/wait.h" >&5
-echo $ECHO_N "checking for sys/wait.h... $ECHO_C" >&6
-if test "${ac_cv_header_sys_wait_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_sys_wait_h" >&5
-echo "${ECHO_T}$ac_cv_header_sys_wait_h" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_mutex_init in -lpthread" >&5
+$as_echo_n "checking for pthread_mutex_init in -lpthread... " >&6; }
+if ${ac_cv_lib_pthread_pthread_mutex_init+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking sys/wait.h usability" >&5
-echo $ECHO_N "checking sys/wait.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lpthread  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
-#include <sys/wait.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
 
-# Is the header present?
-echo "$as_me:$LINENO: checking sys/wait.h presence" >&5
-echo $ECHO_N "checking sys/wait.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <sys/wait.h>
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char pthread_mutex_init ();
+int
+main ()
+{
+return pthread_mutex_init ();
+  ;
+  return 0;
+}
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_pthread_pthread_mutex_init=yes
 else
-  ac_cpp_err=yes
+  ac_cv_lib_pthread_pthread_mutex_init=no
 fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: sys/wait.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: sys/wait.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: sys/wait.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: sys/wait.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: sys/wait.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: sys/wait.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: sys/wait.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/wait.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: sys/wait.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for sys/wait.h" >&5
-echo $ECHO_N "checking for sys/wait.h... $ECHO_C" >&6
-if test "${ac_cv_header_sys_wait_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_mutex_init" >&5
+$as_echo "$ac_cv_lib_pthread_pthread_mutex_init" >&6; }
+if test "x$ac_cv_lib_pthread_pthread_mutex_init" = xyes; then :
+  tcl_ok=yes
 else
-  ac_cv_header_sys_wait_h=$ac_header_preproc
+  tcl_ok=no
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_sys_wait_h" >&5
-echo "${ECHO_T}$ac_cv_header_sys_wait_h" >&6
 
-fi
-if test $ac_cv_header_sys_wait_h = yes; then
-  :
+	if test "$tcl_ok" = "no"; then
+	    # Check a little harder for __pthread_mutex_init in the same
+	    # library, as some systems hide it there until pthread.h is
+	    # defined.  We could alternatively do an AC_TRY_COMPILE with
+	    # pthread.h, but that will work with libpthread really doesn't
+	    # exist, like AIX 4.2.  [Bug: 4359]
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __pthread_mutex_init in -lpthread" >&5
+$as_echo_n "checking for __pthread_mutex_init in -lpthread... " >&6; }
+if ${ac_cv_lib_pthread___pthread_mutex_init+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lpthread  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_SYS_WAIT_H 1
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char __pthread_mutex_init ();
+int
+main ()
+{
+return __pthread_mutex_init ();
+  ;
+  return 0;
+}
 _ACEOF
-
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_pthread___pthread_mutex_init=yes
+else
+  ac_cv_lib_pthread___pthread_mutex_init=no
 fi
-
-
-    if test "${ac_cv_header_dlfcn_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for dlfcn.h" >&5
-echo $ECHO_N "checking for dlfcn.h... $ECHO_C" >&6
-if test "${ac_cv_header_dlfcn_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_dlfcn_h" >&5
-echo "${ECHO_T}$ac_cv_header_dlfcn_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking dlfcn.h usability" >&5
-echo $ECHO_N "checking dlfcn.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <dlfcn.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking dlfcn.h presence" >&5
-echo $ECHO_N "checking dlfcn.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <dlfcn.h>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: dlfcn.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: dlfcn.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: dlfcn.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: dlfcn.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: dlfcn.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: dlfcn.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: dlfcn.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: dlfcn.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: dlfcn.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for dlfcn.h" >&5
-echo $ECHO_N "checking for dlfcn.h... $ECHO_C" >&6
-if test "${ac_cv_header_dlfcn_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_cv_header_dlfcn_h=$ac_header_preproc
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_dlfcn_h" >&5
-echo "${ECHO_T}$ac_cv_header_dlfcn_h" >&6
-
-fi
-if test $ac_cv_header_dlfcn_h = yes; then
-  :
-else
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_DLFCN_H 1
-_ACEOF
-
-fi
-
-
-
-    # OS/390 lacks sys/param.h (and doesn't need it, by chance).
-
-for ac_header in sys/param.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  eval "$as_ac_Header=\$ac_header_preproc"
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-
-fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-_ACEOF
-
-fi
-
-done
-
-
-
-#------------------------------------------------------------------------
-# If we're using GCC, see if the compiler understands -pipe.  If so, use it.
-# It makes compiling go faster.  (This is only a performance feature.)
-#------------------------------------------------------------------------
-
-if test -z "$no_pipe" && test -n "$GCC"; then
-    echo "$as_me:$LINENO: checking if the compiler understands -pipe" >&5
-echo $ECHO_N "checking if the compiler understands -pipe... $ECHO_C" >&6
-if test "${tcl_cv_cc_pipe+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	hold_cflags=$CFLAGS; CFLAGS="$CFLAGS -pipe"
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_cc_pipe=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cc_pipe=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-	CFLAGS=$hold_cflags
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_cc_pipe" >&5
-echo "${ECHO_T}$tcl_cv_cc_pipe" >&6
-    if test $tcl_cv_cc_pipe = yes; then
-	CFLAGS="$CFLAGS -pipe"
-    fi
-fi
-
-#------------------------------------------------------------------------
-# Threads support
-#------------------------------------------------------------------------
-
-
-    # Check whether --enable-threads or --disable-threads was given.
-if test "${enable_threads+set}" = set; then
-  enableval="$enable_threads"
-  tcl_ok=$enableval
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread___pthread_mutex_init" >&5
+$as_echo "$ac_cv_lib_pthread___pthread_mutex_init" >&6; }
+if test "x$ac_cv_lib_pthread___pthread_mutex_init" = xyes; then :
+  tcl_ok=yes
 else
   tcl_ok=no
-fi;
-
-    if test "${TCL_THREADS}" = 1; then
-	tcl_threaded_core=1;
-    fi
-
-    if test "$tcl_ok" = "yes" -o "${TCL_THREADS}" = 1; then
-	TCL_THREADS=1
-	# USE_THREAD_ALLOC tells us to try the special thread-based
-	# allocator that significantly reduces lock contention
-
-cat >>confdefs.h <<\_ACEOF
-#define USE_THREAD_ALLOC 1
-_ACEOF
-
-
-cat >>confdefs.h <<\_ACEOF
-#define _REENTRANT 1
-_ACEOF
-
-	if test "`uname -s`" = "SunOS" ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define _POSIX_PTHREAD_SEMANTICS 1
-_ACEOF
+fi
 
 	fi
 
-cat >>confdefs.h <<\_ACEOF
-#define _THREAD_SAFE 1
-_ACEOF
-
-	echo "$as_me:$LINENO: checking for pthread_mutex_init in -lpthread" >&5
-echo $ECHO_N "checking for pthread_mutex_init in -lpthread... $ECHO_C" >&6
-if test "${ac_cv_lib_pthread_pthread_mutex_init+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	if test "$tcl_ok" = "yes"; then
+	    # The space is needed
+	    THREADS_LIBS=" -lpthread"
+	else
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_mutex_init in -lpthreads" >&5
+$as_echo_n "checking for pthread_mutex_init in -lpthreads... " >&6; }
+if ${ac_cv_lib_pthreads_pthread_mutex_init+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
-LIBS="-lpthread  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+LIBS="-lpthreads  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
 char pthread_mutex_init ();
 int
 main ()
 {
-pthread_mutex_init ();
+return pthread_mutex_init ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_pthread_pthread_mutex_init=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_pthreads_pthread_mutex_init=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_pthread_pthread_mutex_init=no
+  ac_cv_lib_pthreads_pthread_mutex_init=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_mutex_init" >&5
-echo "${ECHO_T}$ac_cv_lib_pthread_pthread_mutex_init" >&6
-if test $ac_cv_lib_pthread_pthread_mutex_init = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthreads_pthread_mutex_init" >&5
+$as_echo "$ac_cv_lib_pthreads_pthread_mutex_init" >&6; }
+if test "x$ac_cv_lib_pthreads_pthread_mutex_init" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
 fi
 
-	if test "$tcl_ok" = "no"; then
-	    # Check a little harder for __pthread_mutex_init in the same
-	    # library, as some systems hide it there until pthread.h is
-	    # defined.  We could alternatively do an AC_TRY_COMPILE with
-	    # pthread.h, but that will work with libpthread really doesn't
-	    # exist, like AIX 4.2.  [Bug: 4359]
-	    echo "$as_me:$LINENO: checking for __pthread_mutex_init in -lpthread" >&5
-echo $ECHO_N "checking for __pthread_mutex_init in -lpthread... $ECHO_C" >&6
-if test "${ac_cv_lib_pthread___pthread_mutex_init+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    if test "$tcl_ok" = "yes"; then
+		# The space is needed
+		THREADS_LIBS=" -lpthreads"
+	    else
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_mutex_init in -lc" >&5
+$as_echo_n "checking for pthread_mutex_init in -lc... " >&6; }
+if ${ac_cv_lib_c_pthread_mutex_init+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
-LIBS="-lpthread  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+LIBS="-lc  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char __pthread_mutex_init ();
+char pthread_mutex_init ();
 int
 main ()
 {
-__pthread_mutex_init ();
+return pthread_mutex_init ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_pthread___pthread_mutex_init=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_c_pthread_mutex_init=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_pthread___pthread_mutex_init=no
+  ac_cv_lib_c_pthread_mutex_init=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_pthread___pthread_mutex_init" >&5
-echo "${ECHO_T}$ac_cv_lib_pthread___pthread_mutex_init" >&6
-if test $ac_cv_lib_pthread___pthread_mutex_init = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_pthread_mutex_init" >&5
+$as_echo "$ac_cv_lib_c_pthread_mutex_init" >&6; }
+if test "x$ac_cv_lib_c_pthread_mutex_init" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
 fi
 
-	fi
-
-	if test "$tcl_ok" = "yes"; then
-	    # The space is needed
-	    THREADS_LIBS=" -lpthread"
-	else
-	    echo "$as_me:$LINENO: checking for pthread_mutex_init in -lpthreads" >&5
-echo $ECHO_N "checking for pthread_mutex_init in -lpthreads... $ECHO_C" >&6
-if test "${ac_cv_lib_pthreads_pthread_mutex_init+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+		if test "$tcl_ok" = "no"; then
+		    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_mutex_init in -lc_r" >&5
+$as_echo_n "checking for pthread_mutex_init in -lc_r... " >&6; }
+if ${ac_cv_lib_c_r_pthread_mutex_init+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
-LIBS="-lpthreads  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+LIBS="-lc_r  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
 char pthread_mutex_init ();
 int
 main ()
 {
-pthread_mutex_init ();
+return pthread_mutex_init ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_pthreads_pthread_mutex_init=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_c_r_pthread_mutex_init=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_pthreads_pthread_mutex_init=no
+  ac_cv_lib_c_r_pthread_mutex_init=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_pthreads_pthread_mutex_init" >&5
-echo "${ECHO_T}$ac_cv_lib_pthreads_pthread_mutex_init" >&6
-if test $ac_cv_lib_pthreads_pthread_mutex_init = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_r_pthread_mutex_init" >&5
+$as_echo "$ac_cv_lib_c_r_pthread_mutex_init" >&6; }
+if test "x$ac_cv_lib_c_r_pthread_mutex_init" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
 fi
 
-	    if test "$tcl_ok" = "yes"; then
-		# The space is needed
-		THREADS_LIBS=" -lpthreads"
-	    else
-		echo "$as_me:$LINENO: checking for pthread_mutex_init in -lc" >&5
-echo $ECHO_N "checking for pthread_mutex_init in -lc... $ECHO_C" >&6
-if test "${ac_cv_lib_c_pthread_mutex_init+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lc  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+		    if test "$tcl_ok" = "yes"; then
+			# The space is needed
+			THREADS_LIBS=" -pthread"
+		    else
+			TCL_THREADS=0
+			{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Don't know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile..." >&5
+$as_echo "$as_me: WARNING: Don't know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile..." >&2;}
+		    fi
+		fi
+	    fi
+	fi
+
+	# Does the pthread-implementation provide
+	# 'pthread_attr_setstacksize' ?
+
+	ac_saved_libs=$LIBS
+	LIBS="$LIBS $THREADS_LIBS"
+	for ac_func in pthread_attr_setstacksize pthread_atfork
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char pthread_mutex_init ();
-int
-main ()
-{
-pthread_mutex_init ();
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_c_pthread_mutex_init=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_c_pthread_mutex_init=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_c_pthread_mutex_init" >&5
-echo "${ECHO_T}$ac_cv_lib_c_pthread_mutex_init" >&6
-if test $ac_cv_lib_c_pthread_mutex_init = yes; then
+done
+
+	ac_fn_c_check_func "$LINENO" "pthread_attr_get_np" "ac_cv_func_pthread_attr_get_np"
+if test "x$ac_cv_func_pthread_attr_get_np" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
 fi
 
-		if test "$tcl_ok" = "no"; then
-		    echo "$as_me:$LINENO: checking for pthread_mutex_init in -lc_r" >&5
-echo $ECHO_N "checking for pthread_mutex_init in -lc_r... $ECHO_C" >&6
-if test "${ac_cv_lib_c_r_pthread_mutex_init+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	if test $tcl_ok = yes ; then
+
+$as_echo "#define HAVE_PTHREAD_ATTR_GET_NP 1" >>confdefs.h
+
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_attr_get_np declaration" >&5
+$as_echo_n "checking for pthread_attr_get_np declaration... " >&6; }
+if ${tcl_cv_grep_pthread_attr_get_np+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lc_r  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+
+		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+#include <pthread.h>
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char pthread_mutex_init ();
-int
-main ()
-{
-pthread_mutex_init ();
-  ;
-  return 0;
-}
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_c_r_pthread_mutex_init=yes
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "pthread_attr_get_np" >/dev/null 2>&1; then :
+  tcl_cv_grep_pthread_attr_get_np=present
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_c_r_pthread_mutex_init=no
+  tcl_cv_grep_pthread_attr_get_np=missing
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+rm -f conftest*
+
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_c_r_pthread_mutex_init" >&5
-echo "${ECHO_T}$ac_cv_lib_c_r_pthread_mutex_init" >&6
-if test $ac_cv_lib_c_r_pthread_mutex_init = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_grep_pthread_attr_get_np" >&5
+$as_echo "$tcl_cv_grep_pthread_attr_get_np" >&6; }
+	    if test $tcl_cv_grep_pthread_attr_get_np = missing ; then
+
+$as_echo "#define ATTRGETNP_NOT_DECLARED 1" >>confdefs.h
+
+	    fi
+	else
+	    ac_fn_c_check_func "$LINENO" "pthread_getattr_np" "ac_cv_func_pthread_getattr_np"
+if test "x$ac_cv_func_pthread_getattr_np" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
 fi
 
-		    if test "$tcl_ok" = "yes"; then
-			# The space is needed
-			THREADS_LIBS=" -pthread"
-		    else
-			TCL_THREADS=0
-			{ echo "$as_me:$LINENO: WARNING: Don't know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile..." >&5
-echo "$as_me: WARNING: Don't know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile..." >&2;}
-		    fi
+	    if test $tcl_ok = yes ; then
+
+$as_echo "#define HAVE_PTHREAD_GETATTR_NP 1" >>confdefs.h
+
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_getattr_np declaration" >&5
+$as_echo_n "checking for pthread_getattr_np declaration... " >&6; }
+if ${tcl_cv_grep_pthread_getattr_np+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+		    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <pthread.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "pthread_getattr_np" >/dev/null 2>&1; then :
+  tcl_cv_grep_pthread_getattr_np=present
+else
+  tcl_cv_grep_pthread_getattr_np=missing
+fi
+rm -f conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_grep_pthread_getattr_np" >&5
+$as_echo "$tcl_cv_grep_pthread_getattr_np" >&6; }
+		if test $tcl_cv_grep_pthread_getattr_np = missing ; then
+
+$as_echo "#define GETATTRNP_NOT_DECLARED 1" >>confdefs.h
+
 		fi
 	    fi
 	fi
+	if test $tcl_ok = no; then
+	    # Darwin thread stacksize API
+	    for ac_func in pthread_get_stacksize_np
+do :
+  ac_fn_c_check_func "$LINENO" "pthread_get_stacksize_np" "ac_cv_func_pthread_get_stacksize_np"
+if test "x$ac_cv_func_pthread_get_stacksize_np" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_PTHREAD_GET_STACKSIZE_NP 1
+_ACEOF
 
-	# Does the pthread-implementation provide
-	# 'pthread_attr_setstacksize' ?
+fi
+done
 
-	ac_saved_libs=$LIBS
-	LIBS="$LIBS $THREADS_LIBS"
+	fi
+	LIBS=$ac_saved_libs
+    else
+	TCL_THREADS=0
+    fi
+    # Do checking message here to not mess up interleaved configure output
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for building with threads" >&5
+$as_echo_n "checking for building with threads... " >&6; }
+    if test "${TCL_THREADS}" = 1; then
 
+$as_echo "#define TCL_THREADS 1" >>confdefs.h
 
-for ac_func in pthread_attr_setstacksize pthread_atfork
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+	if test "${tcl_threaded_core}" = 1; then
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (threaded core)" >&5
+$as_echo "yes (threaded core)" >&6; }
+	else
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+	fi
+    else
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no (default)" >&5
+$as_echo "no (default)" >&6; }
+    fi
+
+
+
+
+#------------------------------------------------------------------------
+# Embedded configuration information, encoding to use for the values, TIP #59
+#------------------------------------------------------------------------
+
+
+
+# Check whether --with-encoding was given.
+if test "${with_encoding+set}" = set; then :
+  withval=$with_encoding; with_tcencoding=${withval}
+fi
+
+
+    if test x"${with_tcencoding}" != x ; then
+
+cat >>confdefs.h <<_ACEOF
+#define TCL_CFGVAL_ENCODING "${with_tcencoding}"
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+    else
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+$as_echo "#define TCL_CFGVAL_ENCODING \"iso8859-1\"" >>confdefs.h
 
-#undef $ac_func
+    fi
+
+
+#--------------------------------------------------------------------
+# Look for libraries that we will need when compiling the Tcl shell
+#--------------------------------------------------------------------
+
+
+    #--------------------------------------------------------------------
+    # On a few very rare systems, all of the libm.a stuff is
+    # already in libc.a.  Set compiler flags accordingly.
+    # Also, Linux requires the "ieee" library for math to work
+    # right (and it must appear before "-lm").
+    #--------------------------------------------------------------------
+
+    ac_fn_c_check_func "$LINENO" "sin" "ac_cv_func_sin"
+if test "x$ac_cv_func_sin" = xyes; then :
+  MATH_LIBS=""
+else
+  MATH_LIBS="-lm"
+fi
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lieee" >&5
+$as_echo_n "checking for main in -lieee... " >&6; }
+if ${ac_cv_lib_ieee_main+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lieee  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
 
 int
 main ()
 {
-return f != $ac_func;
+return main ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_ieee_main=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
+  ac_cv_lib_ieee_main=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-_ACEOF
-
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ieee_main" >&5
+$as_echo "$ac_cv_lib_ieee_main" >&6; }
+if test "x$ac_cv_lib_ieee_main" = xyes; then :
+  MATH_LIBS="-lieee $MATH_LIBS"
 fi
-done
 
-	echo "$as_me:$LINENO: checking for pthread_attr_get_np" >&5
-echo $ECHO_N "checking for pthread_attr_get_np... $ECHO_C" >&6
-if test "${ac_cv_func_pthread_attr_get_np+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define pthread_attr_get_np to an innocuous variant, in case <limits.h> declares pthread_attr_get_np.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define pthread_attr_get_np innocuous_pthread_attr_get_np
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char pthread_attr_get_np (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+    #--------------------------------------------------------------------
+    # Interactive UNIX requires -linet instead of -lsocket, plus it
+    # needs net/errno.h to define the socket-related error codes.
+    #--------------------------------------------------------------------
 
-#undef pthread_attr_get_np
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -linet" >&5
+$as_echo_n "checking for main in -linet... " >&6; }
+if ${ac_cv_lib_inet_main+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-linet  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char pthread_attr_get_np ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_pthread_attr_get_np) || defined (__stub___pthread_attr_get_np)
-choke me
-#else
-char (*f) () = pthread_attr_get_np;
-#endif
-#ifdef __cplusplus
-}
-#endif
 
 int
 main ()
 {
-return f != pthread_attr_get_np;
+return main ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_pthread_attr_get_np=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_inet_main=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_pthread_attr_get_np=no
+  ac_cv_lib_inet_main=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_pthread_attr_get_np" >&5
-echo "${ECHO_T}$ac_cv_func_pthread_attr_get_np" >&6
-if test $ac_cv_func_pthread_attr_get_np = yes; then
-  tcl_ok=yes
-else
-  tcl_ok=no
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_inet_main" >&5
+$as_echo "$ac_cv_lib_inet_main" >&6; }
+if test "x$ac_cv_lib_inet_main" = xyes; then :
+  LIBS="$LIBS -linet"
 fi
 
-	if test $tcl_ok = yes ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_PTHREAD_ATTR_GET_NP 1
-_ACEOF
-
-	    echo "$as_me:$LINENO: checking for pthread_attr_get_np declaration" >&5
-echo $ECHO_N "checking for pthread_attr_get_np declaration... $ECHO_C" >&6
-if test "${tcl_cv_grep_pthread_attr_get_np+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
+    ac_fn_c_check_header_mongrel "$LINENO" "net/errno.h" "ac_cv_header_net_errno_h" "$ac_includes_default"
+if test "x$ac_cv_header_net_errno_h" = xyes; then :
 
-		cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <pthread.h>
 
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "pthread_attr_get_np" >/dev/null 2>&1; then
-  tcl_cv_grep_pthread_attr_get_np=present
-else
-  tcl_cv_grep_pthread_attr_get_np=missing
-fi
-rm -f conftest*
+$as_echo "#define HAVE_NET_ERRNO_H 1" >>confdefs.h
 
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_grep_pthread_attr_get_np" >&5
-echo "${ECHO_T}$tcl_cv_grep_pthread_attr_get_np" >&6
-	    if test $tcl_cv_grep_pthread_attr_get_np = missing ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define ATTRGETNP_NOT_DECLARED 1
-_ACEOF
 
-	    fi
-	else
-	    echo "$as_me:$LINENO: checking for pthread_getattr_np" >&5
-echo $ECHO_N "checking for pthread_getattr_np... $ECHO_C" >&6
-if test "${ac_cv_func_pthread_getattr_np+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define pthread_getattr_np to an innocuous variant, in case <limits.h> declares pthread_getattr_np.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define pthread_getattr_np innocuous_pthread_getattr_np
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char pthread_getattr_np (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+    #--------------------------------------------------------------------
+    #	Check for the existence of the -lsocket and -lnsl libraries.
+    #	The order here is important, so that they end up in the right
+    #	order in the command line generated by make.  Here are some
+    #	special considerations:
+    #	1. Use "connect" and "accept" to check for -lsocket, and
+    #	   "gethostbyname" to check for -lnsl.
+    #	2. Use each function name only once:  can't redo a check because
+    #	   autoconf caches the results of the last check and won't redo it.
+    #	3. Use -lnsl and -lsocket only if they supply procedures that
+    #	   aren't already present in the normal libraries.  This is because
+    #	   IRIX 5.2 has libraries, but they aren't needed and they're
+    #	   bogus:  they goof up name resolution if used.
+    #	4. On some SVR4 systems, can't use -lsocket without -lnsl too.
+    #	   To get around this problem, check for both libraries together
+    #	   if -lsocket doesn't work by itself.
+    #--------------------------------------------------------------------
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+    tcl_checkBoth=0
+    ac_fn_c_check_func "$LINENO" "connect" "ac_cv_func_connect"
+if test "x$ac_cv_func_connect" = xyes; then :
+  tcl_checkSocket=0
+else
+  tcl_checkSocket=1
+fi
 
-#undef pthread_getattr_np
+    if test "$tcl_checkSocket" = 1; then
+	ac_fn_c_check_func "$LINENO" "setsockopt" "ac_cv_func_setsockopt"
+if test "x$ac_cv_func_setsockopt" = xyes; then :
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for setsockopt in -lsocket" >&5
+$as_echo_n "checking for setsockopt in -lsocket... " >&6; }
+if ${ac_cv_lib_socket_setsockopt+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsocket  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
    builtin and then its argument prototype would still apply.  */
-char pthread_getattr_np ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_pthread_getattr_np) || defined (__stub___pthread_getattr_np)
-choke me
-#else
-char (*f) () = pthread_getattr_np;
-#endif
 #ifdef __cplusplus
-}
+extern "C"
 #endif
-
+char setsockopt ();
 int
 main ()
 {
-return f != pthread_getattr_np;
+return setsockopt ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_pthread_getattr_np=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_socket_setsockopt=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_pthread_getattr_np=no
+  ac_cv_lib_socket_setsockopt=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_pthread_getattr_np" >&5
-echo "${ECHO_T}$ac_cv_func_pthread_getattr_np" >&6
-if test $ac_cv_func_pthread_getattr_np = yes; then
-  tcl_ok=yes
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_setsockopt" >&5
+$as_echo "$ac_cv_lib_socket_setsockopt" >&6; }
+if test "x$ac_cv_lib_socket_setsockopt" = xyes; then :
+  LIBS="$LIBS -lsocket"
 else
-  tcl_ok=no
+  tcl_checkBoth=1
 fi
 
-	    if test $tcl_ok = yes ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_PTHREAD_GETATTR_NP 1
-_ACEOF
-
-		echo "$as_me:$LINENO: checking for pthread_getattr_np declaration" >&5
-echo $ECHO_N "checking for pthread_getattr_np declaration... $ECHO_C" >&6
-if test "${tcl_cv_grep_pthread_getattr_np+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-		    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <pthread.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "pthread_getattr_np" >/dev/null 2>&1; then
-  tcl_cv_grep_pthread_getattr_np=present
-else
-  tcl_cv_grep_pthread_getattr_np=missing
 fi
-rm -f conftest*
 
+    fi
+    if test "$tcl_checkBoth" = 1; then
+	tk_oldLibs=$LIBS
+	LIBS="$LIBS -lsocket -lnsl"
+	ac_fn_c_check_func "$LINENO" "accept" "ac_cv_func_accept"
+if test "x$ac_cv_func_accept" = xyes; then :
+  tcl_checkNsl=0
+else
+  LIBS=$tk_oldLibs
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_grep_pthread_getattr_np" >&5
-echo "${ECHO_T}$tcl_cv_grep_pthread_getattr_np" >&6
-		if test $tcl_cv_grep_pthread_getattr_np = missing ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define GETATTRNP_NOT_DECLARED 1
-_ACEOF
 
-		fi
-	    fi
-	fi
-	if test $tcl_ok = no; then
-	    # Darwin thread stacksize API
+    fi
+    ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
+if test "x$ac_cv_func_gethostbyname" = xyes; then :
 
-for ac_func in pthread_get_stacksize_np
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
+$as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
+if ${ac_cv_lib_nsl_gethostbyname+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lnsl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
 
-#undef $ac_func
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
    builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
 #ifdef __cplusplus
-}
+extern "C"
 #endif
-
+char gethostbyname ();
 int
 main ()
 {
-return f != $ac_func;
+return gethostbyname ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_nsl_gethostbyname=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
+  ac_cv_lib_nsl_gethostbyname=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-_ACEOF
-
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
+$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
+if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
+  LIBS="$LIBS -lnsl"
 fi
-done
-
-	fi
-	LIBS=$ac_saved_libs
-    else
-	TCL_THREADS=0
-    fi
-    # Do checking message here to not mess up interleaved configure output
-    echo "$as_me:$LINENO: checking for building with threads" >&5
-echo $ECHO_N "checking for building with threads... $ECHO_C" >&6
-    if test "${TCL_THREADS}" = 1; then
-
-cat >>confdefs.h <<\_ACEOF
-#define TCL_THREADS 1
-_ACEOF
-
-	if test "${tcl_threaded_core}" = 1; then
-	    echo "$as_me:$LINENO: result: yes (threaded core)" >&5
-echo "${ECHO_T}yes (threaded core)" >&6
-	else
-	    echo "$as_me:$LINENO: result: yes" >&5
-echo "${ECHO_T}yes" >&6
-	fi
-    else
-	echo "$as_me:$LINENO: result: no (default)" >&5
-echo "${ECHO_T}no (default)" >&6
-    fi
-
 
+fi
 
 
-#------------------------------------------------------------------------
-# Embedded configuration information, encoding to use for the values, TIP #59
-#------------------------------------------------------------------------
 
+# Add the threads support libraries
+LIBS="$LIBS$THREADS_LIBS"
 
 
-# Check whether --with-encoding or --without-encoding was given.
-if test "${with_encoding+set}" = set; then
-  withval="$with_encoding"
-  with_tcencoding=${withval}
-fi;
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to build libraries" >&5
+$as_echo_n "checking how to build libraries... " >&6; }
+    # Check whether --enable-shared was given.
+if test "${enable_shared+set}" = set; then :
+  enableval=$enable_shared; tcl_ok=$enableval
+else
+  tcl_ok=yes
+fi
 
-    if test x"${with_tcencoding}" != x ; then
 
-cat >>confdefs.h <<_ACEOF
-#define TCL_CFGVAL_ENCODING "${with_tcencoding}"
-_ACEOF
+    if test "${enable_shared+set}" = set; then
+	enableval="$enable_shared"
+	tcl_ok=$enableval
+    else
+	tcl_ok=yes
+    fi
 
+    if test "$tcl_ok" = "yes" ; then
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: shared" >&5
+$as_echo "shared" >&6; }
+	SHARED_BUILD=1
     else
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: static" >&5
+$as_echo "static" >&6; }
+	SHARED_BUILD=0
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_CFGVAL_ENCODING "iso8859-1"
-_ACEOF
+$as_echo "#define STATIC_BUILD 1" >>confdefs.h
 
     fi
 
 
 #--------------------------------------------------------------------
-# Look for libraries that we will need when compiling the Tcl shell
+# The statements below define a collection of compile flags.  This
+# macro depends on the value of SHARED_BUILD, and should be called
+# after SC_ENABLE_SHARED checks the configure switches.
 #--------------------------------------------------------------------
 
-
-    #--------------------------------------------------------------------
-    # On a few very rare systems, all of the libm.a stuff is
-    # already in libc.a.  Set compiler flags accordingly.
-    # Also, Linux requires the "ieee" library for math to work
-    # right (and it must appear before "-lm").
-    #--------------------------------------------------------------------
-
-    echo "$as_me:$LINENO: checking for sin" >&5
-echo $ECHO_N "checking for sin... $ECHO_C" >&6
-if test "${ac_cv_func_sin+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define sin to an innocuous variant, in case <limits.h> declares sin.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define sin innocuous_sin
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char sin (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef sin
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char sin ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_sin) || defined (__stub___sin)
-choke me
-#else
-char (*f) () = sin;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != sin;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_sin=yes
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
 
-ac_cv_func_sin=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_sin" >&5
-echo "${ECHO_T}$ac_cv_func_sin" >&6
-if test $ac_cv_func_sin = yes; then
-  MATH_LIBS=""
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+$as_echo "$RANLIB" >&6; }
 else
-  MATH_LIBS="-lm"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
-    echo "$as_me:$LINENO: checking for main in -lieee" >&5
-echo $ECHO_N "checking for main in -lieee... $ECHO_C" >&6
-if test "${ac_cv_lib_ieee_main+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lieee  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
 
-int
-main ()
-{
-main ();
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_ieee_main=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_ieee_main=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_ieee_main" >&5
-echo "${ECHO_T}$ac_cv_lib_ieee_main" >&6
-if test $ac_cv_lib_ieee_main = yes; then
-  MATH_LIBS="-lieee $MATH_LIBS"
 fi
-
-
-    #--------------------------------------------------------------------
-    # Interactive UNIX requires -linet instead of -lsocket, plus it
-    # needs net/errno.h to define the socket-related error codes.
-    #--------------------------------------------------------------------
-
-    echo "$as_me:$LINENO: checking for main in -linet" >&5
-echo $ECHO_N "checking for main in -linet... $ECHO_C" >&6
-if test "${ac_cv_lib_inet_main+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-linet  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-
-int
-main ()
-{
-main ();
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_inet_main=yes
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
 
-ac_cv_lib_inet_main=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_inet_main" >&5
-echo "${ECHO_T}$ac_cv_lib_inet_main" >&6
-if test $ac_cv_lib_inet_main = yes; then
-  LIBS="$LIBS -linet"
-fi
-
-    if test "${ac_cv_header_net_errno_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for net/errno.h" >&5
-echo $ECHO_N "checking for net/errno.h... $ECHO_C" >&6
-if test "${ac_cv_header_net_errno_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_net_errno_h" >&5
-echo "${ECHO_T}$ac_cv_header_net_errno_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking net/errno.h usability" >&5
-echo $ECHO_N "checking net/errno.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <net/errno.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+$as_echo "$ac_ct_RANLIB" >&6; }
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
 
-# Is the header present?
-echo "$as_me:$LINENO: checking net/errno.h presence" >&5
-echo $ECHO_N "checking net/errno.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <net/errno.h>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  if test "x$ac_ct_RANLIB" = x; then
+    RANLIB=":"
   else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: net/errno.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: net/errno.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: net/errno.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: net/errno.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: net/errno.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: net/errno.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: net/errno.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: net/errno.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: net/errno.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: net/errno.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: net/errno.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: net/errno.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: net/errno.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: net/errno.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: net/errno.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: net/errno.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
 esac
-echo "$as_me:$LINENO: checking for net/errno.h" >&5
-echo $ECHO_N "checking for net/errno.h... $ECHO_C" >&6
-if test "${ac_cv_header_net_errno_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    RANLIB=$ac_ct_RANLIB
+  fi
 else
-  ac_cv_header_net_errno_h=$ac_header_preproc
+  RANLIB="$ac_cv_prog_RANLIB"
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_net_errno_h" >&5
-echo "${ECHO_T}$ac_cv_header_net_errno_h" >&6
 
-fi
-if test $ac_cv_header_net_errno_h = yes; then
 
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_NET_ERRNO_H 1
-_ACEOF
+    # Step 0.a: Enable 64 bit support?
 
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if 64bit support is requested" >&5
+$as_echo_n "checking if 64bit support is requested... " >&6; }
+    # Check whether --enable-64bit was given.
+if test "${enable_64bit+set}" = set; then :
+  enableval=$enable_64bit; do64bit=$enableval
+else
+  do64bit=no
 fi
 
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $do64bit" >&5
+$as_echo "$do64bit" >&6; }
 
+    # Step 0.b: Enable Solaris 64 bit VIS support?
 
-    #--------------------------------------------------------------------
-    #	Check for the existence of the -lsocket and -lnsl libraries.
-    #	The order here is important, so that they end up in the right
-    #	order in the command line generated by make.  Here are some
-    #	special considerations:
-    #	1. Use "connect" and "accept" to check for -lsocket, and
-    #	   "gethostbyname" to check for -lnsl.
-    #	2. Use each function name only once:  can't redo a check because
-    #	   autoconf caches the results of the last check and won't redo it.
-    #	3. Use -lnsl and -lsocket only if they supply procedures that
-    #	   aren't already present in the normal libraries.  This is because
-    #	   IRIX 5.2 has libraries, but they aren't needed and they're
-    #	   bogus:  they goof up name resolution if used.
-    #	4. On some SVR4 systems, can't use -lsocket without -lnsl too.
-    #	   To get around this problem, check for both libraries together
-    #	   if -lsocket doesn't work by itself.
-    #--------------------------------------------------------------------
-
-    tcl_checkBoth=0
-    echo "$as_me:$LINENO: checking for connect" >&5
-echo $ECHO_N "checking for connect... $ECHO_C" >&6
-if test "${ac_cv_func_connect+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if 64bit Sparc VIS support is requested" >&5
+$as_echo_n "checking if 64bit Sparc VIS support is requested... " >&6; }
+    # Check whether --enable-64bit-vis was given.
+if test "${enable_64bit_vis+set}" = set; then :
+  enableval=$enable_64bit_vis; do64bitVIS=$enableval
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define connect to an innocuous variant, in case <limits.h> declares connect.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define connect innocuous_connect
+  do64bitVIS=no
+fi
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char connect (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $do64bitVIS" >&5
+$as_echo "$do64bitVIS" >&6; }
+    # Force 64bit on with VIS
+    if test "$do64bitVIS" = "yes"; then :
+  do64bit=yes
+fi
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+    # Step 0.c: Check if visibility support is available. Do this here so
+    # that platform specific alternatives can be used below if this fails.
 
-#undef connect
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler supports visibility \"hidden\"" >&5
+$as_echo_n "checking if compiler supports visibility \"hidden\"... " >&6; }
+if ${tcl_cv_cc_visibility_hidden+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char connect ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_connect) || defined (__stub___connect)
-choke me
-#else
-char (*f) () = connect;
-#endif
-#ifdef __cplusplus
-}
-#endif
+	hold_cflags=$CFLAGS; CFLAGS="$CFLAGS -Werror"
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
+	    extern __attribute__((__visibility__("hidden"))) void f(void);
+	    void f(void) {}
 int
 main ()
 {
-return f != connect;
+f();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_connect=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  tcl_cv_cc_visibility_hidden=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_connect=no
+  tcl_cv_cc_visibility_hidden=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+	CFLAGS=$hold_cflags
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_connect" >&5
-echo "${ECHO_T}$ac_cv_func_connect" >&6
-if test $ac_cv_func_connect = yes; then
-  tcl_checkSocket=0
-else
-  tcl_checkSocket=1
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cc_visibility_hidden" >&5
+$as_echo "$tcl_cv_cc_visibility_hidden" >&6; }
+    if test $tcl_cv_cc_visibility_hidden = yes; then :
+
+
+$as_echo "#define MODULE_SCOPE extern __attribute__((__visibility__(\"hidden\")))" >>confdefs.h
+
+
 fi
 
-    if test "$tcl_checkSocket" = 1; then
-	echo "$as_me:$LINENO: checking for setsockopt" >&5
-echo $ECHO_N "checking for setsockopt... $ECHO_C" >&6
-if test "${ac_cv_func_setsockopt+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define setsockopt to an innocuous variant, in case <limits.h> declares setsockopt.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define setsockopt innocuous_setsockopt
+    # Step 0.d: Disable -rpath support?
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char setsockopt (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if rpath support is requested" >&5
+$as_echo_n "checking if rpath support is requested... " >&6; }
+    # Check whether --enable-rpath was given.
+if test "${enable_rpath+set}" = set; then :
+  enableval=$enable_rpath; doRpath=$enableval
+else
+  doRpath=yes
+fi
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $doRpath" >&5
+$as_echo "$doRpath" >&6; }
 
-#undef setsockopt
+    # Step 1: set the variable "system" to hold the name and version number
+    # for the system.
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char setsockopt ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_setsockopt) || defined (__stub___setsockopt)
-choke me
-#else
-char (*f) () = setsockopt;
-#endif
-#ifdef __cplusplus
-}
-#endif
 
-int
-main ()
-{
-return f != setsockopt;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_setsockopt=yes
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking system version" >&5
+$as_echo_n "checking system version... " >&6; }
+if ${tcl_cv_sys_version+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-ac_cv_func_setsockopt=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+	if test -f /usr/lib/NextStep/software_version; then
+	    tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
+	else
+	    tcl_cv_sys_version=`uname -s`-`uname -r`
+	    if test "$?" -ne 0 ; then
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: can't find uname command" >&5
+$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
+	    fi
+	fi
+
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_setsockopt" >&5
-echo "${ECHO_T}$ac_cv_func_setsockopt" >&6
-if test $ac_cv_func_setsockopt = yes; then
-  :
-else
-  echo "$as_me:$LINENO: checking for setsockopt in -lsocket" >&5
-echo $ECHO_N "checking for setsockopt in -lsocket... $ECHO_C" >&6
-if test "${ac_cv_lib_socket_setsockopt+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_sys_version" >&5
+$as_echo "$tcl_cv_sys_version" >&6; }
+    system=$tcl_cv_sys_version
+
+
+    # Step 2: check for existence of -ldl library.  This is needed because
+    # Linux can use either -ldl or -ldld for dynamic loading.
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
-LIBS="-lsocket  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char setsockopt ();
+char dlopen ();
 int
 main ()
 {
-setsockopt ();
+return dlopen ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_socket_setsockopt=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dl_dlopen=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_socket_setsockopt=no
+  ac_cv_lib_dl_dlopen=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_socket_setsockopt" >&5
-echo "${ECHO_T}$ac_cv_lib_socket_setsockopt" >&6
-if test $ac_cv_lib_socket_setsockopt = yes; then
-  LIBS="$LIBS -lsocket"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+  have_dl=yes
 else
-  tcl_checkBoth=1
-fi
-
+  have_dl=no
 fi
 
-    fi
-    if test "$tcl_checkBoth" = 1; then
-	tk_oldLibs=$LIBS
-	LIBS="$LIBS -lsocket -lnsl"
-	echo "$as_me:$LINENO: checking for accept" >&5
-echo $ECHO_N "checking for accept... $ECHO_C" >&6
-if test "${ac_cv_func_accept+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define accept to an innocuous variant, in case <limits.h> declares accept.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define accept innocuous_accept
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char accept (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef accept
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char accept ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_accept) || defined (__stub___accept)
-choke me
-#else
-char (*f) () = accept;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != accept;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_accept=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_accept=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_accept" >&5
-echo "${ECHO_T}$ac_cv_func_accept" >&6
-if test $ac_cv_func_accept = yes; then
-  tcl_checkNsl=0
-else
-  LIBS=$tk_oldLibs
+    # Require ranlib early so we can override it in special cases below.
+    if test x"${SHLIB_VERSION}" = x; then :
+  SHLIB_VERSION="1.0"
 fi
 
-    fi
-    echo "$as_me:$LINENO: checking for gethostbyname" >&5
-echo $ECHO_N "checking for gethostbyname... $ECHO_C" >&6
-if test "${ac_cv_func_gethostbyname+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define gethostbyname to an innocuous variant, in case <limits.h> declares gethostbyname.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define gethostbyname innocuous_gethostbyname
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char gethostbyname (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
 
-#undef gethostbyname
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char gethostbyname ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_gethostbyname) || defined (__stub___gethostbyname)
-choke me
-#else
-char (*f) () = gethostbyname;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    # Step 3: set configuration options based on system name and version.
 
-int
-main ()
-{
-return f != gethostbyname;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_gethostbyname=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+    do64bit_ok=no
+    # default to '{$LIBS}' and set to "" on per-platform necessary basis
+    SHLIB_LD_LIBS='${LIBS}'
+    LDFLAGS_ORIG="$LDFLAGS"
+    # When ld needs options to work in 64-bit mode, put them in
+    # LDFLAGS_ARCH so they eventually end up in LDFLAGS even if [load]
+    # is disabled by the user. [Bug 1016796]
+    LDFLAGS_ARCH=""
+    UNSHARED_LIB_SUFFIX=""
+    TCL_TRIM_DOTS='`echo ${VERSION} | tr -d .`'
+    ECHO_VERSION='`echo ${VERSION}`'
+    TCL_LIB_VERSIONS_OK=ok
+    CFLAGS_DEBUG=-g
+    CFLAGS_OPTIMIZE=-O
+    if test "$GCC" = yes; then :
 
-ac_cv_func_gethostbyname=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_gethostbyname" >&5
-echo "${ECHO_T}$ac_cv_func_gethostbyname" >&6
-if test $ac_cv_func_gethostbyname = yes; then
-  :
-else
-  echo "$as_me:$LINENO: checking for gethostbyname in -lnsl" >&5
-echo $ECHO_N "checking for gethostbyname in -lnsl... $ECHO_C" >&6
-if test "${ac_cv_lib_nsl_gethostbyname+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lnsl  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
+	CFLAGS_WARNING="-Wall"
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char gethostbyname ();
-int
-main ()
-{
-gethostbyname ();
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_nsl_gethostbyname=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_nsl_gethostbyname=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_nsl_gethostbyname" >&5
-echo "${ECHO_T}$ac_cv_lib_nsl_gethostbyname" >&6
-if test $ac_cv_lib_nsl_gethostbyname = yes; then
-  LIBS="$LIBS -lnsl"
-fi
-
+  CFLAGS_WARNING=""
 fi
-
-
-
-# Add the threads support libraries
-LIBS="$LIBS$THREADS_LIBS"
-
-
-    echo "$as_me:$LINENO: checking how to build libraries" >&5
-echo $ECHO_N "checking how to build libraries... $ECHO_C" >&6
-    # Check whether --enable-shared or --disable-shared was given.
-if test "${enable_shared+set}" = set; then
-  enableval="$enable_shared"
-  tcl_ok=$enableval
-else
-  tcl_ok=yes
-fi;
-
-    if test "${enable_shared+set}" = set; then
-	enableval="$enable_shared"
-	tcl_ok=$enableval
-    else
-	tcl_ok=yes
-    fi
-
-    if test "$tcl_ok" = "yes" ; then
-	echo "$as_me:$LINENO: result: shared" >&5
-echo "${ECHO_T}shared" >&6
-	SHARED_BUILD=1
-    else
-	echo "$as_me:$LINENO: result: static" >&5
-echo "${ECHO_T}static" >&6
-	SHARED_BUILD=0
-
-cat >>confdefs.h <<\_ACEOF
-#define STATIC_BUILD 1
-_ACEOF
-
-    fi
-
-
-#--------------------------------------------------------------------
-# The statements below define a collection of compile flags.  This
-# macro depends on the value of SHARED_BUILD, and should be called
-# after SC_ENABLE_SHARED checks the configure switches.
-#--------------------------------------------------------------------
-
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
-set dummy ${ac_tool_prefix}ranlib; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_RANLIB+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ar; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AR+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  if test -n "$RANLIB"; then
-  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+  if test -n "$AR"; then
+  ac_cv_prog_AR="$AR" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AR="${ac_tool_prefix}ar"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
 fi
 fi
-RANLIB=$ac_cv_prog_RANLIB
-if test -n "$RANLIB"; then
-  echo "$as_me:$LINENO: result: $RANLIB" >&5
-echo "${ECHO_T}$RANLIB" >&6
+AR=$ac_cv_prog_AR
+if test -n "$AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+$as_echo "$AR" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
+
 fi
-if test -z "$ac_cv_prog_RANLIB"; then
-  ac_ct_RANLIB=$RANLIB
-  # Extract the first word of "ranlib", so it can be a program name with args.
-set dummy ranlib; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+if test -z "$ac_cv_prog_AR"; then
+  ac_ct_AR=$AR
+  # Extract the first word of "ar", so it can be a program name with args.
+set dummy ar; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_AR+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  if test -n "$ac_ct_RANLIB"; then
-  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+  if test -n "$ac_ct_AR"; then
+  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_RANLIB="ranlib"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AR="ar"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
-  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
 fi
 fi
-ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
-if test -n "$ac_ct_RANLIB"; then
-  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
-echo "${ECHO_T}$ac_ct_RANLIB" >&6
+ac_ct_AR=$ac_cv_prog_ac_ct_AR
+if test -n "$ac_ct_AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+$as_echo "$ac_ct_AR" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
-  RANLIB=$ac_ct_RANLIB
+  if test "x$ac_ct_AR" = x; then
+    AR=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AR=$ac_ct_AR
+  fi
 else
-  RANLIB="$ac_cv_prog_RANLIB"
+  AR="$ac_cv_prog_AR"
 fi
 
+    STLIB_LD='${AR} cr'
+    LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH"
+    PLAT_OBJS=""
+    PLAT_SRCS=""
+    LDAIX_SRC=""
+    case $system in
+	AIX-*)
+	    if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes"; then :
 
-
-    # Step 0.a: Enable 64 bit support?
-
-    echo "$as_me:$LINENO: checking if 64bit support is requested" >&5
-echo $ECHO_N "checking if 64bit support is requested... $ECHO_C" >&6
-    # Check whether --enable-64bit or --disable-64bit was given.
-if test "${enable_64bit+set}" = set; then
-  enableval="$enable_64bit"
-  do64bit=$enableval
-else
-  do64bit=no
-fi;
-    echo "$as_me:$LINENO: result: $do64bit" >&5
-echo "${ECHO_T}$do64bit" >&6
-
-    # Step 0.b: Enable Solaris 64 bit VIS support?
-
-    echo "$as_me:$LINENO: checking if 64bit Sparc VIS support is requested" >&5
-echo $ECHO_N "checking if 64bit Sparc VIS support is requested... $ECHO_C" >&6
-    # Check whether --enable-64bit-vis or --disable-64bit-vis was given.
-if test "${enable_64bit_vis+set}" = set; then
-  enableval="$enable_64bit_vis"
-  do64bitVIS=$enableval
-else
-  do64bitVIS=no
-fi;
-    echo "$as_me:$LINENO: result: $do64bitVIS" >&5
-echo "${ECHO_T}$do64bitVIS" >&6
-    # Force 64bit on with VIS
-    if test "$do64bitVIS" = "yes"; then
-  do64bit=yes
-fi
-
-
-    # Step 0.c: Check if visibility support is available. Do this here so
-    # that platform specific alternatives can be used below if this fails.
-
-    echo "$as_me:$LINENO: checking if compiler supports visibility \"hidden\"" >&5
-echo $ECHO_N "checking if compiler supports visibility \"hidden\"... $ECHO_C" >&6
-if test "${tcl_cv_cc_visibility_hidden+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	hold_cflags=$CFLAGS; CFLAGS="$CFLAGS -Werror"
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-	    extern __attribute__((__visibility__("hidden"))) void f(void);
-	    void f(void) {}
-int
-main ()
-{
-f();
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_cc_visibility_hidden=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cc_visibility_hidden=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-	CFLAGS=$hold_cflags
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_cc_visibility_hidden" >&5
-echo "${ECHO_T}$tcl_cv_cc_visibility_hidden" >&6
-    if test $tcl_cv_cc_visibility_hidden = yes; then
-
-
-cat >>confdefs.h <<\_ACEOF
-#define MODULE_SCOPE extern __attribute__((__visibility__("hidden")))
-_ACEOF
-
-
-fi
-
-
-    # Step 0.d: Disable -rpath support?
-
-    echo "$as_me:$LINENO: checking if rpath support is requested" >&5
-echo $ECHO_N "checking if rpath support is requested... $ECHO_C" >&6
-    # Check whether --enable-rpath or --disable-rpath was given.
-if test "${enable_rpath+set}" = set; then
-  enableval="$enable_rpath"
-  doRpath=$enableval
-else
-  doRpath=yes
-fi;
-    echo "$as_me:$LINENO: result: $doRpath" >&5
-echo "${ECHO_T}$doRpath" >&6
-
-    # Step 1: set the variable "system" to hold the name and version number
-    # for the system.
-
-
-    echo "$as_me:$LINENO: checking system version" >&5
-echo $ECHO_N "checking system version... $ECHO_C" >&6
-if test "${tcl_cv_sys_version+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	if test -f /usr/lib/NextStep/software_version; then
-	    tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
-	else
-	    tcl_cv_sys_version=`uname -s`-`uname -r`
-	    if test "$?" -ne 0 ; then
-		{ echo "$as_me:$LINENO: WARNING: can't find uname command" >&5
-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
-	    fi
-	fi
-
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_sys_version" >&5
-echo "${ECHO_T}$tcl_cv_sys_version" >&6
-    system=$tcl_cv_sys_version
-
-
-    # Step 2: check for existence of -ldl library.  This is needed because
-    # Linux can use either -ldl or -ldld for dynamic loading.
-
-    echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
-echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6
-if test "${ac_cv_lib_dl_dlopen+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-ldl  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char dlopen ();
-int
-main ()
-{
-dlopen ();
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_dl_dlopen=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_dl_dlopen=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
-echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
-if test $ac_cv_lib_dl_dlopen = yes; then
-  have_dl=yes
-else
-  have_dl=no
-fi
-
-
-    # Require ranlib early so we can override it in special cases below.
-    if test x"${SHLIB_VERSION}" = x; then
-  SHLIB_VERSION="1.0"
-fi
-
-
-
-
-    # Step 3: set configuration options based on system name and version.
-
-    do64bit_ok=no
-    # default to '{$LIBS}' and set to "" on per-platform necessary basis
-    SHLIB_LD_LIBS='${LIBS}'
-    LDFLAGS_ORIG="$LDFLAGS"
-    # When ld needs options to work in 64-bit mode, put them in
-    # LDFLAGS_ARCH so they eventually end up in LDFLAGS even if [load]
-    # is disabled by the user. [Bug 1016796]
-    LDFLAGS_ARCH=""
-    UNSHARED_LIB_SUFFIX=""
-    TCL_TRIM_DOTS='`echo ${VERSION} | tr -d .`'
-    ECHO_VERSION='`echo ${VERSION}`'
-    TCL_LIB_VERSIONS_OK=ok
-    CFLAGS_DEBUG=-g
-    CFLAGS_OPTIMIZE=-O
-    if test "$GCC" = yes; then
-
-	CFLAGS_WARNING="-Wall"
-
-else
-  CFLAGS_WARNING=""
-fi
-
-    if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
-set dummy ${ac_tool_prefix}ar; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_AR+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  if test -n "$AR"; then
-  ac_cv_prog_AR="$AR" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_AR="${ac_tool_prefix}ar"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-done
-
-fi
-fi
-AR=$ac_cv_prog_AR
-if test -n "$AR"; then
-  echo "$as_me:$LINENO: result: $AR" >&5
-echo "${ECHO_T}$AR" >&6
-else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
-fi
-
-fi
-if test -z "$ac_cv_prog_AR"; then
-  ac_ct_AR=$AR
-  # Extract the first word of "ar", so it can be a program name with args.
-set dummy ar; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  if test -n "$ac_ct_AR"; then
-  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_AR="ar"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-done
-
-fi
-fi
-ac_ct_AR=$ac_cv_prog_ac_ct_AR
-if test -n "$ac_ct_AR"; then
-  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
-echo "${ECHO_T}$ac_ct_AR" >&6
-else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
-fi
-
-  AR=$ac_ct_AR
-else
-  AR="$ac_cv_prog_AR"
-fi
-
-    STLIB_LD='${AR} cr'
-    LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH"
-    PLAT_OBJS=""
-    PLAT_SRCS=""
-    LDAIX_SRC=""
-    case $system in
-	AIX-*)
-	    if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes"; then
-
-		# AIX requires the _r compiler when gcc isn't being used
-		case "${CC}" in
-		    *_r|*_r\ *)
-			# ok ...
-			;;
-		    *)
-			# Make sure only first arg gets _r
-		    	CC=`echo "$CC" | sed -e 's/^\([^ ]*\)/\1_r/'`
-			;;
-		esac
-		echo "$as_me:$LINENO: result: Using $CC for compiling with threads" >&5
-echo "${ECHO_T}Using $CC for compiling with threads" >&6
+		# AIX requires the _r compiler when gcc isn't being used
+		case "${CC}" in
+		    *_r|*_r\ *)
+			# ok ...
+			;;
+		    *)
+			# Make sure only first arg gets _r
+		    	CC=`echo "$CC" | sed -e 's/^\([^ ]*\)/\1_r/'`
+			;;
+		esac
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Using $CC for compiling with threads" >&5
+$as_echo "Using $CC for compiling with threads" >&6; }
 
 fi
-
 	    LIBS="$LIBS -lc"
 	    SHLIB_CFLAGS=""
 	    SHLIB_SUFFIX=".so"
@@ -6767,12 +5053,12 @@ fi
 	    LDAIX_SRC='$(UNIX_DIR)/ldAix'
 
 	    # Check to enable 64-bit flags for compiler/linker
-	    if test "$do64bit" = yes; then
+	    if test "$do64bit" = yes; then :
 
-		if test "$GCC" = yes; then
+		if test "$GCC" = yes; then :
 
-		    { echo "$as_me:$LINENO: WARNING: 64bit mode not supported with GCC on $system" >&5
-echo "$as_me: WARNING: 64bit mode not supported with GCC on $system" >&2;}
+		    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit mode not supported with GCC on $system" >&5
+$as_echo "$as_me: WARNING: 64bit mode not supported with GCC on $system" >&2;}
 
 else
 
@@ -6785,17 +5071,15 @@ else
 
 fi
 
-
 fi
 
-
-	    if test "`uname -m`" = ia64; then
+	    if test "`uname -m`" = ia64; then :
 
 		# AIX-5 uses ELF style dynamic libraries on IA-64, but not PPC
 		SHLIB_LD="/usr/ccs/bin/ld -G -z text"
 		# AIX-5 has dl* in libc.so
 		DL_LIBS=""
-		if test "$GCC" = yes; then
+		if test "$GCC" = yes; then :
 
 		    CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
 
@@ -6804,12 +5088,11 @@ else
 		    CC_SEARCH_FLAGS='-R${LIB_RUNTIME_DIR}'
 
 fi
-
 		LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
 
 else
 
-		if test "$GCC" = yes; then
+		if test "$GCC" = yes; then :
 
 		    SHLIB_LD='${CC} -shared -Wl,-bexpall'
 
@@ -6819,14 +5102,12 @@ else
 		    LDFLAGS="$LDFLAGS -brtl"
 
 fi
-
 		SHLIB_LD="${SHLIB_LD} ${SHLIB_LD_FLAGS}"
 		DL_LIBS="-ldl"
 		CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
 
 fi
-
 	    ;;
 	BeOS*)
 	    SHLIB_CFLAGS="-fPIC"
@@ -6840,71 +5121,43 @@ fi
 	    # -lsocket, even if the network functions are in -lnet which
 	    # is always linked to, for compatibility.
 	    #-----------------------------------------------------------
-	    echo "$as_me:$LINENO: checking for inet_ntoa in -lbind" >&5
-echo $ECHO_N "checking for inet_ntoa in -lbind... $ECHO_C" >&6
-if test "${ac_cv_lib_bind_inet_ntoa+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inet_ntoa in -lbind" >&5
+$as_echo_n "checking for inet_ntoa in -lbind... " >&6; }
+if ${ac_cv_lib_bind_inet_ntoa+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
 LIBS="-lbind  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
 char inet_ntoa ();
 int
 main ()
 {
-inet_ntoa ();
+return inet_ntoa ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   ac_cv_lib_bind_inet_ntoa=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_bind_inet_ntoa=no
+  ac_cv_lib_bind_inet_ntoa=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_bind_inet_ntoa" >&5
-echo "${ECHO_T}$ac_cv_lib_bind_inet_ntoa" >&6
-if test $ac_cv_lib_bind_inet_ntoa = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bind_inet_ntoa" >&5
+$as_echo "$ac_cv_lib_bind_inet_ntoa" >&6; }
+if test "x$ac_cv_lib_bind_inet_ntoa" = xyes; then :
   LIBS="$LIBS -lbind -lsocket"
 fi
 
@@ -6939,16 +5192,12 @@ fi
 	    TCL_NEEDS_EXP_FILE=1
 	    TCL_EXPORT_FILE_SUFFIX='${VERSION}\$\{DBGX\}.dll.a'
 	    SHLIB_LD_LIBS="${SHLIB_LD_LIBS} -Wl,--out-implib,\$@.a"
-	    echo "$as_me:$LINENO: checking for Cygwin version of gcc" >&5
-echo $ECHO_N "checking for Cygwin version of gcc... $ECHO_C" >&6
-if test "${ac_cv_cygwin+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Cygwin version of gcc" >&5
+$as_echo_n "checking for Cygwin version of gcc... " >&6; }
+if ${ac_cv_cygwin+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 		#ifdef __CYGWIN__
@@ -6963,49 +5212,21 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   ac_cv_cygwin=no
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_cygwin=yes
+  ac_cv_cygwin=yes
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
 fi
-echo "$as_me:$LINENO: result: $ac_cv_cygwin" >&5
-echo "${ECHO_T}$ac_cv_cygwin" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cygwin" >&5
+$as_echo "$ac_cv_cygwin" >&6; }
 	    if test "$ac_cv_cygwin" = "no"; then
-		{ { echo "$as_me:$LINENO: error: ${CC} is not a cygwin compiler." >&5
-echo "$as_me: error: ${CC} is not a cygwin compiler." >&2;}
-   { (exit 1); exit 1; }; }
+		as_fn_error $? "${CC} is not a cygwin compiler." "$LINENO" 5
 	    fi
 	    if test "x${TCL_THREADS}" = "x0"; then
-		{ { echo "$as_me:$LINENO: error: CYGWIN compile is only supported with --enable-threads" >&5
-echo "$as_me: error: CYGWIN compile is only supported with --enable-threads" >&2;}
-   { (exit 1); exit 1; }; }
+		as_fn_error $? "CYGWIN compile is only supported with --enable-threads" "$LINENO" 5
 	    fi
 	    do64bit_ok=yes
 	    if test "x${SHARED_BUILD}" = "x1"; then
@@ -7035,71 +5256,43 @@ echo "$as_me: error: CYGWIN compile is only supported with --enable-threads" >&2
 	    SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}'
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS="-lroot"
-	    echo "$as_me:$LINENO: checking for inet_ntoa in -lnetwork" >&5
-echo $ECHO_N "checking for inet_ntoa in -lnetwork... $ECHO_C" >&6
-if test "${ac_cv_lib_network_inet_ntoa+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inet_ntoa in -lnetwork" >&5
+$as_echo_n "checking for inet_ntoa in -lnetwork... " >&6; }
+if ${ac_cv_lib_network_inet_ntoa+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
 LIBS="-lnetwork  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
 char inet_ntoa ();
 int
 main ()
 {
-inet_ntoa ();
+return inet_ntoa ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   ac_cv_lib_network_inet_ntoa=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_network_inet_ntoa=no
+  ac_cv_lib_network_inet_ntoa=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_network_inet_ntoa" >&5
-echo "${ECHO_T}$ac_cv_lib_network_inet_ntoa" >&6
-if test $ac_cv_lib_network_inet_ntoa = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_network_inet_ntoa" >&5
+$as_echo "$ac_cv_lib_network_inet_ntoa" >&6; }
+if test "x$ac_cv_lib_network_inet_ntoa" = xyes; then :
   LIBS="$LIBS -lnetwork"
 fi
 
@@ -7107,18 +5300,14 @@ fi
 	HP-UX-*.11.*)
 	    # Use updated header definitions where possible
 
-cat >>confdefs.h <<\_ACEOF
-#define _XOPEN_SOURCE_EXTENDED 1
-_ACEOF
+$as_echo "#define _XOPEN_SOURCE_EXTENDED 1" >>confdefs.h
 
 
-cat >>confdefs.h <<\_ACEOF
-#define _XOPEN_SOURCE 1
-_ACEOF
+$as_echo "#define _XOPEN_SOURCE 1" >>confdefs.h
 
 	    LIBS="$LIBS -lxnet"               # Use the XOPEN network library
 
-	    if test "`uname -m`" = ia64; then
+	    if test "`uname -m`" = ia64; then :
 
 		SHLIB_SUFFIX=".so"
 
@@ -7127,78 +5316,49 @@ else
 		SHLIB_SUFFIX=".sl"
 
 fi
-
-	    echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5
-echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6
-if test "${ac_cv_lib_dld_shl_load+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+$as_echo_n "checking for shl_load in -ldld... " >&6; }
+if ${ac_cv_lib_dld_shl_load+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
 LIBS="-ldld  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
 char shl_load ();
 int
 main ()
 {
-shl_load ();
+return shl_load ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   ac_cv_lib_dld_shl_load=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_dld_shl_load=no
+  ac_cv_lib_dld_shl_load=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5
-echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6
-if test $ac_cv_lib_dld_shl_load = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
+if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
 fi
 
-	    if test "$tcl_ok" = yes; then
+	    if test "$tcl_ok" = yes; then :
 
 		SHLIB_CFLAGS="+z"
 		SHLIB_LD="ld -b"
@@ -7210,38 +5370,35 @@ fi
 		LD_LIBRARY_PATH_VAR="SHLIB_PATH"
 
 fi
-
-	    if test "$GCC" = yes; then
+	    if test "$GCC" = yes; then :
 
 		SHLIB_LD='${CC} -shared'
 		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
 
 fi
 
-
 	    # Users may want PA-RISC 1.1/2.0 portable code - needs HP cc
 	    #CFLAGS="$CFLAGS +DAportable"
 
 	    # Check to enable 64-bit flags for compiler/linker
-	    if test "$do64bit" = "yes"; then
+	    if test "$do64bit" = "yes"; then :
 
-		if test "$GCC" = yes; then
+		if test "$GCC" = yes; then :
 
 		    case `${CC} -dumpmachine` in
 			hppa64*)
 			    # 64-bit gcc in use.  Fix flags for GNU ld.
 			    do64bit_ok=yes
 			    SHLIB_LD='${CC} -shared'
-			    if test $doRpath = yes; then
+			    if test $doRpath = yes; then :
 
 				CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 fi
-
 			    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
 			    ;;
 			*)
-			    { echo "$as_me:$LINENO: WARNING: 64bit mode not supported with GCC on $system" >&5
-echo "$as_me: WARNING: 64bit mode not supported with GCC on $system" >&2;}
+			    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit mode not supported with GCC on $system" >&5
+$as_echo "$as_me: WARNING: 64bit mode not supported with GCC on $system" >&2;}
 			    ;;
 		    esac
 
@@ -7253,82 +5410,52 @@ else
 
 fi
 
-
-fi
- ;;
+fi ;;
 	HP-UX-*.08.*|HP-UX-*.09.*|HP-UX-*.10.*)
 	    SHLIB_SUFFIX=".sl"
-	    echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5
-echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6
-if test "${ac_cv_lib_dld_shl_load+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+$as_echo_n "checking for shl_load in -ldld... " >&6; }
+if ${ac_cv_lib_dld_shl_load+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
 LIBS="-ldld  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
 #ifdef __cplusplus
 extern "C"
 #endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
 char shl_load ();
 int
 main ()
 {
-shl_load ();
+return shl_load ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   ac_cv_lib_dld_shl_load=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_dld_shl_load=no
+  ac_cv_lib_dld_shl_load=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5
-echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6
-if test $ac_cv_lib_dld_shl_load = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
+if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
 fi
 
-	    if test "$tcl_ok" = yes; then
+	    if test "$tcl_ok" = yes; then :
 
 		SHLIB_CFLAGS="+z"
 		SHLIB_LD="ld -b"
@@ -7340,20 +5467,18 @@ fi
 		LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.'
 		LD_LIBRARY_PATH_VAR="SHLIB_PATH"
 
-fi
- ;;
+fi ;;
 	IRIX-5.*)
 	    SHLIB_CFLAGS=""
 	    SHLIB_LD="ld -shared -rdata_shared"
 	    SHLIB_SUFFIX=".so"
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS=""
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
 fi
-
 	    ;;
 	IRIX-6.*)
 	    SHLIB_CFLAGS=""
@@ -7361,13 +5486,12 @@ fi
 	    SHLIB_SUFFIX=".so"
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS=""
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
 fi
-
-	    if test "$GCC" = yes; then
+	    if test "$GCC" = yes; then :
 
 		CFLAGS="$CFLAGS -mabi=n32"
 		LDFLAGS="$LDFLAGS -mabi=n32"
@@ -7386,7 +5510,6 @@ else
 		LDFLAGS="$LDFLAGS -n32"
 
 fi
-
 	    ;;
 	IRIX64-6.*)
 	    SHLIB_CFLAGS=""
@@ -7394,21 +5517,20 @@ fi
 	    SHLIB_SUFFIX=".so"
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS=""
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
 fi
 
-
 	    # Check to enable 64-bit flags for compiler/linker
 
-	    if test "$do64bit" = yes; then
+	    if test "$do64bit" = yes; then :
 
-	        if test "$GCC" = yes; then
+	        if test "$GCC" = yes; then :
 
-	            { echo "$as_me:$LINENO: WARNING: 64bit mode not supported by gcc" >&5
-echo "$as_me: WARNING: 64bit mode not supported by gcc" >&2;}
+	            { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit mode not supported by gcc" >&5
+$as_echo "$as_me: WARNING: 64bit mode not supported by gcc" >&2;}
 
 else
 
@@ -7419,9 +5541,7 @@ else
 
 fi
 
-
 fi
-
 	    ;;
 	Linux*|GNU*|NetBSD-Debian)
 	    SHLIB_CFLAGS="-fPIC"
@@ -7437,31 +5557,25 @@ fi
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS="-ldl"
 	    LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 fi
-
 	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-	    if test "`uname -m`" = "alpha"; then
+	    if test "`uname -m`" = "alpha"; then :
   CFLAGS="$CFLAGS -mieee"
 fi
+	    if test $do64bit = yes; then :
 
-	    if test $do64bit = yes; then
-
-		echo "$as_me:$LINENO: checking if compiler accepts -m64 flag" >&5
-echo $ECHO_N "checking if compiler accepts -m64 flag... $ECHO_C" >&6
-if test "${tcl_cv_cc_m64+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler accepts -m64 flag" >&5
+$as_echo_n "checking if compiler accepts -m64 flag... " >&6; }
+if ${tcl_cv_cc_m64+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 		    hold_cflags=$CFLAGS
 		    CFLAGS="$CFLAGS -m64"
-		    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+		    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -7472,62 +5586,35 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_cc_m64=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cc_m64=no
+  tcl_cv_cc_m64=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 		    CFLAGS=$hold_cflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_cc_m64" >&5
-echo "${ECHO_T}$tcl_cv_cc_m64" >&6
-		if test $tcl_cv_cc_m64 = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cc_m64" >&5
+$as_echo "$tcl_cv_cc_m64" >&6; }
+		if test $tcl_cv_cc_m64 = yes; then :
 
 		    CFLAGS="$CFLAGS -m64"
 		    do64bit_ok=yes
 
 fi
 
-
 fi
 
-
 	    # The combo of gcc + glibc has a bug related to inlining of
 	    # functions like strtod(). The -fno-builtin flag should address
 	    # this problem but it does not work. The -fno-inline flag is kind
 	    # of overkill but it works. Disable inlining only when one of the
 	    # files in compat/*.c is being linked in.
 
-	    if test x"${USE_COMPAT}" != x; then
+	    if test x"${USE_COMPAT}" != x; then :
   CFLAGS="$CFLAGS -fno-inline"
 fi
-
 	    ;;
 	Lynx*)
 	    SHLIB_CFLAGS="-fPIC"
@@ -7537,12 +5624,11 @@ fi
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS="-mshared -ldl"
 	    LD_FLAGS="-Wl,--export-dynamic"
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 fi
-
 	    ;;
 	MP-RAS-02*)
 	    SHLIB_CFLAGS="-K PIC"
@@ -7588,11 +5674,10 @@ fi
 		SHLIB_SUFFIX=".so"
 		DL_OBJS="tclLoadDl.o"
 		DL_LIBS=""
-		if test $doRpath = yes; then
+		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"
@@ -7609,7 +5694,7 @@ fi
 		CFLAGS_OPTIMIZE="-O2"
 		;;
 	    esac
-	    if test "${TCL_THREADS}" = "1"; then
+	    if test "${TCL_THREADS}" = "1"; then :
 
 		# On OpenBSD:	Compile with -pthread
 		#		Don't link with -lpthread
@@ -7617,7 +5702,6 @@ fi
 		CFLAGS="$CFLAGS -pthread"
 
 fi
-
 	    # OpenBSD doesn't do version numbers with dots.
 	    UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
 	    TCL_LIB_VERSIONS_OK=nodots
@@ -7630,13 +5714,12 @@ fi
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS=""
 	    LDFLAGS="$LDFLAGS -export-dynamic"
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 fi
-
 	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-	    if test "${TCL_THREADS}" = "1"; then
+	    if test "${TCL_THREADS}" = "1"; then :
 
 		# The -pthread needs to go in the CFLAGS, not LIBS
 		LIBS=`echo $LIBS | sed s/-pthread//`
@@ -7644,7 +5727,6 @@ fi
 	    	LDFLAGS="$LDFLAGS -pthread"
 
 fi
-
 	    ;;
 	FreeBSD-*)
 	    # This configuration from FreeBSD Ports.
@@ -7655,20 +5737,18 @@ fi
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS=""
 	    LDFLAGS=""
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 fi
-
-	    if test "${TCL_THREADS}" = "1"; then
+	    if test "${TCL_THREADS}" = "1"; then :
 
 		# The -pthread needs to go in the LDFLAGS, not LIBS
 		LIBS=`echo $LIBS | sed s/-pthread//`
 		CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
 		LDFLAGS="$LDFLAGS $PTHREAD_LIBS"
 fi
-
 	    case $system in
 	    FreeBSD-3.*)
 		# Version numbers are dot-stripped by system policy.
@@ -7691,23 +5771,19 @@ fi
 	    CFLAGS="`echo " ${CFLAGS}" | \
 		awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
 		if (!($i~/^(isysroot|mmacosx-version-min)/)) print "-"$i}'`"
-	    if test $do64bit = yes; then
+	    if test $do64bit = yes; then :
 
 		case `arch` in
 		    ppc)
-			echo "$as_me:$LINENO: checking if compiler accepts -arch ppc64 flag" >&5
-echo $ECHO_N "checking if compiler accepts -arch ppc64 flag... $ECHO_C" >&6
-if test "${tcl_cv_cc_arch_ppc64+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+			{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler accepts -arch ppc64 flag" >&5
+$as_echo_n "checking if compiler accepts -arch ppc64 flag... " >&6; }
+if ${tcl_cv_cc_arch_ppc64+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 			    hold_cflags=$CFLAGS
 			    CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
-			    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+			    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -7718,62 +5794,33 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_cc_arch_ppc64=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cc_arch_ppc64=no
+  tcl_cv_cc_arch_ppc64=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 			    CFLAGS=$hold_cflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_cc_arch_ppc64" >&5
-echo "${ECHO_T}$tcl_cv_cc_arch_ppc64" >&6
-			if test $tcl_cv_cc_arch_ppc64 = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cc_arch_ppc64" >&5
+$as_echo "$tcl_cv_cc_arch_ppc64" >&6; }
+			if test $tcl_cv_cc_arch_ppc64 = yes; then :
 
 			    CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
 			    do64bit_ok=yes
 
-fi
-;;
+fi;;
 		    i386)
-			echo "$as_me:$LINENO: checking if compiler accepts -arch x86_64 flag" >&5
-echo $ECHO_N "checking if compiler accepts -arch x86_64 flag... $ECHO_C" >&6
-if test "${tcl_cv_cc_arch_x86_64+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+			{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler accepts -arch x86_64 flag" >&5
+$as_echo_n "checking if compiler accepts -arch x86_64 flag... " >&6; }
+if ${tcl_cv_cc_arch_x86_64+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 			    hold_cflags=$CFLAGS
 			    CFLAGS="$CFLAGS -arch x86_64"
-			    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+			    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -7784,79 +5831,48 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_cc_arch_x86_64=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cc_arch_x86_64=no
+  tcl_cv_cc_arch_x86_64=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 			    CFLAGS=$hold_cflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_cc_arch_x86_64" >&5
-echo "${ECHO_T}$tcl_cv_cc_arch_x86_64" >&6
-			if test $tcl_cv_cc_arch_x86_64 = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cc_arch_x86_64" >&5
+$as_echo "$tcl_cv_cc_arch_x86_64" >&6; }
+			if test $tcl_cv_cc_arch_x86_64 = yes; then :
 
 			    CFLAGS="$CFLAGS -arch x86_64"
 			    do64bit_ok=yes
 
-fi
-;;
+fi;;
 		    *)
-			{ echo "$as_me:$LINENO: WARNING: Don't know how enable 64-bit on architecture \`arch\`" >&5
-echo "$as_me: WARNING: Don't know how enable 64-bit on architecture \`arch\`" >&2;};;
+			{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Don't know how enable 64-bit on architecture \`arch\`" >&5
+$as_echo "$as_me: WARNING: Don't know how enable 64-bit on architecture \`arch\`" >&2;};;
 		esac
 
 else
 
 		# Check for combined 32-bit and 64-bit fat build
 		if echo "$CFLAGS " |grep -E -q -- '-arch (ppc64|x86_64) ' \
-		    && echo "$CFLAGS " |grep -E -q -- '-arch (ppc|i386) '; then
+		    && echo "$CFLAGS " |grep -E -q -- '-arch (ppc|i386) '; then :
 
 		    fat_32_64=yes
 fi
 
-
 fi
-
 	    SHLIB_LD='${CC} -dynamiclib ${CFLAGS} ${LDFLAGS}'
-	    echo "$as_me:$LINENO: checking if ld accepts -single_module flag" >&5
-echo $ECHO_N "checking if ld accepts -single_module flag... $ECHO_C" >&6
-if test "${tcl_cv_ld_single_module+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ld accepts -single_module flag" >&5
+$as_echo_n "checking if ld accepts -single_module flag... " >&6; }
+if ${tcl_cv_ld_single_module+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 		hold_ldflags=$LDFLAGS
 		LDFLAGS="$LDFLAGS -dynamiclib -Wl,-single_module"
-		cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -7867,71 +5883,41 @@ int i;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_ld_single_module=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_ld_single_module=no
+  tcl_cv_ld_single_module=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 		LDFLAGS=$hold_ldflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_ld_single_module" >&5
-echo "${ECHO_T}$tcl_cv_ld_single_module" >&6
-	    if test $tcl_cv_ld_single_module = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_ld_single_module" >&5
+$as_echo "$tcl_cv_ld_single_module" >&6; }
+	    if test $tcl_cv_ld_single_module = yes; then :
 
 		SHLIB_LD="${SHLIB_LD} -Wl,-single_module"
 
 fi
-
 	    SHLIB_SUFFIX=".dylib"
 	    DL_OBJS="tclLoadDyld.o"
 	    DL_LIBS=""
 	    # Don't use -prebind when building for Mac OS X 10.4 or later only:
 	    if test "`echo "${MACOSX_DEPLOYMENT_TARGET}" | awk -F '10\\.' '{print int($2)}'`" -lt 4 -a \
-		"`echo "${CPPFLAGS}" | awk -F '-mmacosx-version-min=10\\.' '{print int($2)}'`" -lt 4; then
+		"`echo "${CPPFLAGS}" | awk -F '-mmacosx-version-min=10\\.' '{print int($2)}'`" -lt 4; then :
 
 		LDFLAGS="$LDFLAGS -prebind"
 fi
-
 	    LDFLAGS="$LDFLAGS -headerpad_max_install_names"
-	    echo "$as_me:$LINENO: checking if ld accepts -search_paths_first flag" >&5
-echo $ECHO_N "checking if ld accepts -search_paths_first flag... $ECHO_C" >&6
-if test "${tcl_cv_ld_search_paths_first+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ld accepts -search_paths_first flag" >&5
+$as_echo_n "checking if ld accepts -search_paths_first flag... " >&6; }
+if ${tcl_cv_ld_search_paths_first+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 		hold_ldflags=$LDFLAGS
 		LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
-		cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -7942,88 +5928,58 @@ int i;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_ld_search_paths_first=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_ld_search_paths_first=no
+  tcl_cv_ld_search_paths_first=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 		LDFLAGS=$hold_ldflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_ld_search_paths_first" >&5
-echo "${ECHO_T}$tcl_cv_ld_search_paths_first" >&6
-	    if test $tcl_cv_ld_search_paths_first = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_ld_search_paths_first" >&5
+$as_echo "$tcl_cv_ld_search_paths_first" >&6; }
+	    if test $tcl_cv_ld_search_paths_first = yes; then :
 
 		LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
 
 fi
-
-	    if test "$tcl_cv_cc_visibility_hidden" != yes; then
+	    if test "$tcl_cv_cc_visibility_hidden" != yes; then :
 
 
-cat >>confdefs.h <<\_ACEOF
-#define MODULE_SCOPE __private_extern__
-_ACEOF
+$as_echo "#define MODULE_SCOPE __private_extern__" >>confdefs.h
 
 
 fi
-
 	    CC_SEARCH_FLAGS=""
 	    LD_SEARCH_FLAGS=""
 	    LD_LIBRARY_PATH_VAR="DYLD_LIBRARY_PATH"
 
-cat >>confdefs.h <<\_ACEOF
-#define MAC_OSX_TCL 1
-_ACEOF
+$as_echo "#define MAC_OSX_TCL 1" >>confdefs.h
 
 	    PLAT_OBJS='${MAC_OSX_OBJS}'
 	    PLAT_SRCS='${MAC_OSX_SRCS}'
-	    echo "$as_me:$LINENO: checking whether to use CoreFoundation" >&5
-echo $ECHO_N "checking whether to use CoreFoundation... $ECHO_C" >&6
-	    # Check whether --enable-corefoundation or --disable-corefoundation was given.
-if test "${enable_corefoundation+set}" = set; then
-  enableval="$enable_corefoundation"
-  tcl_corefoundation=$enableval
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use CoreFoundation" >&5
+$as_echo_n "checking whether to use CoreFoundation... " >&6; }
+	    # Check whether --enable-corefoundation was given.
+if test "${enable_corefoundation+set}" = set; then :
+  enableval=$enable_corefoundation; tcl_corefoundation=$enableval
 else
   tcl_corefoundation=yes
-fi;
-	    echo "$as_me:$LINENO: result: $tcl_corefoundation" >&5
-echo "${ECHO_T}$tcl_corefoundation" >&6
-	    if test $tcl_corefoundation = yes; then
+fi
 
-		echo "$as_me:$LINENO: checking for CoreFoundation.framework" >&5
-echo $ECHO_N "checking for CoreFoundation.framework... $ECHO_C" >&6
-if test "${tcl_cv_lib_corefoundation+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_corefoundation" >&5
+$as_echo "$tcl_corefoundation" >&6; }
+	    if test $tcl_corefoundation = yes; then :
+
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CoreFoundation.framework" >&5
+$as_echo_n "checking for CoreFoundation.framework... " >&6; }
+if ${tcl_cv_lib_corefoundation+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 		    hold_libs=$LIBS
-		    if test "$fat_32_64" = yes; then
+		    if test "$fat_32_64" = yes; then :
 
 			for v in CFLAGS CPPFLAGS LDFLAGS; do
 			    # On Tiger there is no 64-bit CF, so remove 64-bit
@@ -8033,13 +5989,8 @@ else
 			    eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc64 / /g" -e "s/-arch x86_64 / /g"`"'
 			done
 fi
-
 		    LIBS="$LIBS -framework CoreFoundation"
-		    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+		    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <CoreFoundation/CoreFoundation.h>
 int
@@ -8050,77 +6001,45 @@ CFBundleRef b = CFBundleGetMainBundle();
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_lib_corefoundation=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_lib_corefoundation=no
+  tcl_cv_lib_corefoundation=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-		    if test "$fat_32_64" = yes; then
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+		    if test "$fat_32_64" = yes; then :
 
 			for v in CFLAGS CPPFLAGS LDFLAGS; do
 			    eval $v'="$hold_'$v'"'
 		        done
 fi
-
 		    LIBS=$hold_libs
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_lib_corefoundation" >&5
-echo "${ECHO_T}$tcl_cv_lib_corefoundation" >&6
-		if test $tcl_cv_lib_corefoundation = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_lib_corefoundation" >&5
+$as_echo "$tcl_cv_lib_corefoundation" >&6; }
+		if test $tcl_cv_lib_corefoundation = yes; then :
 
 		    LIBS="$LIBS -framework CoreFoundation"
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_COREFOUNDATION 1
-_ACEOF
+$as_echo "#define HAVE_COREFOUNDATION 1" >>confdefs.h
 
 
 else
   tcl_corefoundation=no
 fi
+		if test "$fat_32_64" = yes -a $tcl_corefoundation = yes; then :
 
-		if test "$fat_32_64" = yes -a $tcl_corefoundation = yes; then
-
-		    echo "$as_me:$LINENO: checking for 64-bit CoreFoundation" >&5
-echo $ECHO_N "checking for 64-bit CoreFoundation... $ECHO_C" >&6
-if test "${tcl_cv_lib_corefoundation_64+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+		    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for 64-bit CoreFoundation" >&5
+$as_echo_n "checking for 64-bit CoreFoundation... " >&6; }
+if ${tcl_cv_lib_corefoundation_64+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 			for v in CFLAGS CPPFLAGS LDFLAGS; do
 			    eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc / /g" -e "s/-arch i386 / /g"`"'
 			done
-			cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+			cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <CoreFoundation/CoreFoundation.h>
 int
@@ -8131,60 +6050,31 @@ CFBundleRef b = CFBundleGetMainBundle();
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_lib_corefoundation_64=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_lib_corefoundation_64=no
+  tcl_cv_lib_corefoundation_64=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 			for v in CFLAGS CPPFLAGS LDFLAGS; do
 			    eval $v'="$hold_'$v'"'
 			done
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_lib_corefoundation_64" >&5
-echo "${ECHO_T}$tcl_cv_lib_corefoundation_64" >&6
-		    if test $tcl_cv_lib_corefoundation_64 = no; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_lib_corefoundation_64" >&5
+$as_echo "$tcl_cv_lib_corefoundation_64" >&6; }
+		    if test $tcl_cv_lib_corefoundation_64 = no; then :
 
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_COREFOUNDATION_64 1
-_ACEOF
+$as_echo "#define NO_COREFOUNDATION_64 1" >>confdefs.h
 
                         LDFLAGS="$LDFLAGS -Wl,-no_arch_warnings"
 
 fi
 
-
 fi
 
-
 fi
-
 	    ;;
 	NEXTSTEP-*)
 	    SHLIB_CFLAGS=""
@@ -8200,9 +6090,7 @@ fi
 	    SHLIB_LD_LIBS=""
 	    CFLAGS_OPTIMIZE=""		# Optimizer is buggy
 
-cat >>confdefs.h <<\_ACEOF
-#define _OE_SOCKETS 1
-_ACEOF
+$as_echo "#define _OE_SOCKETS 1" >>confdefs.h
 
 	    ;;
 	OSF1-1.0|OSF1-1.1|OSF1-1.2)
@@ -8220,14 +6108,13 @@ _ACEOF
 	OSF1-1.*)
 	    # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2
 	    SHLIB_CFLAGS="-fPIC"
-	    if test "$SHARED_BUILD" = 1; then
+	    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"
@@ -8238,7 +6125,7 @@ fi
 	OSF1-V*)
 	    # Digital OSF/1
 	    SHLIB_CFLAGS=""
-	    if test "$SHARED_BUILD" = 1; then
+	    if test "$SHARED_BUILD" = 1; then :
 
 	        SHLIB_LD='ld -shared -expect_unresolved "*"'
 
@@ -8247,30 +6134,27 @@ else
 	        SHLIB_LD='ld -non_shared -expect_unresolved "*"'
 
 fi
-
 	    SHLIB_SUFFIX=".so"
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS=""
-	    if test $doRpath = yes; then
+	    if test $doRpath = yes; then :
 
 		CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
 fi
-
-	    if test "$GCC" = yes; then
+	    if test "$GCC" = yes; then :
   CFLAGS="$CFLAGS -mieee"
 else
 
 		CFLAGS="$CFLAGS -DHAVE_TZSET -std1 -ieee"
 fi
-
 	    # see pthread_intro(3) for pthread support on osf1, k.furukawa
-	    if test "${TCL_THREADS}" = 1; then
+	    if test "${TCL_THREADS}" = 1; then :
 
 		CFLAGS="$CFLAGS -DHAVE_PTHREAD_ATTR_SETSTACKSIZE"
 		CFLAGS="$CFLAGS -DTCL_THREAD_STACK_MIN=PTHREAD_STACK_MIN*64"
 		LIBS=`echo $LIBS | sed s/-lpthreads//`
-		if test "$GCC" = yes; then
+		if test "$GCC" = yes; then :
 
 		    LIBS="$LIBS -lpthread -lmach -lexc"
 
@@ -8281,9 +6165,7 @@ else
 
 fi
 
-
 fi
-
 	    ;;
 	QNX-6*)
 	    # QNX RTP
@@ -8302,7 +6184,7 @@ fi
 	    # Note, dlopen is available only on SCO 3.2.5 and greater. However,
 	    # this test works, since "uname -s" was non-standard in 3.2.4 and
 	    # below.
-	    if test "$GCC" = yes; then
+	    if test "$GCC" = yes; then :
 
 	    	SHLIB_CFLAGS="-fPIC -melf"
 	    	LDFLAGS="$LDFLAGS -melf -Wl,-Bexport"
@@ -8313,7 +6195,6 @@ else
 	    	LDFLAGS="$LDFLAGS -belf -Wl,-Bexport"
 
 fi
-
 	    SHLIB_LD="ld -G"
 	    SHLIB_LD_LIBS=""
 	    SHLIB_SUFFIX=".so"
@@ -8358,21 +6239,17 @@ fi
 	    # won't define thread-safe library routines.
 
 
-cat >>confdefs.h <<\_ACEOF
-#define _REENTRANT 1
-_ACEOF
+$as_echo "#define _REENTRANT 1" >>confdefs.h
 
 
-cat >>confdefs.h <<\_ACEOF
-#define _POSIX_PTHREAD_SEMANTICS 1
-_ACEOF
+$as_echo "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h
 
 
 	    SHLIB_CFLAGS="-KPIC"
 	    SHLIB_SUFFIX=".so"
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS="-ldl"
-	    if test "$GCC" = yes; then
+	    if test "$GCC" = yes; then :
 
 		SHLIB_LD='${CC} -shared'
 		CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
@@ -8385,37 +6262,32 @@ else
 		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
 
 fi
-
 	    ;;
 	SunOS-5*)
 	    # Note: If _REENTRANT isn't defined, then Solaris
 	    # won't define thread-safe library routines.
 
 
-cat >>confdefs.h <<\_ACEOF
-#define _REENTRANT 1
-_ACEOF
+$as_echo "#define _REENTRANT 1" >>confdefs.h
 
 
-cat >>confdefs.h <<\_ACEOF
-#define _POSIX_PTHREAD_SEMANTICS 1
-_ACEOF
+$as_echo "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h
 
 
 	    SHLIB_CFLAGS="-KPIC"
 
 	    # Check to enable 64-bit flags for compiler/linker
-	    if test "$do64bit" = yes; then
+	    if test "$do64bit" = yes; then :
 
 		arch=`isainfo`
-		if test "$arch" = "sparcv9 sparc"; then
+		if test "$arch" = "sparcv9 sparc"; then :
 
-		    if test "$GCC" = yes; then
+		    if test "$GCC" = yes; then :
 
-			if test "`${CC} -dumpversion | awk -F. '{print $1}'`" -lt 3; then
+			if test "`${CC} -dumpversion | awk -F. '{print $1}'`" -lt 3; then :
 
-			    { echo "$as_me:$LINENO: WARNING: 64bit mode not supported with GCC < 3.2 on $system" >&5
-echo "$as_me: WARNING: 64bit mode not supported with GCC < 3.2 on $system" >&2;}
+			    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit mode not supported with GCC < 3.2 on $system" >&5
+$as_echo "$as_me: WARNING: 64bit mode not supported with GCC < 3.2 on $system" >&2;}
 
 else
 
@@ -8426,11 +6298,10 @@ else
 
 fi
 
-
 else
 
 			do64bit_ok=yes
-			if test "$do64bitVIS" = yes; then
+			if test "$do64bitVIS" = yes; then :
 
 			    CFLAGS="$CFLAGS -xarch=v9a"
 			    LDFLAGS_ARCH="-xarch=v9a"
@@ -8441,17 +6312,15 @@ else
 			    LDFLAGS_ARCH="-xarch=v9"
 
 fi
-
 			# Solaris 64 uses this as well
 			#LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH_64"
 
 fi
 
-
 else
-  if test "$arch" = "amd64 i386"; then
+  if test "$arch" = "amd64 i386"; then :
 
-		    if test "$GCC" = yes; then
+		    if test "$GCC" = yes; then :
 
 			case $system in
 			    SunOS-5.1[1-9]*|SunOS-5.[2-9][0-9]*)
@@ -8459,8 +6328,8 @@ else
 				CFLAGS="$CFLAGS -m64"
 				LDFLAGS="$LDFLAGS -m64";;
 			    *)
-				{ echo "$as_me:$LINENO: WARNING: 64bit mode not supported with GCC on $system" >&5
-echo "$as_me: WARNING: 64bit mode not supported with GCC on $system" >&2;};;
+				{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit mode not supported with GCC on $system" >&5
+$as_echo "$as_me: WARNING: 64bit mode not supported with GCC on $system" >&2;};;
 			esac
 
 else
@@ -8477,169 +6346,32 @@ else
 
 fi
 
-
 else
-  { echo "$as_me:$LINENO: WARNING: 64bit mode not supported for $arch" >&5
-echo "$as_me: WARNING: 64bit mode not supported for $arch" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit mode not supported for $arch" >&5
+$as_echo "$as_me: WARNING: 64bit mode not supported for $arch" >&2;}
 fi
-
 fi
 
-
 fi
 
-
 	    #--------------------------------------------------------------------
 	    # On Solaris 5.x i386 with the sunpro compiler we need to link
 	    # with sunmath to get floating point rounding control
 	    #--------------------------------------------------------------------
-	    if test "$GCC" = yes; then
+	    if test "$GCC" = yes; then :
   use_sunmath=no
 else
 
 		arch=`isainfo`
-		echo "$as_me:$LINENO: checking whether to use -lsunmath for fp rounding control" >&5
-echo $ECHO_N "checking whether to use -lsunmath for fp rounding control... $ECHO_C" >&6
-		if test "$arch" = "amd64 i386"; then
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use -lsunmath for fp rounding control" >&5
+$as_echo_n "checking whether to use -lsunmath for fp rounding control... " >&6; }
+		if test "$arch" = "amd64 i386"; then :
 
-			echo "$as_me:$LINENO: result: yes" >&5
-echo "${ECHO_T}yes" >&6
+			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
 			MATH_LIBS="-lsunmath $MATH_LIBS"
-			if test "${ac_cv_header_sunmath_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for sunmath.h" >&5
-echo $ECHO_N "checking for sunmath.h... $ECHO_C" >&6
-if test "${ac_cv_header_sunmath_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_sunmath_h" >&5
-echo "${ECHO_T}$ac_cv_header_sunmath_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking sunmath.h usability" >&5
-echo $ECHO_N "checking sunmath.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <sunmath.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking sunmath.h presence" >&5
-echo $ECHO_N "checking sunmath.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <sunmath.h>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: sunmath.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: sunmath.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sunmath.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: sunmath.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: sunmath.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: sunmath.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sunmath.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: sunmath.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sunmath.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: sunmath.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sunmath.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: sunmath.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sunmath.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: sunmath.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sunmath.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: sunmath.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for sunmath.h" >&5
-echo $ECHO_N "checking for sunmath.h... $ECHO_C" >&6
-if test "${ac_cv_header_sunmath_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_cv_header_sunmath_h=$ac_header_preproc
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_sunmath_h" >&5
-echo "${ECHO_T}$ac_cv_header_sunmath_h" >&6
+			ac_fn_c_check_header_mongrel "$LINENO" "sunmath.h" "ac_cv_header_sunmath_h" "$ac_includes_default"
+if test "x$ac_cv_header_sunmath_h" = xyes; then :
 
 fi
 
@@ -8648,26 +6380,24 @@ fi
 
 else
 
-			echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+			{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 			use_sunmath=no
 
 fi
 
-
 fi
-
 	    SHLIB_SUFFIX=".so"
 	    DL_OBJS="tclLoadDl.o"
 	    DL_LIBS="-ldl"
-	    if test "$GCC" = yes; then
+	    if test "$GCC" = yes; then :
 
 		SHLIB_LD='${CC} -shared'
 		CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
 		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-		if test "$do64bit_ok" = yes; then
+		if test "$do64bit_ok" = yes; then :
 
-		    if test "$arch" = "sparcv9 sparc"; then
+		    if test "$arch" = "sparcv9 sparc"; then :
 
 			# We need to specify -static-libgcc or we need to
 			# add the path to the sparv9 libgcc.
@@ -8678,26 +6408,22 @@ fi
 			#CC_SEARCH_FLAGS="${CC_SEARCH_FLAGS},-R,$v9gcclibdir"
 
 else
-  if test "$arch" = "amd64 i386"; then
+  if test "$arch" = "amd64 i386"; then :
 
 			SHLIB_LD="$SHLIB_LD -m64 -static-libgcc"
 
 fi
-
 fi
 
-
 fi
 
-
 else
 
-		if test "$use_sunmath" = yes; then
+		if test "$use_sunmath" = yes; then :
   textmode=textoff
 else
   textmode=text
 fi
-
 		case $system in
 		    SunOS-5.[1-9][0-9]*)
 			SHLIB_LD="\${CC} -G -z $textmode \${LDFLAGS}";;
@@ -8708,7 +6434,6 @@ fi
 		LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
 
 fi
-
 	    ;;
 	UNIX_SV* | UnixWare-5*)
 	    SHLIB_CFLAGS="-KPIC"
@@ -8719,19 +6444,15 @@ fi
 	    DL_LIBS="-ldl"
 	    # Some UNIX_SV* systems (unixware 1.1.2 for example) have linkers
 	    # that don't grok the -Bexport option.  Test that it does.
-	    echo "$as_me:$LINENO: checking for ld accepts -Bexport flag" >&5
-echo $ECHO_N "checking for ld accepts -Bexport flag... $ECHO_C" >&6
-if test "${tcl_cv_ld_Bexport+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld accepts -Bexport flag" >&5
+$as_echo_n "checking for ld accepts -Bexport flag... " >&6; }
+if ${tcl_cv_ld_Bexport+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 		hold_ldflags=$LDFLAGS
 		LDFLAGS="$LDFLAGS -Wl,-Bexport"
-		cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+		cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -8742,93 +6463,63 @@ int i;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_ld_Bexport=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_ld_Bexport=no
+  tcl_cv_ld_Bexport=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 	        LDFLAGS=$hold_ldflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_ld_Bexport" >&5
-echo "${ECHO_T}$tcl_cv_ld_Bexport" >&6
-	    if test $tcl_cv_ld_Bexport = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_ld_Bexport" >&5
+$as_echo "$tcl_cv_ld_Bexport" >&6; }
+	    if test $tcl_cv_ld_Bexport = yes; then :
 
 		LDFLAGS="$LDFLAGS -Wl,-Bexport"
 
 fi
-
 	    CC_SEARCH_FLAGS=""
 	    LD_SEARCH_FLAGS=""
 	    ;;
     esac
 
-    if test "$do64bit" = yes -a "$do64bit_ok" = no; then
+    if test "$do64bit" = yes -a "$do64bit_ok" = no; then :
 
-	{ echo "$as_me:$LINENO: WARNING: 64bit support being disabled -- don't know magic for this platform" >&5
-echo "$as_me: WARNING: 64bit support being disabled -- don't know magic for this platform" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit support being disabled -- don't know magic for this platform" >&5
+$as_echo "$as_me: WARNING: 64bit support being disabled -- don't know magic for this platform" >&2;}
 
 fi
 
-
-    if test "$do64bit" = yes -a "$do64bit_ok" = yes; then
+    if test "$do64bit" = yes -a "$do64bit_ok" = yes; then :
 
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_CFG_DO64BIT 1
-_ACEOF
+$as_echo "#define TCL_CFG_DO64BIT 1" >>confdefs.h
 
 
 fi
 
 
 
-
     # Step 4: disable dynamic loading if requested via a command-line switch.
 
-    # Check whether --enable-load or --disable-load was given.
-if test "${enable_load+set}" = set; then
-  enableval="$enable_load"
-  tcl_ok=$enableval
+    # Check whether --enable-load was given.
+if test "${enable_load+set}" = set; then :
+  enableval=$enable_load; tcl_ok=$enableval
 else
   tcl_ok=yes
-fi;
-    if test "$tcl_ok" = no; then
-  DL_OBJS=""
 fi
 
+    if test "$tcl_ok" = no; then :
+  DL_OBJS=""
+fi
 
-    if test "x$DL_OBJS" != x; then
+    if test "x$DL_OBJS" != x; then :
   BUILD_DLTEST="\$(DLTEST_TARGETS)"
 else
 
-	{ echo "$as_me:$LINENO: WARNING: Can't figure out how to do dynamic loading or shared libraries on this system." >&5
-echo "$as_me: WARNING: Can't figure out how to do dynamic loading or shared libraries on this system." >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can't figure out how to do dynamic loading or shared libraries on this system." >&5
+$as_echo "$as_me: WARNING: Can't figure out how to do dynamic loading or shared libraries on this system." >&2;}
 	SHLIB_CFLAGS=""
 	SHLIB_LD=""
 	SHLIB_SUFFIX=""
@@ -8840,14 +6531,13 @@ echo "$as_me: WARNING: Can't figure out how to do dynamic loading or shared libr
 	BUILD_DLTEST=""
 
 fi
-
     LDFLAGS="$LDFLAGS $LDFLAGS_ARCH"
 
     # If we're running gcc, then change the C flags for compiling shared
     # libraries to the right flags for gcc, instead of those for the
     # standard manufacturer compiler.
 
-    if test "$DL_OBJS" != "tclLoadNone.o" -a "$GCC" = yes; then
+    if test "$DL_OBJS" != "tclLoadNone.o" -a "$GCC" = yes; then :
 
 	case $system in
 	    AIX-*) ;;
@@ -8861,24 +6551,21 @@ fi
 	esac
 fi
 
-
-    if test "$SHARED_LIB_SUFFIX" = ""; then
+    if test "$SHARED_LIB_SUFFIX" = ""; then :
 
 	SHARED_LIB_SUFFIX='${VERSION}${SHLIB_SUFFIX}'
 fi
-
-    if test "$UNSHARED_LIB_SUFFIX" = ""; then
+    if test "$UNSHARED_LIB_SUFFIX" = ""; then :
 
 	UNSHARED_LIB_SUFFIX='${VERSION}.a'
 fi
-
     DLL_INSTALL_DIR="\$(LIB_INSTALL_DIR)"
 
-    if test "${SHARED_BUILD}" = 1 -a "${SHLIB_SUFFIX}" != ""; then
+    if test "${SHARED_BUILD}" = 1 -a "${SHLIB_SUFFIX}" != ""; then :
 
         LIB_SUFFIX=${SHARED_LIB_SUFFIX}
         MAKE_LIB='${SHLIB_LD} -o $@ ${OBJS} ${SHLIB_LD_LIBS} ${TCL_SHLIB_LD_EXTRAS} ${TK_SHLIB_LD_EXTRAS} ${LD_SEARCH_FLAGS}'
-        if test "${SHLIB_SUFFIX}" = ".dll"; then
+        if test "${SHLIB_SUFFIX}" = ".dll"; then :
 
             INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) "$(BIN_INSTALL_DIR)/$(LIB_FILE)";if test -f $(LIB_FILE).a; then $(INSTALL_DATA) $(LIB_FILE).a "$(LIB_INSTALL_DIR)"; fi;'
             DLL_INSTALL_DIR="\$(BIN_INSTALL_DIR)"
@@ -8889,12 +6576,11 @@ else
 
 fi
 
-
 else
 
         LIB_SUFFIX=${UNSHARED_LIB_SUFFIX}
 
-        if test "$RANLIB" = ""; then
+        if test "$RANLIB" = ""; then :
 
             MAKE_LIB='$(STLIB_LD) $@ ${OBJS}'
             INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) "$(LIB_INSTALL_DIR)/$(LIB_FILE)"'
@@ -8906,12 +6592,10 @@ else
 
 fi
 
-
 fi
 
-
     # Stub lib does not depend on shared/static configuration
-    if test "$RANLIB" = ""; then
+    if test "$RANLIB" = ""; then :
 
         MAKE_STUB_LIB='${STLIB_LD} $@ ${STUB_LIB_OBJS}'
         INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) "$(LIB_INSTALL_DIR)/$(STUB_LIB_FILE)"'
@@ -8923,31 +6607,25 @@ else
 
 fi
 
-
     # Define TCL_LIBS now that we know what DL_LIBS is.
     # The trick here is that we don't want to change the value of TCL_LIBS if
     # it is already set when tclConfig.sh had been loaded by Tk.
-    if test "x${TCL_LIBS}" = x; then
+    if test "x${TCL_LIBS}" = x; then :
 
         TCL_LIBS="${DL_LIBS} ${LIBS} ${MATH_LIBS}"
 fi
 
 
-
 	# See if the compiler supports casting to a union type.
 	# This is used to stop gcc from printing a compiler
 	# warning when initializing a union member.
 
-	echo "$as_me:$LINENO: checking for cast to union support" >&5
-echo $ECHO_N "checking for cast to union support... $ECHO_C" >&6
-if test "${tcl_cv_cast_to_union+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for cast to union support" >&5
+$as_echo_n "checking for cast to union support... " >&6; }
+if ${tcl_cv_cast_to_union+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -8961,45 +6639,19 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_cast_to_union=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cast_to_union=no
+  tcl_cv_cast_to_union=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_cast_to_union" >&5
-echo "${ECHO_T}$tcl_cv_cast_to_union" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cast_to_union" >&5
+$as_echo "$tcl_cv_cast_to_union" >&6; }
 	if test "$tcl_cv_cast_to_union" = "yes"; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_CAST_TO_UNION 1
-_ACEOF
+$as_echo "#define HAVE_CAST_TO_UNION 1" >>confdefs.h
 
 	fi
 
@@ -9045,38 +6697,34 @@ _ACEOF
 
 
 
-    echo "$as_me:$LINENO: checking for build with symbols" >&5
-echo $ECHO_N "checking for build with symbols... $ECHO_C" >&6
-    # Check whether --enable-symbols or --disable-symbols was given.
-if test "${enable_symbols+set}" = set; then
-  enableval="$enable_symbols"
-  tcl_ok=$enableval
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for build with symbols" >&5
+$as_echo_n "checking for build with symbols... " >&6; }
+    # Check whether --enable-symbols was given.
+if test "${enable_symbols+set}" = set; then :
+  enableval=$enable_symbols; tcl_ok=$enableval
 else
   tcl_ok=no
-fi;
+fi
+
 # FIXME: Currently, LDFLAGS_DEFAULT is not used, it should work like CFLAGS_DEFAULT.
     DBGX=""
     if test "$tcl_ok" = "no"; then
 	CFLAGS_DEFAULT='$(CFLAGS_OPTIMIZE)'
 	LDFLAGS_DEFAULT='$(LDFLAGS_OPTIMIZE)'
 
-cat >>confdefs.h <<\_ACEOF
-#define NDEBUG 1
-_ACEOF
+$as_echo "#define NDEBUG 1" >>confdefs.h
 
-	echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_CFG_OPTIMIZED 1
-_ACEOF
+$as_echo "#define TCL_CFG_OPTIMIZED 1" >>confdefs.h
 
     else
 	CFLAGS_DEFAULT='$(CFLAGS_DEBUG)'
 	LDFLAGS_DEFAULT='$(LDFLAGS_DEBUG)'
 	if test "$tcl_ok" = "yes"; then
-	    echo "$as_me:$LINENO: result: yes (standard debugging)" >&5
-echo "${ECHO_T}yes (standard debugging)" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (standard debugging)" >&5
+$as_echo "yes (standard debugging)" >&6; }
 	fi
     fi
 
@@ -9084,45 +6732,35 @@ echo "${ECHO_T}yes (standard debugging)" >&6
 
     if test "$tcl_ok" = "mem" -o "$tcl_ok" = "all"; then
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_MEM_DEBUG 1
-_ACEOF
+$as_echo "#define TCL_MEM_DEBUG 1" >>confdefs.h
 
     fi
 
     	if test "$tcl_ok" = "compile" -o "$tcl_ok" = "all"; then
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_COMPILE_DEBUG 1
-_ACEOF
+$as_echo "#define TCL_COMPILE_DEBUG 1" >>confdefs.h
 
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_COMPILE_STATS 1
-_ACEOF
+$as_echo "#define TCL_COMPILE_STATS 1" >>confdefs.h
 
 	fi
 
     if test "$tcl_ok" != "yes" -a "$tcl_ok" != "no"; then
 	if test "$tcl_ok" = "all"; then
-	    echo "$as_me:$LINENO: result: enabled symbols mem compile debugging" >&5
-echo "${ECHO_T}enabled symbols mem compile debugging" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: enabled symbols mem compile debugging" >&5
+$as_echo "enabled symbols mem compile debugging" >&6; }
 	else
-	    echo "$as_me:$LINENO: result: enabled $tcl_ok debugging" >&5
-echo "${ECHO_T}enabled $tcl_ok debugging" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: enabled $tcl_ok debugging" >&5
+$as_echo "enabled $tcl_ok debugging" >&6; }
 	fi
     fi
 
 
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_TOMMATH 1
-_ACEOF
+$as_echo "#define TCL_TOMMATH 1" >>confdefs.h
 
 
-cat >>confdefs.h <<\_ACEOF
-#define MP_PREC 4
-_ACEOF
+$as_echo "#define MP_PREC 4" >>confdefs.h
 
 
 #--------------------------------------------------------------------
@@ -9130,18 +6768,14 @@ _ACEOF
 #--------------------------------------------------------------------
 
 
-    echo "$as_me:$LINENO: checking for required early compiler flags" >&5
-echo $ECHO_N "checking for required early compiler flags... $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for required early compiler flags" >&5
+$as_echo_n "checking for required early compiler flags... " >&6; }
     tcl_flags=""
 
-    if test "${tcl_cv_flag__isoc99_source+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if ${tcl_cv_flag__isoc99_source+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <stdlib.h>
 int
@@ -9152,38 +6786,10 @@ char *p = (char *)strtoll; char *q = (char *)strtoull;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_flag__isoc99_source=no
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #define _ISOC99_SOURCE 1
 #include <stdlib.h>
@@ -9195,58 +6801,28 @@ char *p = (char *)strtoll; char *q = (char *)strtoull;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_flag__isoc99_source=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_flag__isoc99_source=no
+  tcl_cv_flag__isoc99_source=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
     if test "x${tcl_cv_flag__isoc99_source}" = "xyes" ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define _ISOC99_SOURCE 1
-_ACEOF
+$as_echo "#define _ISOC99_SOURCE 1" >>confdefs.h
 
 	tcl_flags="$tcl_flags _ISOC99_SOURCE"
     fi
 
 
-    if test "${tcl_cv_flag__largefile64_source+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if ${tcl_cv_flag__largefile64_source+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/stat.h>
 int
@@ -9257,38 +6833,10 @@ struct stat64 buf; int i = stat64("/", &buf);
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_flag__largefile64_source=no
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #define _LARGEFILE64_SOURCE 1
 #include <sys/stat.h>
@@ -9300,58 +6848,28 @@ struct stat64 buf; int i = stat64("/", &buf);
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_flag__largefile64_source=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_flag__largefile64_source=no
+  tcl_cv_flag__largefile64_source=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
     if test "x${tcl_cv_flag__largefile64_source}" = "xyes" ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define _LARGEFILE64_SOURCE 1
-_ACEOF
+$as_echo "#define _LARGEFILE64_SOURCE 1" >>confdefs.h
 
 	tcl_flags="$tcl_flags _LARGEFILE64_SOURCE"
     fi
 
 
-    if test "${tcl_cv_flag__largefile_source64+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if ${tcl_cv_flag__largefile_source64+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/stat.h>
 int
@@ -9362,38 +6880,10 @@ char *p = (char *)open64;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_flag__largefile_source64=no
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #define _LARGEFILE_SOURCE64 1
 #include <sys/stat.h>
@@ -9405,72 +6895,42 @@ char *p = (char *)open64;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_flag__largefile_source64=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_flag__largefile_source64=no
+  tcl_cv_flag__largefile_source64=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
     if test "x${tcl_cv_flag__largefile_source64}" = "xyes" ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define _LARGEFILE_SOURCE64 1
-_ACEOF
+$as_echo "#define _LARGEFILE_SOURCE64 1" >>confdefs.h
 
 	tcl_flags="$tcl_flags _LARGEFILE_SOURCE64"
     fi
 
     if test "x${tcl_flags}" = "x" ; then
-	echo "$as_me:$LINENO: result: none" >&5
-echo "${ECHO_T}none" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
+$as_echo "none" >&6; }
     else
-	echo "$as_me:$LINENO: result: ${tcl_flags}" >&5
-echo "${ECHO_T}${tcl_flags}" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${tcl_flags}" >&5
+$as_echo "${tcl_flags}" >&6; }
     fi
 
 
 
-    echo "$as_me:$LINENO: checking for 64-bit integer type" >&5
-echo $ECHO_N "checking for 64-bit integer type... $ECHO_C" >&6
-    if test "${tcl_cv_type_64bit+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for 64-bit integer type" >&5
+$as_echo_n "checking for 64-bit integer type... " >&6; }
+    if ${tcl_cv_type_64bit+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 	tcl_cv_type_64bit=none
 	# See if the compiler knows natively about __int64
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -9481,44 +6941,16 @@ __int64 value = (__int64) 0;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_type_64bit=__int64
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_type_64bit="long long"
+  tcl_type_64bit="long long"
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 	# See if we should use long anyway  Note that we substitute in the
 	# type that is our current guess for a 64-bit type inside this check
 	# program, so it should be modified only carefully...
-        cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -9531,66 +6963,35 @@ switch (0) {
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_type_64bit=${tcl_type_64bit}
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
     if test "${tcl_cv_type_64bit}" = none ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_WIDE_INT_IS_LONG 1
-_ACEOF
+$as_echo "#define TCL_WIDE_INT_IS_LONG 1" >>confdefs.h
 
-	echo "$as_me:$LINENO: result: using long" >&5
-echo "${ECHO_T}using long" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: using long" >&5
+$as_echo "using long" >&6; }
     else
 
 cat >>confdefs.h <<_ACEOF
 #define TCL_WIDE_INT_TYPE ${tcl_cv_type_64bit}
 _ACEOF
 
-	echo "$as_me:$LINENO: result: ${tcl_cv_type_64bit}" >&5
-echo "${ECHO_T}${tcl_cv_type_64bit}" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${tcl_cv_type_64bit}" >&5
+$as_echo "${tcl_cv_type_64bit}" >&6; }
 
 	# Now check for auxiliary declarations
-	echo "$as_me:$LINENO: checking for struct dirent64" >&5
-echo $ECHO_N "checking for struct dirent64... $ECHO_C" >&6
-if test "${tcl_cv_struct_dirent64+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for struct dirent64" >&5
+$as_echo_n "checking for struct dirent64... " >&6; }
+if ${tcl_cv_struct_dirent64+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/types.h>
 #include <dirent.h>
@@ -9602,58 +7003,28 @@ struct dirent64 p;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_struct_dirent64=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_struct_dirent64=no
+  tcl_cv_struct_dirent64=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_struct_dirent64" >&5
-echo "${ECHO_T}$tcl_cv_struct_dirent64" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_struct_dirent64" >&5
+$as_echo "$tcl_cv_struct_dirent64" >&6; }
 	if test "x${tcl_cv_struct_dirent64}" = "xyes" ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_STRUCT_DIRENT64 1
-_ACEOF
+$as_echo "#define HAVE_STRUCT_DIRENT64 1" >>confdefs.h
 
 	fi
 
-	echo "$as_me:$LINENO: checking for struct stat64" >&5
-echo $ECHO_N "checking for struct stat64... $ECHO_C" >&6
-if test "${tcl_cv_struct_stat64+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for struct stat64" >&5
+$as_echo_n "checking for struct stat64... " >&6; }
+if ${tcl_cv_struct_stat64+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/stat.h>
 int
@@ -9665,161 +7036,40 @@ struct stat64 p;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_struct_stat64=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_struct_stat64=no
+  tcl_cv_struct_stat64=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_struct_stat64" >&5
-echo "${ECHO_T}$tcl_cv_struct_stat64" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_struct_stat64" >&5
+$as_echo "$tcl_cv_struct_stat64" >&6; }
 	if test "x${tcl_cv_struct_stat64}" = "xyes" ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_STRUCT_STAT64 1
-_ACEOF
+$as_echo "#define HAVE_STRUCT_STAT64 1" >>confdefs.h
 
 	fi
 
-
-
-for ac_func in open64 lseek64
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef $ac_func
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != $ac_func;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
+	for ac_func in open64 lseek64
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
   cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
 _ACEOF
 
 fi
 done
 
-	echo "$as_me:$LINENO: checking for off64_t" >&5
-echo $ECHO_N "checking for off64_t... $ECHO_C" >&6
-	if test "${tcl_cv_type_off64_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for off64_t" >&5
+$as_echo_n "checking for off64_t... " >&6; }
+	if ${tcl_cv_type_off64_t+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/types.h>
 int
@@ -9831,51 +7081,25 @@ off64_t offset;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_type_off64_t=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_type_off64_t=no
+  tcl_cv_type_off64_t=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
 
 			if test "x${tcl_cv_type_off64_t}" = "xyes" && \
 	        test "x${ac_cv_func_lseek64}" = "xyes" && \
 	        test "x${ac_cv_func_open64}" = "xyes" ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_TYPE_OFF64_T 1
-_ACEOF
+$as_echo "#define HAVE_TYPE_OFF64_T 1" >>confdefs.h
 
-	    echo "$as_me:$LINENO: result: yes" >&5
-echo "${ECHO_T}yes" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
 	else
-	    echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 	fi
     fi
 
@@ -9885,235 +7109,229 @@ echo "${ECHO_T}no" >&6
 #	Tcl_UniChar strings to memcmp on big-endian systems.
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking whether byte ordering is bigendian" >&5
-echo $ECHO_N "checking whether byte ordering is bigendian... $ECHO_C" >&6
-if test "${ac_cv_c_bigendian+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
+$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
+if ${ac_cv_c_bigendian+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  # See if sys/param.h defines the BYTE_ORDER macro.
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  ac_cv_c_bigendian=unknown
+    # See if we're dealing with a universal compiler.
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifndef __APPLE_CC__
+	       not a universal capable compiler
+	     #endif
+	     typedef int dummy;
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+	# Check for potential -arch flags.  It is not universal unless
+	# there are at least two -arch flags with different values.
+	ac_arch=
+	ac_prev=
+	for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
+	 if test -n "$ac_prev"; then
+	   case $ac_word in
+	     i?86 | x86_64 | ppc | ppc64)
+	       if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
+		 ac_arch=$ac_word
+	       else
+		 ac_cv_c_bigendian=universal
+		 break
+	       fi
+	       ;;
+	   esac
+	   ac_prev=
+	 elif test "x$ac_word" = "x-arch"; then
+	   ac_prev=arch
+	 fi
+       done
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    if test $ac_cv_c_bigendian = unknown; then
+      # See if sys/param.h defines the BYTE_ORDER macro.
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/types.h>
-#include <sys/param.h>
+	     #include <sys/param.h>
 
 int
 main ()
 {
-#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
- bogus endian macros
-#endif
+#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
+		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
+		     && LITTLE_ENDIAN)
+	      bogus endian macros
+	     #endif
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   # It does; now see whether it defined to BIG_ENDIAN or not.
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <sys/types.h>
-#include <sys/param.h>
+		#include <sys/param.h>
 
 int
 main ()
 {
 #if BYTE_ORDER != BIG_ENDIAN
- not big endian
-#endif
+		 not big endian
+		#endif
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   ac_cv_c_bigendian=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_c_bigendian=no
+  ac_cv_c_bigendian=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    fi
+    if test $ac_cv_c_bigendian = unknown; then
+      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
 
-# It does not; compile a test program.
-if test "$cross_compiling" = yes; then
-  # try to guess the endianness by grepping values into an object file
-  ac_cv_c_bigendian=unknown
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+int
+main ()
+{
+#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
+	      bogus endian macros
+	     #endif
+
+  ;
+  return 0;
+}
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  # It does; now see whether it defined to _BIG_ENDIAN or not.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
-short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
-void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; }
-short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
-short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
-void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; }
+#include <limits.h>
+
 int
 main ()
 {
- _ascii (); _ebcdic ();
+#ifndef _BIG_ENDIAN
+		 not big endian
+		#endif
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
+if ac_fn_c_try_compile "$LINENO"; then :
   ac_cv_c_bigendian=yes
+else
+  ac_cv_c_bigendian=no
 fi
-if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
-  if test "$ac_cv_c_bigendian" = unknown; then
-    ac_cv_c_bigendian=no
-  else
-    # finding both strings is unlikely to happen, but who knows?
-    ac_cv_c_bigendian=unknown
-  fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    fi
+    if test $ac_cv_c_bigendian = unknown; then
+      # Compile a test program.
+      if test "$cross_compiling" = yes; then :
+  # Try to guess by grepping values from an object file.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+short int ascii_mm[] =
+		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
+		short int ascii_ii[] =
+		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
+		int use_ascii (int i) {
+		  return ascii_mm[i] + ascii_ii[i];
+		}
+		short int ebcdic_ii[] =
+		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
+		short int ebcdic_mm[] =
+		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
+		int use_ebcdic (int i) {
+		  return ebcdic_mm[i] + ebcdic_ii[i];
+		}
+		extern int foo;
 
+int
+main ()
+{
+return use_ascii (foo) == use_ebcdic (foo);
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
+	      ac_cv_c_bigendian=yes
+	    fi
+	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
+	      if test "$ac_cv_c_bigendian" = unknown; then
+		ac_cv_c_bigendian=no
+	      else
+		# finding both strings is unlikely to happen, but who knows?
+		ac_cv_c_bigendian=unknown
+	      fi
+	    fi
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+$ac_includes_default
 int
 main ()
 {
-  /* Are we little or big endian?  From Harbison&Steele.  */
-  union
-  {
-    long l;
-    char c[sizeof (long)];
-  } u;
-  u.l = 1;
-  exit (u.c[sizeof (long) - 1] == 1);
+
+	     /* Are we little or big endian?  From Harbison&Steele.  */
+	     union
+	     {
+	       long int l;
+	       char c[sizeof (long int)];
+	     } u;
+	     u.l = 1;
+	     return u.c[sizeof (long int) - 1] == 1;
+
+  ;
+  return 0;
 }
 _ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_run "$LINENO"; then :
   ac_cv_c_bigendian=no
 else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-ac_cv_c_bigendian=yes
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+  ac_cv_c_bigendian=yes
 fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+
+    fi
 fi
-echo "$as_me:$LINENO: result: $ac_cv_c_bigendian" >&5
-echo "${ECHO_T}$ac_cv_c_bigendian" >&6
-case $ac_cv_c_bigendian in
-  yes)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
+$as_echo "$ac_cv_c_bigendian" >&6; }
+ case $ac_cv_c_bigendian in #(
+   yes)
+     $as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h
+;; #(
+   no)
+      ;; #(
+   universal)
 
-cat >>confdefs.h <<\_ACEOF
-#define WORDS_BIGENDIAN 1
-_ACEOF
- ;;
-  no)
-     ;;
-  *)
-    { { echo "$as_me:$LINENO: error: unknown endianness
-presetting ac_cv_c_bigendian=no (or yes) will help" >&5
-echo "$as_me: error: unknown endianness
-presetting ac_cv_c_bigendian=no (or yes) will help" >&2;}
-   { (exit 1); exit 1; }; } ;;
-esac
+$as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
+
+     ;; #(
+   *)
+     as_fn_error $? "unknown endianness
+ presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
+ esac
 
 
 #--------------------------------------------------------------------
@@ -10122,7497 +7340,2458 @@ esac
 #--------------------------------------------------------------------
 
 # Check if Posix compliant getcwd exists, if not we'll use getwd.
-
 for ac_func in getcwd
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+do :
+  ac_fn_c_check_func "$LINENO" "getcwd" "ac_cv_func_getcwd"
+if test "x$ac_cv_func_getcwd" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_GETCWD 1
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+else
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+$as_echo "#define USEGETWD 1" >>confdefs.h
 
-#undef $ac_func
+fi
+done
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
+# Nb: if getcwd uses popen and pwd(1) (like SunOS 4) we should really
+# define USEGETWD even if the posix getcwd exists. Add a test ?
+
+ac_fn_c_check_func "$LINENO" "opendir" "ac_cv_func_opendir"
+if test "x$ac_cv_func_opendir" = xyes; then :
+  $as_echo "#define HAVE_OPENDIR 1" >>confdefs.h
 
-int
-main ()
-{
-return f != $ac_func;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+  case " $LIBOBJS " in
+  *" opendir.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS opendir.$ac_objext"
+ ;;
+esac
 
-eval "$as_ac_var=no"
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-_ACEOF
+
+ac_fn_c_check_func "$LINENO" "strtol" "ac_cv_func_strtol"
+if test "x$ac_cv_func_strtol" = xyes; then :
+  $as_echo "#define HAVE_STRTOL 1" >>confdefs.h
 
 else
+  case " $LIBOBJS " in
+  *" strtol.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS strtol.$ac_objext"
+ ;;
+esac
 
-cat >>confdefs.h <<\_ACEOF
-#define USEGETWD 1
-_ACEOF
+fi
+
+ac_fn_c_check_func "$LINENO" "waitpid" "ac_cv_func_waitpid"
+if test "x$ac_cv_func_waitpid" = xyes; then :
+  $as_echo "#define HAVE_WAITPID 1" >>confdefs.h
+
+else
+  case " $LIBOBJS " in
+  *" waitpid.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS waitpid.$ac_objext"
+ ;;
+esac
 
 fi
-done
 
-# Nb: if getcwd uses popen and pwd(1) (like SunOS 4) we should really
-# define USEGETWD even if the posix getcwd exists. Add a test ?
 
+ac_fn_c_check_func "$LINENO" "strerror" "ac_cv_func_strerror"
+if test "x$ac_cv_func_strerror" = xyes; then :
 
+else
 
+$as_echo "#define NO_STRERROR 1" >>confdefs.h
 
-for ac_func in opendir strtol waitpid
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
+fi
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+ac_fn_c_check_func "$LINENO" "getwd" "ac_cv_func_getwd"
+if test "x$ac_cv_func_getwd" = xyes; then :
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+else
 
-#undef $ac_func
+$as_echo "#define NO_GETWD 1" >>confdefs.h
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
+fi
+
+ac_fn_c_check_func "$LINENO" "wait3" "ac_cv_func_wait3"
+if test "x$ac_cv_func_wait3" = xyes; then :
 
-int
-main ()
-{
-return f != $ac_func;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-eval "$as_ac_var=no"
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+$as_echo "#define NO_WAIT3 1" >>confdefs.h
+
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-_ACEOF
+
+ac_fn_c_check_func "$LINENO" "uname" "ac_cv_func_uname"
+if test "x$ac_cv_func_uname" = xyes; then :
 
 else
-  case $LIBOBJS in
-    "$ac_func.$ac_objext"   | \
-  *" $ac_func.$ac_objext"   | \
-    "$ac_func.$ac_objext "* | \
-  *" $ac_func.$ac_objext "* ) ;;
-  *) LIBOBJS="$LIBOBJS $ac_func.$ac_objext" ;;
-esac
+
+$as_echo "#define NO_UNAME 1" >>confdefs.h
 
 fi
-done
 
 
-echo "$as_me:$LINENO: checking for strerror" >&5
-echo $ECHO_N "checking for strerror... $ECHO_C" >&6
-if test "${ac_cv_func_strerror+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+if test "`uname -s`" = "Darwin" && test "${TCL_THREADS}" = 1 && \
+	test "`uname -r | awk -F. '{print $1}'`" -lt 7; then
+    # prior to Darwin 7, realpath is not threadsafe, so don't
+    # use it when threads are enabled, c.f. bug # 711232
+    ac_cv_func_realpath=no
+fi
+ac_fn_c_check_func "$LINENO" "realpath" "ac_cv_func_realpath"
+if test "x$ac_cv_func_realpath" = xyes; then :
+
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define strerror to an innocuous variant, in case <limits.h> declares strerror.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define strerror innocuous_strerror
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char strerror (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+$as_echo "#define NO_REALPATH 1" >>confdefs.h
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+fi
 
-#undef strerror
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strerror ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_strerror) || defined (__stub___strerror)
-choke me
-#else
-char (*f) () = strerror;
-#endif
-#ifdef __cplusplus
-}
-#endif
+ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
+if test "x$ac_cv_func_getaddrinfo" = xyes; then :
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working getaddrinfo" >&5
+$as_echo_n "checking for working getaddrinfo... " >&6; }
+if ${tcl_cv_api_getaddrinfo+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+	#include <netdb.h>
 
 int
 main ()
 {
-return f != strerror;
+
+	const char *name, *port;
+	struct addrinfo *aiPtr, hints;
+	(void)getaddrinfo(name,port, &hints, &aiPtr);
+	(void)freeaddrinfo(aiPtr);
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_strerror=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getaddrinfo=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_strerror=no
+  tcl_cv_getaddrinfo=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_strerror" >&5
-echo "${ECHO_T}$ac_cv_func_strerror" >&6
-if test $ac_cv_func_strerror = yes; then
-  :
-else
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getaddrinfo" >&5
+$as_echo "$tcl_cv_api_getaddrinfo" >&6; }
+    tcl_ok=$tcl_cv_api_getaddrinfo
+    if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_STRERROR 1
-_ACEOF
+$as_echo "#define HAVE_GETADDRINFO 1" >>confdefs.h
+
+    fi
 
 fi
 
-echo "$as_me:$LINENO: checking for getwd" >&5
-echo $ECHO_N "checking for getwd... $ECHO_C" >&6
-if test "${ac_cv_func_getwd+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define getwd to an innocuous variant, in case <limits.h> declares getwd.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define getwd innocuous_getwd
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char getwd (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+#--------------------------------------------------------------------
+#	Look for thread-safe variants of some library functions.
+#--------------------------------------------------------------------
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+if test "${TCL_THREADS}" = 1; then
+    ac_fn_c_check_func "$LINENO" "getpwuid_r" "ac_cv_func_getpwuid_r"
+if test "x$ac_cv_func_getpwuid_r" = xyes; then :
 
-#undef getwd
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for getpwuid_r with 5 args" >&5
+$as_echo_n "checking for getpwuid_r with 5 args... " >&6; }
+if ${tcl_cv_api_getpwuid_r_5+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char getwd ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_getwd) || defined (__stub___getwd)
-choke me
-#else
-char (*f) () = getwd;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+	#include <sys/types.h>
+	#include <pwd.h>
 
 int
 main ()
 {
-return f != getwd;
+
+	uid_t uid;
+	struct passwd pw, *pwp;
+	char buf[512];
+	int buflen = 512;
+
+	(void) getpwuid_r(uid, &pw, buf, buflen, &pwp);
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_getwd=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getpwuid_r_5=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_getwd=no
+  tcl_cv_api_getpwuid_r_5=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_getwd" >&5
-echo "${ECHO_T}$ac_cv_func_getwd" >&6
-if test $ac_cv_func_getwd = yes; then
-  :
-else
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_GETWD 1
-_ACEOF
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getpwuid_r_5" >&5
+$as_echo "$tcl_cv_api_getpwuid_r_5" >&6; }
+    tcl_ok=$tcl_cv_api_getpwuid_r_5
+    if test "$tcl_ok" = yes; then
 
-fi
+$as_echo "#define HAVE_GETPWUID_R_5 1" >>confdefs.h
 
-echo "$as_me:$LINENO: checking for wait3" >&5
-echo $ECHO_N "checking for wait3... $ECHO_C" >&6
-if test "${ac_cv_func_wait3+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    else
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for getpwuid_r with 4 args" >&5
+$as_echo_n "checking for getpwuid_r with 4 args... " >&6; }
+if ${tcl_cv_api_getpwuid_r_4+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define wait3 to an innocuous variant, in case <limits.h> declares wait3.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define wait3 innocuous_wait3
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char wait3 (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
 
-#undef wait3
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char wait3 ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_wait3) || defined (__stub___wait3)
-choke me
-#else
-char (*f) () = wait3;
-#endif
-#ifdef __cplusplus
-}
-#endif
+	    #include <sys/types.h>
+	    #include <pwd.h>
 
 int
 main ()
 {
-return f != wait3;
+
+	    uid_t uid;
+	    struct passwd pw;
+	    char buf[512];
+	    int buflen = 512;
+
+	    (void)getpwnam_r(uid, &pw, buf, buflen);
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_wait3=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getpwuid_r_4=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_wait3=no
+  tcl_cv_api_getpwuid_r_4=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_wait3" >&5
-echo "${ECHO_T}$ac_cv_func_wait3" >&6
-if test $ac_cv_func_wait3 = yes; then
-  :
-else
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getpwuid_r_4" >&5
+$as_echo "$tcl_cv_api_getpwuid_r_4" >&6; }
+	tcl_ok=$tcl_cv_api_getpwuid_r_4
+	if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_WAIT3 1
-_ACEOF
+$as_echo "#define HAVE_GETPWUID_R_4 1" >>confdefs.h
 
-fi
+	fi
+    fi
+    if test "$tcl_ok" = yes; then
 
-echo "$as_me:$LINENO: checking for uname" >&5
-echo $ECHO_N "checking for uname... $ECHO_C" >&6
-if test "${ac_cv_func_uname+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define uname to an innocuous variant, in case <limits.h> declares uname.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define uname innocuous_uname
+$as_echo "#define HAVE_GETPWUID_R 1" >>confdefs.h
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char uname (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+    fi
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+fi
 
-#undef uname
+    ac_fn_c_check_func "$LINENO" "getpwnam_r" "ac_cv_func_getpwnam_r"
+if test "x$ac_cv_func_getpwnam_r" = xyes; then :
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char uname ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_uname) || defined (__stub___uname)
-choke me
-#else
-char (*f) () = uname;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for getpwnam_r with 5 args" >&5
+$as_echo_n "checking for getpwnam_r with 5 args... " >&6; }
+if ${tcl_cv_api_getpwnam_r_5+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+	#include <sys/types.h>
+	#include <pwd.h>
 
 int
 main ()
 {
-return f != uname;
+
+	char *name;
+	struct passwd pw, *pwp;
+	char buf[512];
+	int buflen = 512;
+
+	(void) getpwnam_r(name, &pw, buf, buflen, &pwp);
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_uname=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getpwnam_r_5=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_uname=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+  tcl_cv_api_getpwnam_r_5=no
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_uname" >&5
-echo "${ECHO_T}$ac_cv_func_uname" >&6
-if test $ac_cv_func_uname = yes; then
-  :
-else
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_UNAME 1
-_ACEOF
-
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getpwnam_r_5" >&5
+$as_echo "$tcl_cv_api_getpwnam_r_5" >&6; }
+    tcl_ok=$tcl_cv_api_getpwnam_r_5
+    if test "$tcl_ok" = yes; then
 
+$as_echo "#define HAVE_GETPWNAM_R_5 1" >>confdefs.h
 
-if test "`uname -s`" = "Darwin" && test "${TCL_THREADS}" = 1 && \
-	test "`uname -r | awk -F. '{print $1}'`" -lt 7; then
-    # prior to Darwin 7, realpath is not threadsafe, so don't
-    # use it when threads are enabled, c.f. bug # 711232
-    ac_cv_func_realpath=no
-fi
-echo "$as_me:$LINENO: checking for realpath" >&5
-echo $ECHO_N "checking for realpath... $ECHO_C" >&6
-if test "${ac_cv_func_realpath+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    else
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for getpwnam_r with 4 args" >&5
+$as_echo_n "checking for getpwnam_r with 4 args... " >&6; }
+if ${tcl_cv_api_getpwnam_r_4+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-/* Define realpath to an innocuous variant, in case <limits.h> declares realpath.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define realpath innocuous_realpath
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char realpath (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef realpath
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char realpath ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_realpath) || defined (__stub___realpath)
-choke me
-#else
-char (*f) () = realpath;
-#endif
-#ifdef __cplusplus
-}
-#endif
+	    #include <sys/types.h>
+	    #include <pwd.h>
 
 int
 main ()
 {
-return f != realpath;
+
+	    char *name;
+	    struct passwd pw;
+	    char buf[512];
+	    int buflen = 512;
+
+	    (void)getpwnam_r(name, &pw, buf, buflen);
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_realpath=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getpwnam_r_4=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_realpath=no
+  tcl_cv_api_getpwnam_r_4=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_realpath" >&5
-echo "${ECHO_T}$ac_cv_func_realpath" >&6
-if test $ac_cv_func_realpath = yes; then
-  :
-else
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getpwnam_r_4" >&5
+$as_echo "$tcl_cv_api_getpwnam_r_4" >&6; }
+	tcl_ok=$tcl_cv_api_getpwnam_r_4
+	if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_REALPATH 1
-_ACEOF
+$as_echo "#define HAVE_GETPWNAM_R_4 1" >>confdefs.h
 
-fi
+	fi
+    fi
+    if test "$tcl_ok" = yes; then
 
+$as_echo "#define HAVE_GETPWNAM_R 1" >>confdefs.h
 
-echo "$as_me:$LINENO: checking for getaddrinfo" >&5
-echo $ECHO_N "checking for getaddrinfo... $ECHO_C" >&6
-if test "${ac_cv_func_getaddrinfo+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define getaddrinfo to an innocuous variant, in case <limits.h> declares getaddrinfo.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define getaddrinfo innocuous_getaddrinfo
+    fi
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char getaddrinfo (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+fi
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+    ac_fn_c_check_func "$LINENO" "getgrgid_r" "ac_cv_func_getgrgid_r"
+if test "x$ac_cv_func_getgrgid_r" = xyes; then :
 
-#undef getaddrinfo
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for getgrgid_r with 5 args" >&5
+$as_echo_n "checking for getgrgid_r with 5 args... " >&6; }
+if ${tcl_cv_api_getgrgid_r_5+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char getaddrinfo ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_getaddrinfo) || defined (__stub___getaddrinfo)
-choke me
-#else
-char (*f) () = getaddrinfo;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+	#include <sys/types.h>
+	#include <grp.h>
 
 int
 main ()
 {
-return f != getaddrinfo;
+
+	gid_t gid;
+	struct group gr, *grp;
+	char buf[512];
+	int buflen = 512;
+
+	(void) getgrgid_r(gid, &gr, buf, buflen, &grp);
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_getaddrinfo=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getgrgid_r_5=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_getaddrinfo=no
+  tcl_cv_api_getgrgid_r_5=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_getaddrinfo" >&5
-echo "${ECHO_T}$ac_cv_func_getaddrinfo" >&6
-if test $ac_cv_func_getaddrinfo = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getgrgid_r_5" >&5
+$as_echo "$tcl_cv_api_getgrgid_r_5" >&6; }
+    tcl_ok=$tcl_cv_api_getgrgid_r_5
+    if test "$tcl_ok" = yes; then
 
-    echo "$as_me:$LINENO: checking for working getaddrinfo" >&5
-echo $ECHO_N "checking for working getaddrinfo... $ECHO_C" >&6
-if test "${tcl_cv_api_getaddrinfo+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+$as_echo "#define HAVE_GETGRGID_R_5 1" >>confdefs.h
+
+    else
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for getgrgid_r with 4 args" >&5
+$as_echo_n "checking for getgrgid_r with 4 args... " >&6; }
+if ${tcl_cv_api_getgrgid_r_4+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	#include <netdb.h>
+	    #include <sys/types.h>
+	    #include <grp.h>
 
 int
 main ()
 {
 
-	const char *name, *port;
-	struct addrinfo *aiPtr, hints;
-	(void)getaddrinfo(name,port, &hints, &aiPtr);
-	(void)freeaddrinfo(aiPtr);
+	    gid_t gid;
+	    struct group gr;
+	    char buf[512];
+	    int buflen = 512;
+
+	    (void)getgrgid_r(gid, &gr, buf, buflen);
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getaddrinfo=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getgrgid_r_4=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_getaddrinfo=no
+  tcl_cv_api_getgrgid_r_4=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getaddrinfo" >&5
-echo "${ECHO_T}$tcl_cv_api_getaddrinfo" >&6
-    tcl_ok=$tcl_cv_api_getaddrinfo
-    if test "$tcl_ok" = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getgrgid_r_4" >&5
+$as_echo "$tcl_cv_api_getgrgid_r_4" >&6; }
+	tcl_ok=$tcl_cv_api_getgrgid_r_4
+	if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETADDRINFO 1
-_ACEOF
+$as_echo "#define HAVE_GETGRGID_R_4 1" >>confdefs.h
 
+	fi
     fi
+    if test "$tcl_ok" = yes; then
 
-fi
-
-
-#--------------------------------------------------------------------
-#	Look for thread-safe variants of some library functions.
-#--------------------------------------------------------------------
-
-if test "${TCL_THREADS}" = 1; then
-    echo "$as_me:$LINENO: checking for getpwuid_r" >&5
-echo $ECHO_N "checking for getpwuid_r... $ECHO_C" >&6
-if test "${ac_cv_func_getpwuid_r+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define getpwuid_r to an innocuous variant, in case <limits.h> declares getpwuid_r.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define getpwuid_r innocuous_getpwuid_r
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char getpwuid_r (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef getpwuid_r
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char getpwuid_r ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_getpwuid_r) || defined (__stub___getpwuid_r)
-choke me
-#else
-char (*f) () = getpwuid_r;
-#endif
-#ifdef __cplusplus
-}
-#endif
+$as_echo "#define HAVE_GETGRGID_R 1" >>confdefs.h
 
-int
-main ()
-{
-return f != getpwuid_r;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_getpwuid_r=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+    fi
 
-ac_cv_func_getpwuid_r=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_getpwuid_r" >&5
-echo "${ECHO_T}$ac_cv_func_getpwuid_r" >&6
-if test $ac_cv_func_getpwuid_r = yes; then
 
-    echo "$as_me:$LINENO: checking for getpwuid_r with 5 args" >&5
-echo $ECHO_N "checking for getpwuid_r with 5 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getpwuid_r_5+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    ac_fn_c_check_func "$LINENO" "getgrnam_r" "ac_cv_func_getgrnam_r"
+if test "x$ac_cv_func_getgrnam_r" = xyes; then :
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for getgrnam_r with 5 args" >&5
+$as_echo_n "checking for getgrnam_r with 5 args... " >&6; }
+if ${tcl_cv_api_getgrnam_r_5+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 	#include <sys/types.h>
-	#include <pwd.h>
+	#include <grp.h>
 
 int
 main ()
 {
 
-	uid_t uid;
-	struct passwd pw, *pwp;
+	char *name;
+	struct group gr, *grp;
 	char buf[512];
 	int buflen = 512;
 
-	(void) getpwuid_r(uid, &pw, buf, buflen, &pwp);
+	(void) getgrnam_r(name, &gr, buf, buflen, &grp);
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getpwuid_r_5=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getgrnam_r_5=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getpwuid_r_5=no
+  tcl_cv_api_getgrnam_r_5=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getpwuid_r_5" >&5
-echo "${ECHO_T}$tcl_cv_api_getpwuid_r_5" >&6
-    tcl_ok=$tcl_cv_api_getpwuid_r_5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getgrnam_r_5" >&5
+$as_echo "$tcl_cv_api_getgrnam_r_5" >&6; }
+    tcl_ok=$tcl_cv_api_getgrnam_r_5
     if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETPWUID_R_5 1
-_ACEOF
+$as_echo "#define HAVE_GETGRNAM_R_5 1" >>confdefs.h
 
     else
-	echo "$as_me:$LINENO: checking for getpwuid_r with 4 args" >&5
-echo $ECHO_N "checking for getpwuid_r with 4 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getpwuid_r_4+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for getgrnam_r with 4 args" >&5
+$as_echo_n "checking for getgrnam_r with 4 args... " >&6; }
+if ${tcl_cv_api_getgrnam_r_4+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 	    #include <sys/types.h>
-	    #include <pwd.h>
+	    #include <grp.h>
 
 int
 main ()
 {
 
-	    uid_t uid;
-	    struct passwd pw;
+	    char *name;
+	    struct group gr;
 	    char buf[512];
 	    int buflen = 512;
 
-	    (void)getpwnam_r(uid, &pw, buf, buflen);
+	    (void)getgrnam_r(name, &gr, buf, buflen);
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getpwuid_r_4=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_getgrnam_r_4=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getpwuid_r_4=no
+  tcl_cv_api_getgrnam_r_4=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getpwuid_r_4" >&5
-echo "${ECHO_T}$tcl_cv_api_getpwuid_r_4" >&6
-	tcl_ok=$tcl_cv_api_getpwuid_r_4
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_getgrnam_r_4" >&5
+$as_echo "$tcl_cv_api_getgrnam_r_4" >&6; }
+	tcl_ok=$tcl_cv_api_getgrnam_r_4
 	if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETPWUID_R_4 1
-_ACEOF
+$as_echo "#define HAVE_GETGRNAM_R_4 1" >>confdefs.h
 
 	fi
     fi
     if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETPWUID_R 1
-_ACEOF
+$as_echo "#define HAVE_GETGRNAM_R 1" >>confdefs.h
 
     fi
 
 fi
 
-    echo "$as_me:$LINENO: checking for getpwnam_r" >&5
-echo $ECHO_N "checking for getpwnam_r... $ECHO_C" >&6
-if test "${ac_cv_func_getpwnam_r+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define getpwnam_r to an innocuous variant, in case <limits.h> declares getpwnam_r.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define getpwnam_r innocuous_getpwnam_r
+    if test "`uname -s`" = "Darwin" && \
+	    test "`uname -r | awk -F. '{print $1}'`" -gt 5; then
+	# Starting with Darwin 6 (Mac OSX 10.2), gethostbyX
+	# are actually MT-safe as they always return pointers
+	# from TSD instead of static storage.
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char getpwnam_r (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+$as_echo "#define HAVE_MTSAFE_GETHOSTBYNAME 1" >>confdefs.h
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
 
-#undef getpwnam_r
+$as_echo "#define HAVE_MTSAFE_GETHOSTBYADDR 1" >>confdefs.h
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char getpwnam_r ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_getpwnam_r) || defined (__stub___getpwnam_r)
-choke me
-#else
-char (*f) () = getpwnam_r;
-#endif
-#ifdef __cplusplus
-}
-#endif
 
-int
-main ()
-{
-return f != getpwnam_r;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_getpwnam_r=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+    elif test "`uname -s`" = "HP-UX" && \
+	      test "`uname -r|sed -e 's|B\.||' -e 's|\..*$||'`" -gt 10; then
+        # Starting with HPUX 11.00 (we believe), gethostbyX
+        # are actually MT-safe as they always return pointers
+	# from TSD instead of static storage.
 
-ac_cv_func_getpwnam_r=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_getpwnam_r" >&5
-echo "${ECHO_T}$ac_cv_func_getpwnam_r" >&6
-if test $ac_cv_func_getpwnam_r = yes; then
+$as_echo "#define HAVE_MTSAFE_GETHOSTBYNAME 1" >>confdefs.h
+
+
+$as_echo "#define HAVE_MTSAFE_GETHOSTBYADDR 1" >>confdefs.h
+
+
+    else
+	ac_fn_c_check_func "$LINENO" "gethostbyname_r" "ac_cv_func_gethostbyname_r"
+if test "x$ac_cv_func_gethostbyname_r" = xyes; then :
 
-    echo "$as_me:$LINENO: checking for getpwnam_r with 5 args" >&5
-echo $ECHO_N "checking for getpwnam_r with 5 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getpwnam_r_5+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname_r with 6 args" >&5
+$as_echo_n "checking for gethostbyname_r with 6 args... " >&6; }
+if ${tcl_cv_api_gethostbyname_r_6+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	#include <sys/types.h>
-	#include <pwd.h>
+	#include <netdb.h>
 
 int
 main ()
 {
 
 	char *name;
-	struct passwd pw, *pwp;
-	char buf[512];
-	int buflen = 512;
+	struct hostent *he, *res;
+	char buffer[2048];
+	int buflen = 2048;
+	int h_errnop;
 
-	(void) getpwnam_r(name, &pw, buf, buflen, &pwp);
+	(void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop);
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getpwnam_r_5=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_gethostbyname_r_6=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getpwnam_r_5=no
+  tcl_cv_api_gethostbyname_r_6=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getpwnam_r_5" >&5
-echo "${ECHO_T}$tcl_cv_api_getpwnam_r_5" >&6
-    tcl_ok=$tcl_cv_api_getpwnam_r_5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_gethostbyname_r_6" >&5
+$as_echo "$tcl_cv_api_gethostbyname_r_6" >&6; }
+    tcl_ok=$tcl_cv_api_gethostbyname_r_6
     if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETPWNAM_R_5 1
-_ACEOF
+$as_echo "#define HAVE_GETHOSTBYNAME_R_6 1" >>confdefs.h
 
     else
-	echo "$as_me:$LINENO: checking for getpwnam_r with 4 args" >&5
-echo $ECHO_N "checking for getpwnam_r with 4 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getpwnam_r_4+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname_r with 5 args" >&5
+$as_echo_n "checking for gethostbyname_r with 5 args... " >&6; }
+if ${tcl_cv_api_gethostbyname_r_5+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	    #include <sys/types.h>
-	    #include <pwd.h>
+	    #include <netdb.h>
 
 int
 main ()
 {
 
 	    char *name;
-	    struct passwd pw;
-	    char buf[512];
-	    int buflen = 512;
+	    struct hostent *he;
+	    char buffer[2048];
+	    int buflen = 2048;
+	    int h_errnop;
 
-	    (void)getpwnam_r(name, &pw, buf, buflen);
+	    (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop);
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getpwnam_r_4=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_gethostbyname_r_5=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getpwnam_r_4=no
+  tcl_cv_api_gethostbyname_r_5=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getpwnam_r_4" >&5
-echo "${ECHO_T}$tcl_cv_api_getpwnam_r_4" >&6
-	tcl_ok=$tcl_cv_api_getpwnam_r_4
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_gethostbyname_r_5" >&5
+$as_echo "$tcl_cv_api_gethostbyname_r_5" >&6; }
+	tcl_ok=$tcl_cv_api_gethostbyname_r_5
 	if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETPWNAM_R_4 1
-_ACEOF
-
-	fi
-    fi
-    if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETPWNAM_R 1
-_ACEOF
-
-    fi
-
-fi
+$as_echo "#define HAVE_GETHOSTBYNAME_R_5 1" >>confdefs.h
 
-    echo "$as_me:$LINENO: checking for getgrgid_r" >&5
-echo $ECHO_N "checking for getgrgid_r... $ECHO_C" >&6
-if test "${ac_cv_func_getgrgid_r+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	else
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname_r with 3 args" >&5
+$as_echo_n "checking for gethostbyname_r with 3 args... " >&6; }
+if ${tcl_cv_api_gethostbyname_r_3+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define getgrgid_r to an innocuous variant, in case <limits.h> declares getgrgid_r.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define getgrgid_r innocuous_getgrgid_r
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char getgrgid_r (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
 
-#undef getgrgid_r
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char getgrgid_r ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_getgrgid_r) || defined (__stub___getgrgid_r)
-choke me
-#else
-char (*f) () = getgrgid_r;
-#endif
-#ifdef __cplusplus
-}
-#endif
+		#include <netdb.h>
 
 int
 main ()
 {
-return f != getgrgid_r;
+
+		char *name;
+		struct hostent *he;
+		struct hostent_data data;
+
+		(void) gethostbyname_r(name, he, &data);
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_getgrgid_r=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_gethostbyname_r_3=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_getgrgid_r=no
+  tcl_cv_api_gethostbyname_r_3=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_gethostbyname_r_3" >&5
+$as_echo "$tcl_cv_api_gethostbyname_r_3" >&6; }
+	    tcl_ok=$tcl_cv_api_gethostbyname_r_3
+	    if test "$tcl_ok" = yes; then
+
+$as_echo "#define HAVE_GETHOSTBYNAME_R_3 1" >>confdefs.h
+
+	    fi
+	fi
+    fi
+    if test "$tcl_ok" = yes; then
+
+$as_echo "#define HAVE_GETHOSTBYNAME_R 1" >>confdefs.h
+
+    fi
+
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_getgrgid_r" >&5
-echo "${ECHO_T}$ac_cv_func_getgrgid_r" >&6
-if test $ac_cv_func_getgrgid_r = yes; then
 
-    echo "$as_me:$LINENO: checking for getgrgid_r with 5 args" >&5
-echo $ECHO_N "checking for getgrgid_r with 5 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getgrgid_r_5+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	ac_fn_c_check_func "$LINENO" "gethostbyaddr_r" "ac_cv_func_gethostbyaddr_r"
+if test "x$ac_cv_func_gethostbyaddr_r" = xyes; then :
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyaddr_r with 7 args" >&5
+$as_echo_n "checking for gethostbyaddr_r with 7 args... " >&6; }
+if ${tcl_cv_api_gethostbyaddr_r_7+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	#include <sys/types.h>
-	#include <grp.h>
+	#include <netdb.h>
 
 int
 main ()
 {
 
-	gid_t gid;
-	struct group gr, *grp;
-	char buf[512];
-	int buflen = 512;
+	char *addr;
+	int length;
+	int type;
+	struct hostent *result;
+	char buffer[2048];
+	int buflen = 2048;
+	int h_errnop;
 
-	(void) getgrgid_r(gid, &gr, buf, buflen, &grp);
+	(void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
+			       &h_errnop);
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getgrgid_r_5=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_gethostbyaddr_r_7=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getgrgid_r_5=no
+  tcl_cv_api_gethostbyaddr_r_7=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getgrgid_r_5" >&5
-echo "${ECHO_T}$tcl_cv_api_getgrgid_r_5" >&6
-    tcl_ok=$tcl_cv_api_getgrgid_r_5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_gethostbyaddr_r_7" >&5
+$as_echo "$tcl_cv_api_gethostbyaddr_r_7" >&6; }
+    tcl_ok=$tcl_cv_api_gethostbyaddr_r_7
     if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETGRGID_R_5 1
-_ACEOF
+$as_echo "#define HAVE_GETHOSTBYADDR_R_7 1" >>confdefs.h
 
     else
-	echo "$as_me:$LINENO: checking for getgrgid_r with 4 args" >&5
-echo $ECHO_N "checking for getgrgid_r with 4 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getgrgid_r_4+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyaddr_r with 8 args" >&5
+$as_echo_n "checking for gethostbyaddr_r with 8 args... " >&6; }
+if ${tcl_cv_api_gethostbyaddr_r_8+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	    #include <sys/types.h>
-	    #include <grp.h>
+	    #include <netdb.h>
 
 int
 main ()
 {
 
-	    gid_t gid;
-	    struct group gr;
-	    char buf[512];
-	    int buflen = 512;
+	    char *addr;
+	    int length;
+	    int type;
+	    struct hostent *result, *resultp;
+	    char buffer[2048];
+	    int buflen = 2048;
+	    int h_errnop;
 
-	    (void)getgrgid_r(gid, &gr, buf, buflen);
+	    (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
+				   &resultp, &h_errnop);
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getgrgid_r_4=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_api_gethostbyaddr_r_8=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getgrgid_r_4=no
+  tcl_cv_api_gethostbyaddr_r_8=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getgrgid_r_4" >&5
-echo "${ECHO_T}$tcl_cv_api_getgrgid_r_4" >&6
-	tcl_ok=$tcl_cv_api_getgrgid_r_4
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_gethostbyaddr_r_8" >&5
+$as_echo "$tcl_cv_api_gethostbyaddr_r_8" >&6; }
+	tcl_ok=$tcl_cv_api_gethostbyaddr_r_8
 	if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETGRGID_R_4 1
-_ACEOF
+$as_echo "#define HAVE_GETHOSTBYADDR_R_8 1" >>confdefs.h
 
 	fi
     fi
     if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETGRGID_R 1
-_ACEOF
+$as_echo "#define HAVE_GETHOSTBYADDR_R 1" >>confdefs.h
 
     fi
 
 fi
 
-    echo "$as_me:$LINENO: checking for getgrnam_r" >&5
-echo $ECHO_N "checking for getgrnam_r... $ECHO_C" >&6
-if test "${ac_cv_func_getgrnam_r+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+    fi
+fi
+
+#---------------------------------------------------------------------------
+#	Determine which interface to use to talk to the serial port.
+#	Note that #include lines must begin in leftmost column for
+#	some compilers to recognize them as preprocessor directives.
+#---------------------------------------------------------------------------
+
+
+    for ac_header in sys/modem.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "sys/modem.h" "ac_cv_header_sys_modem_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_modem_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_SYS_MODEM_H 1
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define getgrnam_r to an innocuous variant, in case <limits.h> declares getgrnam_r.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define getgrnam_r innocuous_getgrnam_r
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char getgrnam_r (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+fi
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+done
 
-#undef getgrnam_r
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking termios vs. termio vs. sgtty" >&5
+$as_echo_n "checking termios vs. termio vs. sgtty... " >&6; }
+if ${tcl_cv_api_serial+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char getgrnam_r ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_getgrnam_r) || defined (__stub___getgrnam_r)
-choke me
-#else
-char (*f) () = getgrnam_r;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    if test "$cross_compiling" = yes; then :
+  tcl_cv_api_serial=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
-int
-main ()
-{
-return f != getgrnam_r;
-  ;
-  return 0;
+#include <termios.h>
+
+int main() {
+    struct termios t;
+    if (tcgetattr(0, &t) == 0) {
+	cfsetospeed(&t, 0);
+	t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
+	return 0;
+    }
+    return 1;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_getgrnam_r=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_api_serial=termios
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_getgrnam_r=no
+  tcl_cv_api_serial=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_getgrnam_r" >&5
-echo "${ECHO_T}$ac_cv_func_getgrnam_r" >&6
-if test $ac_cv_func_getgrnam_r = yes; then
 
-    echo "$as_me:$LINENO: checking for getgrnam_r with 5 args" >&5
-echo $ECHO_N "checking for getgrnam_r with 5 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getgrnam_r_5+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if test $tcl_cv_api_serial = no ; then
+	if test "$cross_compiling" = yes; then :
+  tcl_cv_api_serial=no
 else
-
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	#include <sys/types.h>
-	#include <grp.h>
-
-int
-main ()
-{
-
-	char *name;
-	struct group gr, *grp;
-	char buf[512];
-	int buflen = 512;
-
-	(void) getgrnam_r(name, &gr, buf, buflen, &grp);
+#include <termio.h>
 
-  ;
-  return 0;
+int main() {
+    struct termio t;
+    if (ioctl(0, TCGETA, &t) == 0) {
+	t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
+	return 0;
+    }
+    return 1;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getgrnam_r_5=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_api_serial=termio
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getgrnam_r_5=no
+  tcl_cv_api_serial=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getgrnam_r_5" >&5
-echo "${ECHO_T}$tcl_cv_api_getgrnam_r_5" >&6
-    tcl_ok=$tcl_cv_api_getgrnam_r_5
-    if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETGRNAM_R_5 1
-_ACEOF
-
-    else
-	echo "$as_me:$LINENO: checking for getgrnam_r with 4 args" >&5
-echo $ECHO_N "checking for getgrnam_r with 4 args... $ECHO_C" >&6
-if test "${tcl_cv_api_getgrnam_r_4+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    fi
+    if test $tcl_cv_api_serial = no ; then
+	if test "$cross_compiling" = yes; then :
+  tcl_cv_api_serial=no
 else
-
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	    #include <sys/types.h>
-	    #include <grp.h>
-
-int
-main ()
-{
-
-	    char *name;
-	    struct group gr;
-	    char buf[512];
-	    int buflen = 512;
-
-	    (void)getgrnam_r(name, &gr, buf, buflen);
+#include <sgtty.h>
 
-  ;
-  return 0;
+int main() {
+    struct sgttyb t;
+    if (ioctl(0, TIOCGETP, &t) == 0) {
+	t.sg_ospeed = 0;
+	t.sg_flags |= ODDP | EVENP | RAW;
+	return 0;
+    }
+    return 1;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_getgrnam_r_4=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_api_serial=sgtty
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_getgrnam_r_4=no
+  tcl_cv_api_serial=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_getgrnam_r_4" >&5
-echo "${ECHO_T}$tcl_cv_api_getgrnam_r_4" >&6
-	tcl_ok=$tcl_cv_api_getgrnam_r_4
-	if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETGRNAM_R_4 1
-_ACEOF
-
-	fi
-    fi
-    if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETGRNAM_R 1
-_ACEOF
 
     fi
-
-fi
-
-    if test "`uname -s`" = "Darwin" && \
-	    test "`uname -r | awk -F. '{print $1}'`" -gt 5; then
-	# Starting with Darwin 6 (Mac OSX 10.2), gethostbyX
-	# are actually MT-safe as they always return pointers
-	# from TSD instead of static storage.
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_MTSAFE_GETHOSTBYNAME 1
-_ACEOF
-
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_MTSAFE_GETHOSTBYADDR 1
-_ACEOF
-
-
-    elif test "`uname -s`" = "HP-UX" && \
-	      test "`uname -r|sed -e 's|B\.||' -e 's|\..*$||'`" -gt 10; then
-        # Starting with HPUX 11.00 (we believe), gethostbyX
-        # are actually MT-safe as they always return pointers
-	# from TSD instead of static storage.
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_MTSAFE_GETHOSTBYNAME 1
-_ACEOF
-
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_MTSAFE_GETHOSTBYADDR 1
-_ACEOF
-
-
-    else
-	echo "$as_me:$LINENO: checking for gethostbyname_r" >&5
-echo $ECHO_N "checking for gethostbyname_r... $ECHO_C" >&6
-if test "${ac_cv_func_gethostbyname_r+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if test $tcl_cv_api_serial = no ; then
+	if test "$cross_compiling" = yes; then :
+  tcl_cv_api_serial=no
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-/* Define gethostbyname_r to an innocuous variant, in case <limits.h> declares gethostbyname_r.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define gethostbyname_r innocuous_gethostbyname_r
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char gethostbyname_r (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
 
-#undef gethostbyname_r
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char gethostbyname_r ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_gethostbyname_r) || defined (__stub___gethostbyname_r)
-choke me
-#else
-char (*f) () = gethostbyname_r;
-#endif
-#ifdef __cplusplus
-}
-#endif
+#include <termios.h>
+#include <errno.h>
 
-int
-main ()
-{
-return f != gethostbyname_r;
-  ;
-  return 0;
+int main() {
+    struct termios t;
+    if (tcgetattr(0, &t) == 0
+	|| errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
+	cfsetospeed(&t, 0);
+	t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
+	return 0;
+    }
+    return 1;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_gethostbyname_r=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_api_serial=termios
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_gethostbyname_r=no
+  tcl_cv_api_serial=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_gethostbyname_r" >&5
-echo "${ECHO_T}$ac_cv_func_gethostbyname_r" >&6
-if test $ac_cv_func_gethostbyname_r = yes; then
 
-    echo "$as_me:$LINENO: checking for gethostbyname_r with 6 args" >&5
-echo $ECHO_N "checking for gethostbyname_r with 6 args... $ECHO_C" >&6
-if test "${tcl_cv_api_gethostbyname_r_6+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    fi
+    if test $tcl_cv_api_serial = no; then
+	if test "$cross_compiling" = yes; then :
+  tcl_cv_api_serial=no
 else
-
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	#include <netdb.h>
-
-int
-main ()
-{
-
-	char *name;
-	struct hostent *he, *res;
-	char buffer[2048];
-	int buflen = 2048;
-	int h_errnop;
-
-	(void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop);
+#include <termio.h>
+#include <errno.h>
 
-  ;
-  return 0;
-}
+int main() {
+    struct termio t;
+    if (ioctl(0, TCGETA, &t) == 0
+	|| errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
+	t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
+	return 0;
+    }
+    return 1;
+    }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_gethostbyname_r_6=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_api_serial=termio
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_gethostbyname_r_6=no
+  tcl_cv_api_serial=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_gethostbyname_r_6" >&5
-echo "${ECHO_T}$tcl_cv_api_gethostbyname_r_6" >&6
-    tcl_ok=$tcl_cv_api_gethostbyname_r_6
-    if test "$tcl_ok" = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETHOSTBYNAME_R_6 1
-_ACEOF
-
-    else
-	echo "$as_me:$LINENO: checking for gethostbyname_r with 5 args" >&5
-echo $ECHO_N "checking for gethostbyname_r with 5 args... $ECHO_C" >&6
-if test "${tcl_cv_api_gethostbyname_r_5+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    fi
+    if test $tcl_cv_api_serial = no; then
+	if test "$cross_compiling" = yes; then :
+  tcl_cv_api_serial=none
 else
-
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-	    #include <netdb.h>
-
-int
-main ()
-{
-
-	    char *name;
-	    struct hostent *he;
-	    char buffer[2048];
-	    int buflen = 2048;
-	    int h_errnop;
-
-	    (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop);
+#include <sgtty.h>
+#include <errno.h>
 
-  ;
-  return 0;
+int main() {
+    struct sgttyb t;
+    if (ioctl(0, TIOCGETP, &t) == 0
+	|| errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
+	t.sg_ospeed = 0;
+	t.sg_flags |= ODDP | EVENP | RAW;
+	return 0;
+    }
+    return 1;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_gethostbyname_r_5=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_api_serial=sgtty
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_gethostbyname_r_5=no
+  tcl_cv_api_serial=none
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_gethostbyname_r_5" >&5
-echo "${ECHO_T}$tcl_cv_api_gethostbyname_r_5" >&6
-	tcl_ok=$tcl_cv_api_gethostbyname_r_5
-	if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETHOSTBYNAME_R_5 1
-_ACEOF
-
-	else
-	    echo "$as_me:$LINENO: checking for gethostbyname_r with 3 args" >&5
-echo $ECHO_N "checking for gethostbyname_r with 3 args... $ECHO_C" >&6
-if test "${tcl_cv_api_gethostbyname_r_3+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
 
-		#include <netdb.h>
-
-int
-main ()
-{
-
-		char *name;
-		struct hostent *he;
-		struct hostent_data data;
-
-		(void) gethostbyname_r(name, he, &data);
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_gethostbyname_r_3=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_gethostbyname_r_3=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_gethostbyname_r_3" >&5
-echo "${ECHO_T}$tcl_cv_api_gethostbyname_r_3" >&6
-	    tcl_ok=$tcl_cv_api_gethostbyname_r_3
-	    if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETHOSTBYNAME_R_3 1
-_ACEOF
-
-	    fi
-	fi
-    fi
-    if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETHOSTBYNAME_R 1
-_ACEOF
-
-    fi
-
-fi
-
-	echo "$as_me:$LINENO: checking for gethostbyaddr_r" >&5
-echo $ECHO_N "checking for gethostbyaddr_r... $ECHO_C" >&6
-if test "${ac_cv_func_gethostbyaddr_r+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define gethostbyaddr_r to an innocuous variant, in case <limits.h> declares gethostbyaddr_r.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define gethostbyaddr_r innocuous_gethostbyaddr_r
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char gethostbyaddr_r (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef gethostbyaddr_r
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char gethostbyaddr_r ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_gethostbyaddr_r) || defined (__stub___gethostbyaddr_r)
-choke me
-#else
-char (*f) () = gethostbyaddr_r;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != gethostbyaddr_r;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_gethostbyaddr_r=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_gethostbyaddr_r=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_gethostbyaddr_r" >&5
-echo "${ECHO_T}$ac_cv_func_gethostbyaddr_r" >&6
-if test $ac_cv_func_gethostbyaddr_r = yes; then
-
-    echo "$as_me:$LINENO: checking for gethostbyaddr_r with 7 args" >&5
-echo $ECHO_N "checking for gethostbyaddr_r with 7 args... $ECHO_C" >&6
-if test "${tcl_cv_api_gethostbyaddr_r_7+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-	#include <netdb.h>
-
-int
-main ()
-{
-
-	char *addr;
-	int length;
-	int type;
-	struct hostent *result;
-	char buffer[2048];
-	int buflen = 2048;
-	int h_errnop;
-
-	(void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
-			       &h_errnop);
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_gethostbyaddr_r_7=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_gethostbyaddr_r_7=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_gethostbyaddr_r_7" >&5
-echo "${ECHO_T}$tcl_cv_api_gethostbyaddr_r_7" >&6
-    tcl_ok=$tcl_cv_api_gethostbyaddr_r_7
-    if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETHOSTBYADDR_R_7 1
-_ACEOF
-
-    else
-	echo "$as_me:$LINENO: checking for gethostbyaddr_r with 8 args" >&5
-echo $ECHO_N "checking for gethostbyaddr_r with 8 args... $ECHO_C" >&6
-if test "${tcl_cv_api_gethostbyaddr_r_8+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-	    #include <netdb.h>
-
-int
-main ()
-{
-
-	    char *addr;
-	    int length;
-	    int type;
-	    struct hostent *result, *resultp;
-	    char buffer[2048];
-	    int buflen = 2048;
-	    int h_errnop;
-
-	    (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
-				   &resultp, &h_errnop);
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_gethostbyaddr_r_8=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_gethostbyaddr_r_8=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_gethostbyaddr_r_8" >&5
-echo "${ECHO_T}$tcl_cv_api_gethostbyaddr_r_8" >&6
-	tcl_ok=$tcl_cv_api_gethostbyaddr_r_8
-	if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETHOSTBYADDR_R_8 1
-_ACEOF
-
-	fi
-    fi
-    if test "$tcl_ok" = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_GETHOSTBYADDR_R 1
-_ACEOF
-
-    fi
-
-fi
-
-    fi
-fi
-
-#---------------------------------------------------------------------------
-#	Determine which interface to use to talk to the serial port.
-#	Note that #include lines must begin in leftmost column for
-#	some compilers to recognize them as preprocessor directives.
-#---------------------------------------------------------------------------
-
-
-
-for ac_header in sys/modem.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  eval "$as_ac_Header=\$ac_header_preproc"
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-
-fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-_ACEOF
-
-fi
-
-done
-
-    echo "$as_me:$LINENO: checking termios vs. termio vs. sgtty" >&5
-echo $ECHO_N "checking termios vs. termio vs. sgtty... $ECHO_C" >&6
-if test "${tcl_cv_api_serial+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-    if test "$cross_compiling" = yes; then
-  tcl_cv_api_serial=no
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-#include <termios.h>
-
-int main() {
-    struct termios t;
-    if (tcgetattr(0, &t) == 0) {
-	cfsetospeed(&t, 0);
-	t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
-	return 0;
-    }
-    return 1;
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_serial=termios
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_api_serial=no
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-    if test $tcl_cv_api_serial = no ; then
-	if test "$cross_compiling" = yes; then
-  tcl_cv_api_serial=no
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-#include <termio.h>
-
-int main() {
-    struct termio t;
-    if (ioctl(0, TCGETA, &t) == 0) {
-	t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
-	return 0;
-    }
-    return 1;
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_serial=termio
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_api_serial=no
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-    fi
-    if test $tcl_cv_api_serial = no ; then
-	if test "$cross_compiling" = yes; then
-  tcl_cv_api_serial=no
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-#include <sgtty.h>
-
-int main() {
-    struct sgttyb t;
-    if (ioctl(0, TIOCGETP, &t) == 0) {
-	t.sg_ospeed = 0;
-	t.sg_flags |= ODDP | EVENP | RAW;
-	return 0;
-    }
-    return 1;
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_serial=sgtty
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_api_serial=no
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-    fi
-    if test $tcl_cv_api_serial = no ; then
-	if test "$cross_compiling" = yes; then
-  tcl_cv_api_serial=no
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-#include <termios.h>
-#include <errno.h>
-
-int main() {
-    struct termios t;
-    if (tcgetattr(0, &t) == 0
-	|| errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
-	cfsetospeed(&t, 0);
-	t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
-	return 0;
-    }
-    return 1;
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_serial=termios
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_api_serial=no
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-    fi
-    if test $tcl_cv_api_serial = no; then
-	if test "$cross_compiling" = yes; then
-  tcl_cv_api_serial=no
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-#include <termio.h>
-#include <errno.h>
-
-int main() {
-    struct termio t;
-    if (ioctl(0, TCGETA, &t) == 0
-	|| errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
-	t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
-	return 0;
-    }
-    return 1;
-    }
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_serial=termio
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_api_serial=no
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-    fi
-    if test $tcl_cv_api_serial = no; then
-	if test "$cross_compiling" = yes; then
-  tcl_cv_api_serial=none
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-#include <sgtty.h>
-#include <errno.h>
-
-int main() {
-    struct sgttyb t;
-    if (ioctl(0, TIOCGETP, &t) == 0
-	|| errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
-	t.sg_ospeed = 0;
-	t.sg_flags |= ODDP | EVENP | RAW;
-	return 0;
-    }
-    return 1;
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_api_serial=sgtty
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_api_serial=none
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-    fi
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_serial" >&5
-echo "${ECHO_T}$tcl_cv_api_serial" >&6
-    case $tcl_cv_api_serial in
-	termios)
-cat >>confdefs.h <<\_ACEOF
-#define USE_TERMIOS 1
-_ACEOF
-;;
-	termio)
-cat >>confdefs.h <<\_ACEOF
-#define USE_TERMIO 1
-_ACEOF
-;;
-	sgtty)
-cat >>confdefs.h <<\_ACEOF
-#define USE_SGTTY 1
-_ACEOF
-;;
-    esac
-
-
-#--------------------------------------------------------------------
-#	Include sys/select.h if it exists and if it supplies things
-#	that appear to be useful and aren't already in sys/types.h.
-#	This appears to be true only on the RS/6000 under AIX.  Some
-#	systems like OSF/1 have a sys/select.h that's of no use, and
-#	other systems like SCO UNIX have a sys/select.h that's
-#	pernicious.  If "fd_set" isn't defined anywhere then set a
-#	special flag.
-#--------------------------------------------------------------------
-
-echo "$as_me:$LINENO: checking for fd_set in sys/types" >&5
-echo $ECHO_N "checking for fd_set in sys/types... $ECHO_C" >&6
-if test "${tcl_cv_type_fd_set+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <sys/types.h>
-int
-main ()
-{
-fd_set readMask, writeMask;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_type_fd_set=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_type_fd_set=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_type_fd_set" >&5
-echo "${ECHO_T}$tcl_cv_type_fd_set" >&6
-tcl_ok=$tcl_cv_type_fd_set
-if test $tcl_ok = no; then
-    echo "$as_me:$LINENO: checking for fd_mask in sys/select" >&5
-echo $ECHO_N "checking for fd_mask in sys/select... $ECHO_C" >&6
-if test "${tcl_cv_grep_fd_mask+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <sys/select.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "fd_mask" >/dev/null 2>&1; then
-  tcl_cv_grep_fd_mask=present
-else
-  tcl_cv_grep_fd_mask=missing
-fi
-rm -f conftest*
-
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_grep_fd_mask" >&5
-echo "${ECHO_T}$tcl_cv_grep_fd_mask" >&6
-    if test $tcl_cv_grep_fd_mask = present; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_SYS_SELECT_H 1
-_ACEOF
-
-	tcl_ok=yes
-    fi
-fi
-if test $tcl_ok = no; then
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_FD_SET 1
-_ACEOF
-
-fi
-
-#------------------------------------------------------------------------------
-#       Find out all about time handling differences.
-#------------------------------------------------------------------------------
-
-
-
-for ac_header in sys/time.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  eval "$as_ac_Header=\$ac_header_preproc"
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-
-fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-_ACEOF
-
-fi
-
-done
-
-    echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
-echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
-if test "${ac_cv_header_time+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <sys/types.h>
-#include <sys/time.h>
-#include <time.h>
-
-int
-main ()
-{
-if ((struct tm *) 0)
-return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_header_time=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_header_time=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
-echo "${ECHO_T}$ac_cv_header_time" >&6
-if test $ac_cv_header_time = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define TIME_WITH_SYS_TIME 1
-_ACEOF
-
-fi
-
-
-
-
-
-for ac_func in gmtime_r localtime_r mktime
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef $ac_func
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != $ac_func;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-_ACEOF
-
-fi
-done
-
-
-    echo "$as_me:$LINENO: checking tm_tzadj in struct tm" >&5
-echo $ECHO_N "checking tm_tzadj in struct tm... $ECHO_C" >&6
-if test "${tcl_cv_member_tm_tzadj+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <time.h>
-int
-main ()
-{
-struct tm tm; tm.tm_tzadj;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_member_tm_tzadj=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_member_tm_tzadj=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_member_tm_tzadj" >&5
-echo "${ECHO_T}$tcl_cv_member_tm_tzadj" >&6
-    if test $tcl_cv_member_tm_tzadj = yes ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_TM_TZADJ 1
-_ACEOF
-
-    fi
-
-    echo "$as_me:$LINENO: checking tm_gmtoff in struct tm" >&5
-echo $ECHO_N "checking tm_gmtoff in struct tm... $ECHO_C" >&6
-if test "${tcl_cv_member_tm_gmtoff+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <time.h>
-int
-main ()
-{
-struct tm tm; tm.tm_gmtoff;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_member_tm_gmtoff=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_member_tm_gmtoff=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_member_tm_gmtoff" >&5
-echo "${ECHO_T}$tcl_cv_member_tm_gmtoff" >&6
-    if test $tcl_cv_member_tm_gmtoff = yes ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_TM_GMTOFF 1
-_ACEOF
-
-    fi
-
-    #
-    # Its important to include time.h in this check, as some systems
-    # (like convex) have timezone functions, etc.
-    #
-    echo "$as_me:$LINENO: checking long timezone variable" >&5
-echo $ECHO_N "checking long timezone variable... $ECHO_C" >&6
-if test "${tcl_cv_timezone_long+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <time.h>
-int
-main ()
-{
-extern long timezone;
-	    timezone += 1;
-	    exit (0);
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_timezone_long=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_timezone_long=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_timezone_long" >&5
-echo "${ECHO_T}$tcl_cv_timezone_long" >&6
-    if test $tcl_cv_timezone_long = yes ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_TIMEZONE_VAR 1
-_ACEOF
-
-    else
-	#
-	# On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
-	#
-	echo "$as_me:$LINENO: checking time_t timezone variable" >&5
-echo $ECHO_N "checking time_t timezone variable... $ECHO_C" >&6
-if test "${tcl_cv_timezone_time+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <time.h>
-int
-main ()
-{
-extern time_t timezone;
-		timezone += 1;
-		exit (0);
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_timezone_time=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_timezone_time=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_timezone_time" >&5
-echo "${ECHO_T}$tcl_cv_timezone_time" >&6
-	if test $tcl_cv_timezone_time = yes ; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_TIMEZONE_VAR 1
-_ACEOF
-
-	fi
-    fi
-
-
-#--------------------------------------------------------------------
-#	Some systems (e.g., IRIX 4.0.5) lack some fields in struct stat. But
-#	we might be able to use fstatfs instead. Some systems (OpenBSD?) also
-#	lack blkcnt_t.
-#--------------------------------------------------------------------
-
-if test "$ac_cv_cygwin" != "yes"; then
-echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
-echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
-if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-static struct stat ac_aggr;
-if (ac_aggr.st_blocks)
-return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_member_struct_stat_st_blocks=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-static struct stat ac_aggr;
-if (sizeof ac_aggr.st_blocks)
-return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_member_struct_stat_st_blocks=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_member_struct_stat_st_blocks=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
-echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
-if test $ac_cv_member_struct_stat_st_blocks = yes; then
-
-cat >>confdefs.h <<_ACEOF
-#define HAVE_STRUCT_STAT_ST_BLOCKS 1
-_ACEOF
-
-
-fi
-echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
-echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
-if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-static struct stat ac_aggr;
-if (ac_aggr.st_blksize)
-return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_member_struct_stat_st_blksize=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-static struct stat ac_aggr;
-if (sizeof ac_aggr.st_blksize)
-return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_member_struct_stat_st_blksize=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_member_struct_stat_st_blksize=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
-echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
-if test $ac_cv_member_struct_stat_st_blksize = yes; then
-
-cat >>confdefs.h <<_ACEOF
-#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
-_ACEOF
-
-
-fi
-
-fi
-echo "$as_me:$LINENO: checking for blkcnt_t" >&5
-echo $ECHO_N "checking for blkcnt_t... $ECHO_C" >&6
-if test "${ac_cv_type_blkcnt_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-if ((blkcnt_t *) 0)
-  return 0;
-if (sizeof (blkcnt_t))
-  return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_type_blkcnt_t=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_type_blkcnt_t=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_type_blkcnt_t" >&5
-echo "${ECHO_T}$ac_cv_type_blkcnt_t" >&6
-if test $ac_cv_type_blkcnt_t = yes; then
-
-cat >>confdefs.h <<_ACEOF
-#define HAVE_BLKCNT_T 1
-_ACEOF
-
-
-fi
-
-echo "$as_me:$LINENO: checking for fstatfs" >&5
-echo $ECHO_N "checking for fstatfs... $ECHO_C" >&6
-if test "${ac_cv_func_fstatfs+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define fstatfs to an innocuous variant, in case <limits.h> declares fstatfs.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define fstatfs innocuous_fstatfs
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char fstatfs (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef fstatfs
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char fstatfs ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_fstatfs) || defined (__stub___fstatfs)
-choke me
-#else
-char (*f) () = fstatfs;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != fstatfs;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_fstatfs=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_fstatfs=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_fstatfs" >&5
-echo "${ECHO_T}$ac_cv_func_fstatfs" >&6
-if test $ac_cv_func_fstatfs = yes; then
-  :
-else
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_FSTATFS 1
-_ACEOF
-
-fi
-
-
-#--------------------------------------------------------------------
-#       Some system have no memcmp or it does not work with 8 bit
-#       data, this checks it and add memcmp.o to LIBOBJS if needed
-#--------------------------------------------------------------------
-
-echo "$as_me:$LINENO: checking for working memcmp" >&5
-echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
-if test "${ac_cv_func_memcmp_working+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  if test "$cross_compiling" = yes; then
-  ac_cv_func_memcmp_working=no
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-
-  /* Some versions of memcmp are not 8-bit clean.  */
-  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
-  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
-    exit (1);
-
-  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
-     or more and with at least one buffer not starting on a 4-byte boundary.
-     William Lewis provided this test program.   */
-  {
-    char foo[21];
-    char bar[21];
-    int i;
-    for (i = 0; i < 4; i++)
-      {
-	char *a = foo + i;
-	char *b = bar + i;
-	strcpy (a, "--------01111111");
-	strcpy (b, "--------10000000");
-	if (memcmp (a, b, 16) >= 0)
-	  exit (1);
-      }
-    exit (0);
-  }
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_memcmp_working=yes
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-ac_cv_func_memcmp_working=no
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
-echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
-test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
-    "memcmp.$ac_objext"   | \
-  *" memcmp.$ac_objext"   | \
-    "memcmp.$ac_objext "* | \
-  *" memcmp.$ac_objext "* ) ;;
-  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
-esac
-
-
-
-#--------------------------------------------------------------------
-#       Some system like SunOS 4 and other BSD like systems
-#       have no memmove (we assume they have bcopy instead).
-#       {The replacement define is in compat/string.h}
-#--------------------------------------------------------------------
-
-echo "$as_me:$LINENO: checking for memmove" >&5
-echo $ECHO_N "checking for memmove... $ECHO_C" >&6
-if test "${ac_cv_func_memmove+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define memmove to an innocuous variant, in case <limits.h> declares memmove.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define memmove innocuous_memmove
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char memmove (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef memmove
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char memmove ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_memmove) || defined (__stub___memmove)
-choke me
-#else
-char (*f) () = memmove;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != memmove;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_memmove=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_memmove=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_memmove" >&5
-echo "${ECHO_T}$ac_cv_func_memmove" >&6
-if test $ac_cv_func_memmove = yes; then
-  :
-else
-
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_MEMMOVE 1
-_ACEOF
-
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_STRING_H 1
-_ACEOF
-
-fi
-
-
-#--------------------------------------------------------------------
-#	On some systems strstr is broken: it returns a pointer even
-#	even if the original string is empty.
-#--------------------------------------------------------------------
-
-
-    echo "$as_me:$LINENO: checking for strstr" >&5
-echo $ECHO_N "checking for strstr... $ECHO_C" >&6
-if test "${ac_cv_func_strstr+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define strstr to an innocuous variant, in case <limits.h> declares strstr.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define strstr innocuous_strstr
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char strstr (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef strstr
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strstr ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_strstr) || defined (__stub___strstr)
-choke me
-#else
-char (*f) () = strstr;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != strstr;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_strstr=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_strstr=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_strstr" >&5
-echo "${ECHO_T}$ac_cv_func_strstr" >&6
-if test $ac_cv_func_strstr = yes; then
-  tcl_ok=1
-else
-  tcl_ok=0
-fi
-
-    if test "$tcl_ok" = 1; then
-	echo "$as_me:$LINENO: checking proper strstr implementation" >&5
-echo $ECHO_N "checking proper strstr implementation... $ECHO_C" >&6
-if test "${tcl_cv_strstr_unbroken+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  if test "$cross_compiling" = yes; then
-  tcl_cv_strstr_unbroken=unknown
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-int main() {
-    extern int strstr();
-    exit(strstr("\0test", "test") ? 1 : 0);
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_strstr_unbroken=ok
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_strstr_unbroken=broken
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_strstr_unbroken" >&5
-echo "${ECHO_T}$tcl_cv_strstr_unbroken" >&6
-	if test "$tcl_cv_strstr_unbroken" = "ok"; then
-	    tcl_ok=1
-	else
-	    tcl_ok=0
-	fi
-    fi
-    if test "$tcl_ok" = 0; then
-	case $LIBOBJS in
-    "strstr.$ac_objext"   | \
-  *" strstr.$ac_objext"   | \
-    "strstr.$ac_objext "* | \
-  *" strstr.$ac_objext "* ) ;;
-  *) LIBOBJS="$LIBOBJS strstr.$ac_objext" ;;
-esac
-
-	USE_COMPAT=1
-    fi
-
-
-#--------------------------------------------------------------------
-#	Check for strtoul function.  This is tricky because under some
-#	versions of AIX strtoul returns an incorrect terminator
-#	pointer for the string "0".
-#--------------------------------------------------------------------
-
-
-    echo "$as_me:$LINENO: checking for strtoul" >&5
-echo $ECHO_N "checking for strtoul... $ECHO_C" >&6
-if test "${ac_cv_func_strtoul+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define strtoul to an innocuous variant, in case <limits.h> declares strtoul.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define strtoul innocuous_strtoul
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char strtoul (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef strtoul
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strtoul ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_strtoul) || defined (__stub___strtoul)
-choke me
-#else
-char (*f) () = strtoul;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != strtoul;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_strtoul=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_strtoul=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_strtoul" >&5
-echo "${ECHO_T}$ac_cv_func_strtoul" >&6
-if test $ac_cv_func_strtoul = yes; then
-  tcl_ok=1
-else
-  tcl_ok=0
-fi
-
-    if test "$tcl_ok" = 1; then
-	echo "$as_me:$LINENO: checking proper strtoul implementation" >&5
-echo $ECHO_N "checking proper strtoul implementation... $ECHO_C" >&6
-if test "${tcl_cv_strtoul_unbroken+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  if test "$cross_compiling" = yes; then
-  tcl_cv_strtoul_unbroken=unknown
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-int main() {
-    extern int strtoul();
-    char *term, *string = "0";
-    exit(strtoul(string,&term,0) != 0 || term != string+1);
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_strtoul_unbroken=ok
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_strtoul_unbroken=broken
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_strtoul_unbroken" >&5
-echo "${ECHO_T}$tcl_cv_strtoul_unbroken" >&6
-	if test "$tcl_cv_strtoul_unbroken" = "ok"; then
-	    tcl_ok=1
-	else
-	    tcl_ok=0
-	fi
-    fi
-    if test "$tcl_ok" = 0; then
-	case $LIBOBJS in
-    "strtoul.$ac_objext"   | \
-  *" strtoul.$ac_objext"   | \
-    "strtoul.$ac_objext "* | \
-  *" strtoul.$ac_objext "* ) ;;
-  *) LIBOBJS="$LIBOBJS strtoul.$ac_objext" ;;
-esac
-
-	USE_COMPAT=1
-    fi
-
-
-#--------------------------------------------------------------------
-#	Check for the strtod function.  This is tricky because in some
-#	versions of Linux strtod mis-parses strings starting with "+".
-#--------------------------------------------------------------------
-
-
-    echo "$as_me:$LINENO: checking for strtod" >&5
-echo $ECHO_N "checking for strtod... $ECHO_C" >&6
-if test "${ac_cv_func_strtod+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define strtod to an innocuous variant, in case <limits.h> declares strtod.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define strtod innocuous_strtod
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char strtod (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef strtod
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strtod ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_strtod) || defined (__stub___strtod)
-choke me
-#else
-char (*f) () = strtod;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != strtod;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_strtod=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_strtod=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
-echo "${ECHO_T}$ac_cv_func_strtod" >&6
-if test $ac_cv_func_strtod = yes; then
-  tcl_ok=1
-else
-  tcl_ok=0
-fi
-
-    if test "$tcl_ok" = 1; then
-	echo "$as_me:$LINENO: checking proper strtod implementation" >&5
-echo $ECHO_N "checking proper strtod implementation... $ECHO_C" >&6
-if test "${tcl_cv_strtod_unbroken+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  if test "$cross_compiling" = yes; then
-  tcl_cv_strtod_unbroken=unknown
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-int main() {
-    extern double strtod();
-    char *term, *string = " +69";
-    exit(strtod(string,&term) != 69 || term != string+4);
-}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_strtod_unbroken=ok
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_strtod_unbroken=broken
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_strtod_unbroken" >&5
-echo "${ECHO_T}$tcl_cv_strtod_unbroken" >&6
-	if test "$tcl_cv_strtod_unbroken" = "ok"; then
-	    tcl_ok=1
-	else
-	    tcl_ok=0
-	fi
-    fi
-    if test "$tcl_ok" = 0; then
-	case $LIBOBJS in
-    "strtod.$ac_objext"   | \
-  *" strtod.$ac_objext"   | \
-    "strtod.$ac_objext "* | \
-  *" strtod.$ac_objext "* ) ;;
-  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
-esac
-
-	USE_COMPAT=1
     fi
-
-
-#--------------------------------------------------------------------
-#	Under Solaris 2.4, strtod returns the wrong value for the
-#	terminating character under some conditions.  Check for this
-#	and if the problem exists use a substitute procedure
-#	"fixstrtod" that corrects the error.
-#--------------------------------------------------------------------
-
-
-    echo "$as_me:$LINENO: checking for strtod" >&5
-echo $ECHO_N "checking for strtod... $ECHO_C" >&6
-if test "${ac_cv_func_strtod+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define strtod to an innocuous variant, in case <limits.h> declares strtod.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define strtod innocuous_strtod
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char strtod (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef strtod
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strtod ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_strtod) || defined (__stub___strtod)
-choke me
-#else
-char (*f) () = strtod;
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-int
-main ()
-{
-return f != strtod;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_strtod=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_func_strtod=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
-echo "${ECHO_T}$ac_cv_func_strtod" >&6
-if test $ac_cv_func_strtod = yes; then
-  tcl_strtod=1
-else
-  tcl_strtod=0
-fi
-
-    if test "$tcl_strtod" = 1; then
-	echo "$as_me:$LINENO: checking for Solaris2.4/Tru64 strtod bugs" >&5
-echo $ECHO_N "checking for Solaris2.4/Tru64 strtod bugs... $ECHO_C" >&6
-if test "${tcl_cv_strtod_buggy+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-	    if test "$cross_compiling" = yes; then
-  tcl_cv_strtod_buggy=buggy
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-
-		extern double strtod();
-		int main() {
-		    char *infString="Inf", *nanString="NaN", *spaceString=" ";
-		    char *term;
-		    double value;
-		    value = strtod(infString, &term);
-		    if ((term != infString) && (term[-1] == 0)) {
-			exit(1);
-		    }
-		    value = strtod(nanString, &term);
-		    if ((term != nanString) && (term[-1] == 0)) {
-			exit(1);
-		    }
-		    value = strtod(spaceString, &term);
-		    if (term == (spaceString+1)) {
-			exit(1);
-		    }
-		    exit(0);
-		}
-_ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_strtod_buggy=ok
-else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_strtod_buggy=buggy
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 fi
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_strtod_buggy" >&5
-echo "${ECHO_T}$tcl_cv_strtod_buggy" >&6
-	if test "$tcl_cv_strtod_buggy" = buggy; then
-	    case $LIBOBJS in
-    "fixstrtod.$ac_objext"   | \
-  *" fixstrtod.$ac_objext"   | \
-    "fixstrtod.$ac_objext "* | \
-  *" fixstrtod.$ac_objext "* ) ;;
-  *) LIBOBJS="$LIBOBJS fixstrtod.$ac_objext" ;;
-esac
-
-	    USE_COMPAT=1
-
-cat >>confdefs.h <<\_ACEOF
-#define strtod fixstrtod
-_ACEOF
-
-	fi
-    fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_serial" >&5
+$as_echo "$tcl_cv_api_serial" >&6; }
+    case $tcl_cv_api_serial in
+	termios)
+$as_echo "#define USE_TERMIOS 1" >>confdefs.h
+;;
+	termio)
+$as_echo "#define USE_TERMIO 1" >>confdefs.h
+;;
+	sgtty)
+$as_echo "#define USE_SGTTY 1" >>confdefs.h
+;;
+    esac
 
 
 #--------------------------------------------------------------------
-#	Check for various typedefs and provide substitutes if
-#	they don't exist.
+#	Include sys/select.h if it exists and if it supplies things
+#	that appear to be useful and aren't already in sys/types.h.
+#	This appears to be true only on the RS/6000 under AIX.  Some
+#	systems like OSF/1 have a sys/select.h that's of no use, and
+#	other systems like SCO UNIX have a sys/select.h that's
+#	pernicious.  If "fd_set" isn't defined anywhere then set a
+#	special flag.
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking for mode_t" >&5
-echo $ECHO_N "checking for mode_t... $ECHO_C" >&6
-if test "${ac_cv_type_mode_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-if ((mode_t *) 0)
-  return 0;
-if (sizeof (mode_t))
-  return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_type_mode_t=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_type_mode_t=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_type_mode_t" >&5
-echo "${ECHO_T}$ac_cv_type_mode_t" >&6
-if test $ac_cv_type_mode_t = yes; then
-  :
-else
-
-cat >>confdefs.h <<_ACEOF
-#define mode_t int
-_ACEOF
-
-fi
-
-echo "$as_me:$LINENO: checking for pid_t" >&5
-echo $ECHO_N "checking for pid_t... $ECHO_C" >&6
-if test "${ac_cv_type_pid_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-if ((pid_t *) 0)
-  return 0;
-if (sizeof (pid_t))
-  return 0;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_type_pid_t=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_type_pid_t=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_type_pid_t" >&5
-echo "${ECHO_T}$ac_cv_type_pid_t" >&6
-if test $ac_cv_type_pid_t = yes; then
-  :
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fd_set in sys/types" >&5
+$as_echo_n "checking for fd_set in sys/types... " >&6; }
+if ${tcl_cv_type_fd_set+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-cat >>confdefs.h <<_ACEOF
-#define pid_t int
-_ACEOF
-
-fi
-
-echo "$as_me:$LINENO: checking for size_t" >&5
-echo $ECHO_N "checking for size_t... $ECHO_C" >&6
-if test "${ac_cv_type_size_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
+#include <sys/types.h>
 int
 main ()
 {
-if ((size_t *) 0)
-  return 0;
-if (sizeof (size_t))
-  return 0;
+fd_set readMask, writeMask;
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_type_size_t=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_type_fd_set=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_type_size_t=no
+  tcl_cv_type_fd_set=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
-echo "${ECHO_T}$ac_cv_type_size_t" >&6
-if test $ac_cv_type_size_t = yes; then
-  :
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_type_fd_set" >&5
+$as_echo "$tcl_cv_type_fd_set" >&6; }
+tcl_ok=$tcl_cv_type_fd_set
+if test $tcl_ok = no; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fd_mask in sys/select" >&5
+$as_echo_n "checking for fd_mask in sys/select... " >&6; }
+if ${tcl_cv_grep_fd_mask+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-cat >>confdefs.h <<_ACEOF
-#define size_t unsigned
-_ACEOF
-
-fi
-
-echo "$as_me:$LINENO: checking for uid_t in sys/types.h" >&5
-echo $ECHO_N "checking for uid_t in sys/types.h... $ECHO_C" >&6
-if test "${ac_cv_type_uid_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#include <sys/types.h>
+#include <sys/select.h>
 
 _ACEOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "uid_t" >/dev/null 2>&1; then
-  ac_cv_type_uid_t=yes
+  $EGREP "fd_mask" >/dev/null 2>&1; then :
+  tcl_cv_grep_fd_mask=present
 else
-  ac_cv_type_uid_t=no
+  tcl_cv_grep_fd_mask=missing
 fi
 rm -f conftest*
 
 fi
-echo "$as_me:$LINENO: result: $ac_cv_type_uid_t" >&5
-echo "${ECHO_T}$ac_cv_type_uid_t" >&6
-if test $ac_cv_type_uid_t = no; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_grep_fd_mask" >&5
+$as_echo "$tcl_cv_grep_fd_mask" >&6; }
+    if test $tcl_cv_grep_fd_mask = present; then
 
-cat >>confdefs.h <<\_ACEOF
-#define uid_t int
-_ACEOF
+$as_echo "#define HAVE_SYS_SELECT_H 1" >>confdefs.h
+
+	tcl_ok=yes
+    fi
+fi
+if test $tcl_ok = no; then
+
+$as_echo "#define NO_FD_SET 1" >>confdefs.h
+
+fi
+
+#------------------------------------------------------------------------------
+#       Find out all about time handling differences.
+#------------------------------------------------------------------------------
 
 
-cat >>confdefs.h <<\_ACEOF
-#define gid_t int
+    for ac_header in sys/time.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_time_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_SYS_TIME_H 1
 _ACEOF
 
 fi
 
+done
 
-echo "$as_me:$LINENO: checking for socklen_t" >&5
-echo $ECHO_N "checking for socklen_t... $ECHO_C" >&6
-if test "${tcl_cv_type_socklen_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
+$as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
+if ${ac_cv_header_time+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-
-	#include <sys/types.h>
-	#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
 
 int
 main ()
 {
-
-    	socklen_t foo;
-
+if ((struct tm *) 0)
+return 0;
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_type_socklen_t=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_time=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_type_socklen_t=no
+  ac_cv_header_time=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_type_socklen_t" >&5
-echo "${ECHO_T}$tcl_cv_type_socklen_t" >&6
-if test $tcl_cv_type_socklen_t = no; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
+$as_echo "$ac_cv_header_time" >&6; }
+if test $ac_cv_header_time = yes; then
+
+$as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
+
+fi
+
 
-cat >>confdefs.h <<\_ACEOF
-#define socklen_t int
+    for ac_func in gmtime_r localtime_r mktime
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
 _ACEOF
 
 fi
+done
 
-echo "$as_me:$LINENO: checking for intptr_t" >&5
-echo $ECHO_N "checking for intptr_t... $ECHO_C" >&6
-if test "${ac_cv_type_intptr_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking tm_tzadj in struct tm" >&5
+$as_echo_n "checking tm_tzadj in struct tm... " >&6; }
+if ${tcl_cv_member_tm_tzadj+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
+#include <time.h>
 int
 main ()
 {
-if ((intptr_t *) 0)
-  return 0;
-if (sizeof (intptr_t))
-  return 0;
+struct tm tm; tm.tm_tzadj;
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_type_intptr_t=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_member_tm_tzadj=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_type_intptr_t=no
+  tcl_cv_member_tm_tzadj=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_type_intptr_t" >&5
-echo "${ECHO_T}$ac_cv_type_intptr_t" >&6
-if test $ac_cv_type_intptr_t = yes; then
-
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_member_tm_tzadj" >&5
+$as_echo "$tcl_cv_member_tm_tzadj" >&6; }
+    if test $tcl_cv_member_tm_tzadj = yes ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_INTPTR_T 1
-_ACEOF
+$as_echo "#define HAVE_TM_TZADJ 1" >>confdefs.h
 
-else
+    fi
 
-    echo "$as_me:$LINENO: checking for pointer-size signed integer type" >&5
-echo $ECHO_N "checking for pointer-size signed integer type... $ECHO_C" >&6
-if test "${tcl_cv_intptr_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking tm_gmtoff in struct tm" >&5
+$as_echo_n "checking tm_gmtoff in struct tm... " >&6; }
+if ${tcl_cv_member_tm_gmtoff+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    for tcl_cv_intptr_t in "int" "long" "long long" none; do
-	if test "$tcl_cv_intptr_t" != none; then
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
+#include <time.h>
 int
 main ()
 {
-static int test_array [1 - 2 * !(sizeof (void *) <= sizeof ($tcl_cv_intptr_t))];
-test_array [0] = 0
-
+struct tm tm; tm.tm_gmtoff;
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_ok=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_member_tm_gmtoff=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_ok=no
+  tcl_cv_member_tm_gmtoff=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-	    test "$tcl_ok" = yes && break; fi
-    done
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_intptr_t" >&5
-echo "${ECHO_T}$tcl_cv_intptr_t" >&6
-    if test "$tcl_cv_intptr_t" != none; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_member_tm_gmtoff" >&5
+$as_echo "$tcl_cv_member_tm_gmtoff" >&6; }
+    if test $tcl_cv_member_tm_gmtoff = yes ; then
 
-cat >>confdefs.h <<_ACEOF
-#define intptr_t $tcl_cv_intptr_t
-_ACEOF
+$as_echo "#define HAVE_TM_GMTOFF 1" >>confdefs.h
 
     fi
 
-fi
-
-echo "$as_me:$LINENO: checking for uintptr_t" >&5
-echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
-if test "${ac_cv_type_uintptr_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    #
+    # Its important to include time.h in this check, as some systems
+    # (like convex) have timezone functions, etc.
+    #
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking long timezone variable" >&5
+$as_echo_n "checking long timezone variable... " >&6; }
+if ${tcl_cv_timezone_long+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
+#include <time.h>
 int
 main ()
 {
-if ((uintptr_t *) 0)
-  return 0;
-if (sizeof (uintptr_t))
-  return 0;
+extern long timezone;
+	    timezone += 1;
+	    exit (0);
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_type_uintptr_t=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_timezone_long=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_type_uintptr_t=no
+  tcl_cv_timezone_long=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
-echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
-if test $ac_cv_type_uintptr_t = yes; then
-
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_UINTPTR_T 1
-_ACEOF
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_timezone_long" >&5
+$as_echo "$tcl_cv_timezone_long" >&6; }
+    if test $tcl_cv_timezone_long = yes ; then
 
-else
+$as_echo "#define HAVE_TIMEZONE_VAR 1" >>confdefs.h
 
-    echo "$as_me:$LINENO: checking for pointer-size unsigned integer type" >&5
-echo $ECHO_N "checking for pointer-size unsigned integer type... $ECHO_C" >&6
-if test "${tcl_cv_uintptr_t+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    else
+	#
+	# On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
+	#
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking time_t timezone variable" >&5
+$as_echo_n "checking time_t timezone variable... " >&6; }
+if ${tcl_cv_timezone_time+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    for tcl_cv_uintptr_t in "unsigned int" "unsigned long" "unsigned long long" \
-	    none; do
-	if test "$tcl_cv_uintptr_t" != none; then
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
+#include <time.h>
 int
 main ()
 {
-static int test_array [1 - 2 * !(sizeof (void *) <= sizeof ($tcl_cv_uintptr_t))];
-test_array [0] = 0
-
+extern time_t timezone;
+		timezone += 1;
+		exit (0);
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_ok=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_timezone_time=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_ok=no
+  tcl_cv_timezone_time=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-	    test "$tcl_ok" = yes && break; fi
-    done
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_uintptr_t" >&5
-echo "${ECHO_T}$tcl_cv_uintptr_t" >&6
-    if test "$tcl_cv_uintptr_t" != none; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_timezone_time" >&5
+$as_echo "$tcl_cv_timezone_time" >&6; }
+	if test $tcl_cv_timezone_time = yes ; then
 
-cat >>confdefs.h <<_ACEOF
-#define uintptr_t $tcl_cv_uintptr_t
-_ACEOF
+$as_echo "#define HAVE_TIMEZONE_VAR 1" >>confdefs.h
 
+	fi
     fi
 
-fi
-
 
 #--------------------------------------------------------------------
-#	If a system doesn't have an opendir function (man, that's old!)
-#	then we have to supply a different version of dirent.h which
-#	is compatible with the substitute version of opendir that's
-#	provided.  This version only works with V7-style directories.
+#	Some systems (e.g., IRIX 4.0.5) lack some fields in struct stat. But
+#	we might be able to use fstatfs instead. Some systems (OpenBSD?) also
+#	lack blkcnt_t.
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking for opendir" >&5
-echo $ECHO_N "checking for opendir... $ECHO_C" >&6
-if test "${ac_cv_func_opendir+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+if test "$ac_cv_cygwin" != "yes"; then
+ac_fn_c_check_member "$LINENO" "struct stat" "st_blocks" "ac_cv_member_struct_stat_st_blocks" "$ac_includes_default"
+if test "x$ac_cv_member_struct_stat_st_blocks" = xyes; then :
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_STRUCT_STAT_ST_BLOCKS 1
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define opendir to an innocuous variant, in case <limits.h> declares opendir.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define opendir innocuous_opendir
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char opendir (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+fi
+ac_fn_c_check_member "$LINENO" "struct stat" "st_blksize" "ac_cv_member_struct_stat_st_blksize" "$ac_includes_default"
+if test "x$ac_cv_member_struct_stat_st_blksize" = xyes; then :
 
-#undef opendir
+cat >>confdefs.h <<_ACEOF
+#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
+_ACEOF
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char opendir ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_opendir) || defined (__stub___opendir)
-choke me
-#else
-char (*f) () = opendir;
-#endif
-#ifdef __cplusplus
-}
-#endif
 
-int
-main ()
-{
-return f != opendir;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_opendir=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+fi
 
-ac_cv_func_opendir=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+ac_fn_c_check_type "$LINENO" "blkcnt_t" "ac_cv_type_blkcnt_t" "$ac_includes_default"
+if test "x$ac_cv_type_blkcnt_t" = xyes; then :
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_BLKCNT_T 1
+_ACEOF
+
+
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_opendir" >&5
-echo "${ECHO_T}$ac_cv_func_opendir" >&6
-if test $ac_cv_func_opendir = yes; then
-  :
+
+ac_fn_c_check_func "$LINENO" "fstatfs" "ac_cv_func_fstatfs"
+if test "x$ac_cv_func_fstatfs" = xyes; then :
+
 else
 
-cat >>confdefs.h <<\_ACEOF
-#define USE_DIRENT2_H 1
-_ACEOF
+$as_echo "#define NO_FSTATFS 1" >>confdefs.h
 
 fi
 
 
 #--------------------------------------------------------------------
-#	The check below checks whether <sys/wait.h> defines the type
-#	"union wait" correctly.  It's needed because of weirdness in
-#	HP-UX where "union wait" is defined in both the BSD and SYS-V
-#	environments.  Checking the usability of WIFEXITED seems to do
-#	the trick.
+#       Some system have no memcmp or it does not work with 8 bit
+#       data, this checks it and add memcmp.o to LIBOBJS if needed
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking union wait" >&5
-echo $ECHO_N "checking union wait... $ECHO_C" >&6
-if test "${tcl_cv_union_wait+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working memcmp" >&5
+$as_echo_n "checking for working memcmp... " >&6; }
+if ${ac_cv_func_memcmp_working+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  if test "$cross_compiling" = yes; then :
+  ac_cv_func_memcmp_working=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#include <sys/types.h>
-#include <sys/wait.h>
+$ac_includes_default
 int
 main ()
 {
 
-union wait x;
-WIFEXITED(x);		/* Generates compiler error if WIFEXITED
-			 * uses an int. */
+  /* Some versions of memcmp are not 8-bit clean.  */
+  char c0 = '\100', c1 = '\200', c2 = '\201';
+  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
+    return 1;
+
+  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
+     or more and with at least one buffer not starting on a 4-byte boundary.
+     William Lewis provided this test program.   */
+  {
+    char foo[21];
+    char bar[21];
+    int i;
+    for (i = 0; i < 4; i++)
+      {
+	char *a = foo + i;
+	char *b = bar + i;
+	strcpy (a, "--------01111111");
+	strcpy (b, "--------10000000");
+	if (memcmp (a, b, 16) >= 0)
+	  return 1;
+      }
+    return 0;
+  }
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_union_wait=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_func_memcmp_working=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_union_wait=no
+  ac_cv_func_memcmp_working=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_union_wait" >&5
-echo "${ECHO_T}$tcl_cv_union_wait" >&6
-if test $tcl_cv_union_wait = no; then
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_UNION_WAIT 1
-_ACEOF
 
 fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_memcmp_working" >&5
+$as_echo "$ac_cv_func_memcmp_working" >&6; }
+test $ac_cv_func_memcmp_working = no && case " $LIBOBJS " in
+  *" memcmp.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext"
+ ;;
+esac
+
+
 
 #--------------------------------------------------------------------
-#	Check whether there is an strncasecmp function on this system.
-#	This is a bit tricky because under SCO it's in -lsocket and
-#	under Sequent Dynix it's in -linet.
+#       Some system like SunOS 4 and other BSD like systems
+#       have no memmove (we assume they have bcopy instead).
+#       {The replacement define is in compat/string.h}
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking for strncasecmp" >&5
-echo $ECHO_N "checking for strncasecmp... $ECHO_C" >&6
-if test "${ac_cv_func_strncasecmp+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define strncasecmp to an innocuous variant, in case <limits.h> declares strncasecmp.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define strncasecmp innocuous_strncasecmp
+ac_fn_c_check_func "$LINENO" "memmove" "ac_cv_func_memmove"
+if test "x$ac_cv_func_memmove" = xyes; then :
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char strncasecmp (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
+else
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
 
-#undef strncasecmp
+$as_echo "#define NO_MEMMOVE 1" >>confdefs.h
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strncasecmp ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_strncasecmp) || defined (__stub___strncasecmp)
-choke me
-#else
-char (*f) () = strncasecmp;
-#endif
-#ifdef __cplusplus
-}
-#endif
 
-int
-main ()
-{
-return f != strncasecmp;
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_strncasecmp=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+$as_echo "#define NO_STRING_H 1" >>confdefs.h
 
-ac_cv_func_strncasecmp=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $ac_cv_func_strncasecmp" >&5
-echo "${ECHO_T}$ac_cv_func_strncasecmp" >&6
-if test $ac_cv_func_strncasecmp = yes; then
+
+
+#--------------------------------------------------------------------
+#	On some systems strstr is broken: it returns a pointer even
+#	even if the original string is empty.
+#--------------------------------------------------------------------
+
+
+    ac_fn_c_check_func "$LINENO" "strstr" "ac_cv_func_strstr"
+if test "x$ac_cv_func_strstr" = xyes; then :
   tcl_ok=1
 else
   tcl_ok=0
 fi
 
-if test "$tcl_ok" = 0; then
-    echo "$as_me:$LINENO: checking for strncasecmp in -lsocket" >&5
-echo $ECHO_N "checking for strncasecmp in -lsocket... $ECHO_C" >&6
-if test "${ac_cv_lib_socket_strncasecmp+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if test "$tcl_ok" = 1; then
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking proper strstr implementation" >&5
+$as_echo_n "checking proper strstr implementation... " >&6; }
+if ${tcl_cv_strstr_unbroken+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lsocket  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  if test "$cross_compiling" = yes; then :
+  tcl_cv_strstr_unbroken=unknown
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strncasecmp ();
-int
-main ()
-{
-strncasecmp ();
-  ;
-  return 0;
+int main() {
+    extern int strstr();
+    exit(strstr("\0test", "test") ? 1 : 0);
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_socket_strncasecmp=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_strstr_unbroken=ok
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_socket_strncasecmp=no
+  tcl_cv_strstr_unbroken=broken
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_socket_strncasecmp" >&5
-echo "${ECHO_T}$ac_cv_lib_socket_strncasecmp" >&6
-if test $ac_cv_lib_socket_strncasecmp = yes; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_strstr_unbroken" >&5
+$as_echo "$tcl_cv_strstr_unbroken" >&6; }
+	if test "$tcl_cv_strstr_unbroken" = "ok"; then
+	    tcl_ok=1
+	else
+	    tcl_ok=0
+	fi
+    fi
+    if test "$tcl_ok" = 0; then
+	case " $LIBOBJS " in
+  *" strstr.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS strstr.$ac_objext"
+ ;;
+esac
+
+	USE_COMPAT=1
+    fi
+
+
+#--------------------------------------------------------------------
+#	Check for strtoul function.  This is tricky because under some
+#	versions of AIX strtoul returns an incorrect terminator
+#	pointer for the string "0".
+#--------------------------------------------------------------------
+
+
+    ac_fn_c_check_func "$LINENO" "strtoul" "ac_cv_func_strtoul"
+if test "x$ac_cv_func_strtoul" = xyes; then :
   tcl_ok=1
 else
   tcl_ok=0
 fi
 
-fi
-if test "$tcl_ok" = 0; then
-    echo "$as_me:$LINENO: checking for strncasecmp in -linet" >&5
-echo $ECHO_N "checking for strncasecmp in -linet... $ECHO_C" >&6
-if test "${ac_cv_lib_inet_strncasecmp+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if test "$tcl_ok" = 1; then
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking proper strtoul implementation" >&5
+$as_echo_n "checking proper strtoul implementation... " >&6; }
+if ${tcl_cv_strtoul_unbroken+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-linet  $LIBS"
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  if test "$cross_compiling" = yes; then :
+  tcl_cv_strtoul_unbroken=unknown
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char strncasecmp ();
-int
-main ()
-{
-strncasecmp ();
-  ;
-  return 0;
+int main() {
+    extern int strtoul();
+    char *term, *string = "0";
+    exit(strtoul(string,&term,0) != 0 || term != string+1);
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_lib_inet_strncasecmp=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_strtoul_unbroken=ok
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_cv_lib_inet_strncasecmp=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+  tcl_cv_strtoul_unbroken=broken
 fi
-echo "$as_me:$LINENO: result: $ac_cv_lib_inet_strncasecmp" >&5
-echo "${ECHO_T}$ac_cv_lib_inet_strncasecmp" >&6
-if test $ac_cv_lib_inet_strncasecmp = yes; then
-  tcl_ok=1
-else
-  tcl_ok=0
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
 
 fi
-if test "$tcl_ok" = 0; then
-    case $LIBOBJS in
-    "strncasecmp.$ac_objext"   | \
-  *" strncasecmp.$ac_objext"   | \
-    "strncasecmp.$ac_objext "* | \
-  *" strncasecmp.$ac_objext "* ) ;;
-  *) LIBOBJS="$LIBOBJS strncasecmp.$ac_objext" ;;
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_strtoul_unbroken" >&5
+$as_echo "$tcl_cv_strtoul_unbroken" >&6; }
+	if test "$tcl_cv_strtoul_unbroken" = "ok"; then
+	    tcl_ok=1
+	else
+	    tcl_ok=0
+	fi
+    fi
+    if test "$tcl_ok" = 0; then
+	case " $LIBOBJS " in
+  *" strtoul.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS strtoul.$ac_objext"
+ ;;
 esac
 
-    USE_COMPAT=1
-fi
+	USE_COMPAT=1
+    fi
+
 
 #--------------------------------------------------------------------
-#	The code below deals with several issues related to gettimeofday:
-#	1. Some systems don't provide a gettimeofday function at all
-#	   (set NO_GETTOD if this is the case).
-#	2. See if gettimeofday is declared in the <sys/time.h> header file.
-#	   if not, set the GETTOD_NOT_DECLARED flag so that tclPort.h can
-#	   declare it.
+#	Check for the strtod function.  This is tricky because in some
+#	versions of Linux strtod mis-parses strings starting with "+".
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking for gettimeofday" >&5
-echo $ECHO_N "checking for gettimeofday... $ECHO_C" >&6
-if test "${ac_cv_func_gettimeofday+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define gettimeofday to an innocuous variant, in case <limits.h> declares gettimeofday.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define gettimeofday innocuous_gettimeofday
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char gettimeofday (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef gettimeofday
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char gettimeofday ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_gettimeofday) || defined (__stub___gettimeofday)
-choke me
-#else
-char (*f) () = gettimeofday;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    ac_fn_c_check_func "$LINENO" "strtod" "ac_cv_func_strtod"
+if test "x$ac_cv_func_strtod" = xyes; then :
+  tcl_ok=1
+else
+  tcl_ok=0
+fi
 
-int
-main ()
-{
-return f != gettimeofday;
-  ;
-  return 0;
+    if test "$tcl_ok" = 1; then
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking proper strtod implementation" >&5
+$as_echo_n "checking proper strtod implementation... " >&6; }
+if ${tcl_cv_strtod_unbroken+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  tcl_cv_strtod_unbroken=unknown
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+int main() {
+    extern double strtod();
+    char *term, *string = " +69";
+    exit(strtod(string,&term) != 69 || term != string+4);
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_func_gettimeofday=yes
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_strtod_unbroken=ok
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+  tcl_cv_strtod_unbroken=broken
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_strtod_unbroken" >&5
+$as_echo "$tcl_cv_strtod_unbroken" >&6; }
+	if test "$tcl_cv_strtod_unbroken" = "ok"; then
+	    tcl_ok=1
+	else
+	    tcl_ok=0
+	fi
+    fi
+    if test "$tcl_ok" = 0; then
+	case " $LIBOBJS " in
+  *" strtod.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
+ ;;
+esac
 
-ac_cv_func_gettimeofday=no
-fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_func_gettimeofday" >&5
-echo "${ECHO_T}$ac_cv_func_gettimeofday" >&6
-if test $ac_cv_func_gettimeofday = yes; then
-  :
-else
+	USE_COMPAT=1
+    fi
 
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_GETTOD 1
-_ACEOF
+#--------------------------------------------------------------------
+#	Under Solaris 2.4, strtod returns the wrong value for the
+#	terminating character under some conditions.  Check for this
+#	and if the problem exists use a substitute procedure
+#	"fixstrtod" that corrects the error.
+#--------------------------------------------------------------------
 
 
+    ac_fn_c_check_func "$LINENO" "strtod" "ac_cv_func_strtod"
+if test "x$ac_cv_func_strtod" = xyes; then :
+  tcl_strtod=1
+else
+  tcl_strtod=0
 fi
 
-echo "$as_me:$LINENO: checking for gettimeofday declaration" >&5
-echo $ECHO_N "checking for gettimeofday declaration... $ECHO_C" >&6
-if test "${tcl_cv_grep_gettimeofday+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    if test "$tcl_strtod" = 1; then
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Solaris2.4/Tru64 strtod bugs" >&5
+$as_echo_n "checking for Solaris2.4/Tru64 strtod bugs... " >&6; }
+if ${tcl_cv_strtod_buggy+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	    if test "$cross_compiling" = yes; then :
+  tcl_cv_strtod_buggy=buggy
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#include <sys/time.h>
 
+		extern double strtod();
+		int main() {
+		    char *infString="Inf", *nanString="NaN", *spaceString=" ";
+		    char *term;
+		    double value;
+		    value = strtod(infString, &term);
+		    if ((term != infString) && (term[-1] == 0)) {
+			exit(1);
+		    }
+		    value = strtod(nanString, &term);
+		    if ((term != nanString) && (term[-1] == 0)) {
+			exit(1);
+		    }
+		    value = strtod(spaceString, &term);
+		    if (term == (spaceString+1)) {
+			exit(1);
+		    }
+		    exit(0);
+		}
 _ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "gettimeofday" >/dev/null 2>&1; then
-  tcl_cv_grep_gettimeofday=present
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_strtod_buggy=ok
 else
-  tcl_cv_grep_gettimeofday=missing
+  tcl_cv_strtod_buggy=buggy
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-rm -f conftest*
 
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_grep_gettimeofday" >&5
-echo "${ECHO_T}$tcl_cv_grep_gettimeofday" >&6
-if test $tcl_cv_grep_gettimeofday = missing ; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_strtod_buggy" >&5
+$as_echo "$tcl_cv_strtod_buggy" >&6; }
+	if test "$tcl_cv_strtod_buggy" = buggy; then
+	    case " $LIBOBJS " in
+  *" fixstrtod.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS fixstrtod.$ac_objext"
+ ;;
+esac
 
-cat >>confdefs.h <<\_ACEOF
-#define GETTOD_NOT_DECLARED 1
-_ACEOF
+	    USE_COMPAT=1
+
+$as_echo "#define strtod fixstrtod" >>confdefs.h
+
+	fi
+    fi
 
-fi
 
 #--------------------------------------------------------------------
-#	The following code checks to see whether it is possible to get
-#	signed chars on this platform.  This is needed in order to
-#	properly generate sign-extended ints from character values.
+#	Check for various typedefs and provide substitutes if
+#	they don't exist.
 #--------------------------------------------------------------------
 
+ac_fn_c_check_type "$LINENO" "mode_t" "ac_cv_type_mode_t" "$ac_includes_default"
+if test "x$ac_cv_type_mode_t" = xyes; then :
 
-echo "$as_me:$LINENO: checking whether char is unsigned" >&5
-echo $ECHO_N "checking whether char is unsigned... $ECHO_C" >&6
-if test "${ac_cv_c_char_unsigned+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main ()
-{
-static int test_array [1 - 2 * !(((char) -1) < 0)];
-test_array [0] = 0
 
-  ;
-  return 0;
-}
+cat >>confdefs.h <<_ACEOF
+#define mode_t int
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_cv_c_char_unsigned=no
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-ac_cv_c_char_unsigned=yes
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $ac_cv_c_char_unsigned" >&5
-echo "${ECHO_T}$ac_cv_c_char_unsigned" >&6
-if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
-  cat >>confdefs.h <<\_ACEOF
-#define __CHAR_UNSIGNED__ 1
-_ACEOF
 
-fi
+ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default"
+if test "x$ac_cv_type_pid_t" = xyes; then :
 
-echo "$as_me:$LINENO: checking signed char declarations" >&5
-echo $ECHO_N "checking signed char declarations... $ECHO_C" >&6
-if test "${tcl_cv_char_signed+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+cat >>confdefs.h <<_ACEOF
+#define pid_t int
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
 
-int
-main ()
-{
+fi
 
-	signed char *p;
-	p = 0;
+ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+if test "x$ac_cv_type_size_t" = xyes; then :
 
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_char_signed=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-tcl_cv_char_signed=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:$LINENO: result: $tcl_cv_char_signed" >&5
-echo "${ECHO_T}$tcl_cv_char_signed" >&6
-if test $tcl_cv_char_signed = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_SIGNED_CHAR 1
+cat >>confdefs.h <<_ACEOF
+#define size_t unsigned int
 _ACEOF
 
 fi
 
-#--------------------------------------------------------------------
-#  Does putenv() copy or not?  We need to know to avoid memory leaks.
-#--------------------------------------------------------------------
-
-echo "$as_me:$LINENO: checking for a putenv() that copies the buffer" >&5
-echo $ECHO_N "checking for a putenv() that copies the buffer... $ECHO_C" >&6
-if test "${tcl_cv_putenv_copy+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-
-    if test "$cross_compiling" = yes; then
-  tcl_cv_putenv_copy=no
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5
+$as_echo_n "checking for uid_t in sys/types.h... " >&6; }
+if ${ac_cv_type_uid_t+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-
-	#include <stdlib.h>
-	#define OURVAR "havecopy=yes"
-	int main (int argc, char *argv[])
-	{
-	    char *foo, *bar;
-	    foo = (char *)strdup(OURVAR);
-	    putenv(foo);
-	    strcpy((char *)(strchr(foo, '=') + 1), "no");
-	    bar = getenv("havecopy");
-	    if (!strcmp(bar, "no")) {
-		/* doesnt copy */
-		return 0;
-	    } else {
-		/* does copy */
-		return 1;
-	    }
-	}
+#include <sys/types.h>
 
 _ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_putenv_copy=no
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "uid_t" >/dev/null 2>&1; then :
+  ac_cv_type_uid_t=yes
 else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_putenv_copy=yes
-fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
-fi
+  ac_cv_type_uid_t=no
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_putenv_copy" >&5
-echo "${ECHO_T}$tcl_cv_putenv_copy" >&6
-if test $tcl_cv_putenv_copy = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_PUTENV_THAT_COPIES 1
-_ACEOF
+rm -f conftest*
 
 fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5
+$as_echo "$ac_cv_type_uid_t" >&6; }
+if test $ac_cv_type_uid_t = no; then
 
-#--------------------------------------------------------------------
-# Check for support of nl_langinfo function
-#--------------------------------------------------------------------
+$as_echo "#define uid_t int" >>confdefs.h
 
 
-    # Check whether --enable-langinfo or --disable-langinfo was given.
-if test "${enable_langinfo+set}" = set; then
-  enableval="$enable_langinfo"
-  langinfo_ok=$enableval
-else
-  langinfo_ok=yes
-fi;
+$as_echo "#define gid_t int" >>confdefs.h
 
-    HAVE_LANGINFO=0
-    if test "$langinfo_ok" = "yes"; then
-	if test "${ac_cv_header_langinfo_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for langinfo.h" >&5
-echo $ECHO_N "checking for langinfo.h... $ECHO_C" >&6
-if test "${ac_cv_header_langinfo_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
 fi
-echo "$as_me:$LINENO: result: $ac_cv_header_langinfo_h" >&5
-echo "${ECHO_T}$ac_cv_header_langinfo_h" >&6
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for socklen_t" >&5
+$as_echo_n "checking for socklen_t... " >&6; }
+if ${tcl_cv_type_socklen_t+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking langinfo.h usability" >&5
-echo $ECHO_N "checking langinfo.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
-#include <langinfo.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
+	#include <sys/types.h>
+	#include <sys/socket.h>
 
-# Is the header present?
-echo "$as_me:$LINENO: checking langinfo.h presence" >&5
-echo $ECHO_N "checking langinfo.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <langinfo.h>
+int
+main ()
+{
+
+    	socklen_t foo;
+
+  ;
+  return 0;
+}
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_type_socklen_t=yes
 else
-  ac_cpp_err=yes
+  tcl_cv_type_socklen_t=no
 fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_type_socklen_t" >&5
+$as_echo "$tcl_cv_type_socklen_t" >&6; }
+if test $tcl_cv_type_socklen_t = no; then
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: langinfo.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: langinfo.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: langinfo.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: langinfo.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: langinfo.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: langinfo.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: langinfo.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: langinfo.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: langinfo.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: langinfo.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: langinfo.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: langinfo.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: langinfo.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: langinfo.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: langinfo.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: langinfo.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for langinfo.h" >&5
-echo $ECHO_N "checking for langinfo.h... $ECHO_C" >&6
-if test "${ac_cv_header_langinfo_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_cv_header_langinfo_h=$ac_header_preproc
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_langinfo_h" >&5
-echo "${ECHO_T}$ac_cv_header_langinfo_h" >&6
+$as_echo "#define socklen_t int" >>confdefs.h
 
 fi
-if test $ac_cv_header_langinfo_h = yes; then
-  langinfo_ok=yes
-else
-  langinfo_ok=no
-fi
 
+ac_fn_c_check_type "$LINENO" "intptr_t" "ac_cv_type_intptr_t" "$ac_includes_default"
+if test "x$ac_cv_type_intptr_t" = xyes; then :
+
+
+$as_echo "#define HAVE_INTPTR_T 1" >>confdefs.h
 
-    fi
-    echo "$as_me:$LINENO: checking whether to use nl_langinfo" >&5
-echo $ECHO_N "checking whether to use nl_langinfo... $ECHO_C" >&6
-    if test "$langinfo_ok" = "yes"; then
-	if test "${tcl_cv_langinfo_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
 else
 
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pointer-size signed integer type" >&5
+$as_echo_n "checking for pointer-size signed integer type... " >&6; }
+if ${tcl_cv_intptr_t+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    for tcl_cv_intptr_t in "int" "long" "long long" none; do
+	if test "$tcl_cv_intptr_t" != none; then
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#include <langinfo.h>
+$ac_includes_default
 int
 main ()
 {
-nl_langinfo(CODESET);
+static int test_array [1 - 2 * !(sizeof (void *) <= sizeof ($tcl_cv_intptr_t))];
+test_array [0] = 0;
+return test_array [0];
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_langinfo_h=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_ok=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_langinfo_h=no
+  tcl_ok=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+	    test "$tcl_ok" = yes && break; fi
+    done
 fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_intptr_t" >&5
+$as_echo "$tcl_cv_intptr_t" >&6; }
+    if test "$tcl_cv_intptr_t" != none; then
 
-	echo "$as_me:$LINENO: result: $tcl_cv_langinfo_h" >&5
-echo "${ECHO_T}$tcl_cv_langinfo_h" >&6
-	if test $tcl_cv_langinfo_h = yes; then
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_LANGINFO 1
+cat >>confdefs.h <<_ACEOF
+#define intptr_t $tcl_cv_intptr_t
 _ACEOF
 
-	fi
-    else
-	echo "$as_me:$LINENO: result: $langinfo_ok" >&5
-echo "${ECHO_T}$langinfo_ok" >&6
     fi
 
+fi
 
-#--------------------------------------------------------------------
-# Check for support of chflags function
-#--------------------------------------------------------------------
-
-
-for ac_func in chflags
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
+ac_fn_c_check_type "$LINENO" "uintptr_t" "ac_cv_type_uintptr_t" "$ac_includes_default"
+if test "x$ac_cv_type_uintptr_t" = xyes; then :
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+$as_echo "#define HAVE_UINTPTR_T 1" >>confdefs.h
 
-#undef $ac_func
+else
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pointer-size unsigned integer type" >&5
+$as_echo_n "checking for pointer-size unsigned integer type... " >&6; }
+if ${tcl_cv_uintptr_t+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
 
+    for tcl_cv_uintptr_t in "unsigned int" "unsigned long" "unsigned long long" \
+	    none; do
+	if test "$tcl_cv_uintptr_t" != none; then
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
 int
 main ()
 {
-return f != $ac_func;
+static int test_array [1 - 2 * !(sizeof (void *) <= sizeof ($tcl_cv_uintptr_t))];
+test_array [0] = 0;
+return test_array [0];
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_ok=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
+  tcl_ok=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+	    test "$tcl_ok" = yes && break; fi
+    done
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_uintptr_t" >&5
+$as_echo "$tcl_cv_uintptr_t" >&6; }
+    if test "$tcl_cv_uintptr_t" != none; then
+
+cat >>confdefs.h <<_ACEOF
+#define uintptr_t $tcl_cv_uintptr_t
 _ACEOF
 
+    fi
+
 fi
-done
 
 
 #--------------------------------------------------------------------
-# Check for support of isnan() function or macro
+#	If a system doesn't have an opendir function (man, that's old!)
+#	then we have to supply a different version of dirent.h which
+#	is compatible with the substitute version of opendir that's
+#	provided.  This version only works with V7-style directories.
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking isnan" >&5
-echo $ECHO_N "checking isnan... $ECHO_C" >&6
-if test "${tcl_cv_isnan+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+ac_fn_c_check_func "$LINENO" "opendir" "ac_cv_func_opendir"
+if test "x$ac_cv_func_opendir" = xyes; then :
+
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+$as_echo "#define USE_DIRENT2_H 1" >>confdefs.h
+
+fi
+
+
+#--------------------------------------------------------------------
+#	The check below checks whether <sys/wait.h> defines the type
+#	"union wait" correctly.  It's needed because of weirdness in
+#	HP-UX where "union wait" is defined in both the BSD and SYS-V
+#	environments.  Checking the usability of WIFEXITED seems to do
+#	the trick.
+#--------------------------------------------------------------------
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking union wait" >&5
+$as_echo_n "checking union wait... " >&6; }
+if ${tcl_cv_union_wait+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#include <math.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 int
 main ()
 {
 
-isnan(0.0);			/* Generates an error if isnan is missing */
+union wait x;
+WIFEXITED(x);		/* Generates compiler error if WIFEXITED
+			 * uses an int. */
 
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  tcl_cv_isnan=yes
+if ac_fn_c_try_link "$LINENO"; then :
+  tcl_cv_union_wait=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_isnan=no
+  tcl_cv_union_wait=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_isnan" >&5
-echo "${ECHO_T}$tcl_cv_isnan" >&6
-if test $tcl_cv_isnan = no; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_union_wait" >&5
+$as_echo "$tcl_cv_union_wait" >&6; }
+if test $tcl_cv_union_wait = no; then
 
-cat >>confdefs.h <<\_ACEOF
-#define NO_ISNAN 1
-_ACEOF
+$as_echo "#define NO_UNION_WAIT 1" >>confdefs.h
 
 fi
 
 #--------------------------------------------------------------------
-# Darwin specific API checks and defines
+#	Check whether there is an strncasecmp function on this system.
+#	This is a bit tricky because under SCO it's in -lsocket and
+#	under Sequent Dynix it's in -linet.
 #--------------------------------------------------------------------
 
-if test "`uname -s`" = "Darwin" ; then
+ac_fn_c_check_func "$LINENO" "strncasecmp" "ac_cv_func_strncasecmp"
+if test "x$ac_cv_func_strncasecmp" = xyes; then :
+  tcl_ok=1
+else
+  tcl_ok=0
+fi
 
-for ac_func in getattrlist
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+if test "$tcl_ok" = 0; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for strncasecmp in -lsocket" >&5
+$as_echo_n "checking for strncasecmp in -lsocket... " >&6; }
+if ${ac_cv_lib_socket_strncasecmp+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsocket  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef $ac_func
-
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
    builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
 #ifdef __cplusplus
-}
+extern "C"
 #endif
-
+char strncasecmp ();
 int
 main ()
 {
-return f != $ac_func;
+return strncasecmp ();
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_socket_strncasecmp=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
+  ac_cv_lib_socket_strncasecmp=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-_ACEOF
-
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_strncasecmp" >&5
+$as_echo "$ac_cv_lib_socket_strncasecmp" >&6; }
+if test "x$ac_cv_lib_socket_strncasecmp" = xyes; then :
+  tcl_ok=1
+else
+  tcl_ok=0
 fi
-done
-
 
-for ac_header in copyfile.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+if test "$tcl_ok" = 0; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for strncasecmp in -linet" >&5
+$as_echo_n "checking for strncasecmp in -linet... " >&6; }
+if ${ac_cv_lib_inet_strncasecmp+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-linet  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
 
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strncasecmp ();
+int
+main ()
+{
+return strncasecmp ();
+  ;
+  return 0;
+}
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_inet_strncasecmp=yes
 else
-  ac_cpp_err=yes
+  ac_cv_lib_inet_strncasecmp=no
 fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_inet_strncasecmp" >&5
+$as_echo "$ac_cv_lib_inet_strncasecmp" >&6; }
+if test "x$ac_cv_lib_inet_strncasecmp" = xyes; then :
+  tcl_ok=1
 else
-  eval "$as_ac_Header=\$ac_header_preproc"
+  tcl_ok=0
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
 fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-_ACEOF
+if test "$tcl_ok" = 0; then
+    case " $LIBOBJS " in
+  *" strncasecmp.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS strncasecmp.$ac_objext"
+ ;;
+esac
 
+    USE_COMPAT=1
 fi
 
-done
+#--------------------------------------------------------------------
+#	The code below deals with several issues related to gettimeofday:
+#	1. Some systems don't provide a gettimeofday function at all
+#	   (set NO_GETTOD if this is the case).
+#	2. See if gettimeofday is declared in the <sys/time.h> header file.
+#	   if not, set the GETTOD_NOT_DECLARED flag so that tclPort.h can
+#	   declare it.
+#--------------------------------------------------------------------
 
+ac_fn_c_check_func "$LINENO" "gettimeofday" "ac_cv_func_gettimeofday"
+if test "x$ac_cv_func_gettimeofday" = xyes; then :
 
-for ac_func in copyfile
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
+else
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+$as_echo "#define NO_GETTOD 1" >>confdefs.h
 
-#undef $ac_func
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gettimeofday declaration" >&5
+$as_echo_n "checking for gettimeofday declaration... " >&6; }
+if ${tcl_cv_grep_gettimeofday+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/time.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gettimeofday" >/dev/null 2>&1; then :
+  tcl_cv_grep_gettimeofday=present
+else
+  tcl_cv_grep_gettimeofday=missing
+fi
+rm -f conftest*
 
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_grep_gettimeofday" >&5
+$as_echo "$tcl_cv_grep_gettimeofday" >&6; }
+if test $tcl_cv_grep_gettimeofday = missing ; then
+
+$as_echo "#define GETTOD_NOT_DECLARED 1" >>confdefs.h
+
+fi
+
+#--------------------------------------------------------------------
+#	The following code checks to see whether it is possible to get
+#	signed chars on this platform.  This is needed in order to
+#	properly generate sign-extended ints from character values.
+#--------------------------------------------------------------------
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether char is unsigned" >&5
+$as_echo_n "checking whether char is unsigned... " >&6; }
+if ${ac_cv_c_char_unsigned+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
 int
 main ()
 {
-return f != $ac_func;
+static int test_array [1 - 2 * !(((char) -1) < 0)];
+test_array [0] = 0;
+return test_array [0];
+
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_char_unsigned=no
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
+  ac_cv_c_char_unsigned=yes
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-_ACEOF
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_char_unsigned" >&5
+$as_echo "$ac_cv_c_char_unsigned" >&6; }
+if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
+  $as_echo "#define __CHAR_UNSIGNED__ 1" >>confdefs.h
 
 fi
-done
-
-    if test $tcl_corefoundation = yes; then
 
-for ac_header in libkern/OSAtomic.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking signed char declarations" >&5
+$as_echo_n "checking signed char declarations... " >&6; }
+if ${tcl_cv_char_signed+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
+
+int
+main ()
+{
+
+	signed char *p;
+	p = 0;
+
+  ;
+  return 0;
+}
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_char_signed=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+  tcl_cv_char_signed=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_char_signed" >&5
+$as_echo "$tcl_cv_char_signed" >&6; }
+if test $tcl_cv_char_signed = yes; then
+
+$as_echo "#define HAVE_SIGNED_CHAR 1" >>confdefs.h
 
-ac_header_compiler=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
 
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
+#--------------------------------------------------------------------
+#  Does putenv() copy or not?  We need to know to avoid memory leaks.
+#--------------------------------------------------------------------
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a putenv() that copies the buffer" >&5
+$as_echo_n "checking for a putenv() that copies the buffer... " >&6; }
+if ${tcl_cv_putenv_copy+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
+
+    if test "$cross_compiling" = yes; then :
+  tcl_cv_putenv_copy=no
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
 
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
+	#include <stdlib.h>
+	#define OURVAR "havecopy=yes"
+	int main (int argc, char *argv[])
+	{
+	    char *foo, *bar;
+	    foo = (char *)strdup(OURVAR);
+	    putenv(foo);
+	    strcpy((char *)(strchr(foo, '=') + 1), "no");
+	    bar = getenv("havecopy");
+	    if (!strcmp(bar, "no")) {
+		/* doesnt copy */
+		return 0;
+	    } else {
+		/* does copy */
+		return 1;
+	    }
+	}
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  tcl_cv_putenv_copy=no
 else
-  eval "$as_ac_Header=\$ac_header_preproc"
+  tcl_cv_putenv_copy=yes
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
 fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-_ACEOF
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_putenv_copy" >&5
+$as_echo "$tcl_cv_putenv_copy" >&6; }
+if test $tcl_cv_putenv_copy = yes; then
+
+$as_echo "#define HAVE_PUTENV_THAT_COPIES 1" >>confdefs.h
 
 fi
 
-done
+#--------------------------------------------------------------------
+# Check for support of nl_langinfo function
+#--------------------------------------------------------------------
 
 
-for ac_func in OSSpinLockLock
-do
-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:$LINENO: checking for $ac_func" >&5
-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
-if eval "test \"\${$as_ac_var+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $ac_func innocuous_$ac_func
+    # Check whether --enable-langinfo was given.
+if test "${enable_langinfo+set}" = set; then :
+  enableval=$enable_langinfo; langinfo_ok=$enableval
+else
+  langinfo_ok=yes
+fi
 
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $ac_func (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
 
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
+    HAVE_LANGINFO=0
+    if test "$langinfo_ok" = "yes"; then
+	ac_fn_c_check_header_mongrel "$LINENO" "langinfo.h" "ac_cv_header_langinfo_h" "$ac_includes_default"
+if test "x$ac_cv_header_langinfo_h" = xyes; then :
+  langinfo_ok=yes
+else
+  langinfo_ok=no
+fi
 
-#undef $ac_func
 
-/* Override any gcc2 internal prototype to avoid an error.  */
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-/* We use char because int might match the return type of a gcc2
-   builtin and then its argument prototype would still apply.  */
-char $ac_func ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
-choke me
-#else
-char (*f) () = $ac_func;
-#endif
-#ifdef __cplusplus
-}
-#endif
+    fi
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use nl_langinfo" >&5
+$as_echo_n "checking whether to use nl_langinfo... " >&6; }
+    if test "$langinfo_ok" = "yes"; then
+	if ${tcl_cv_langinfo_h+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
 
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <langinfo.h>
 int
 main ()
 {
-return f != $ac_func;
+nl_langinfo(CODESET);
   ;
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_var=yes"
+if ac_fn_c_try_compile "$LINENO"; then :
+  tcl_cv_langinfo_h=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-eval "$as_ac_var=no"
+  tcl_cv_langinfo_h=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
-if test `eval echo '${'$as_ac_var'}'` = yes; then
+
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_langinfo_h" >&5
+$as_echo "$tcl_cv_langinfo_h" >&6; }
+	if test $tcl_cv_langinfo_h = yes; then
+
+$as_echo "#define HAVE_LANGINFO 1" >>confdefs.h
+
+	fi
+    else
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $langinfo_ok" >&5
+$as_echo "$langinfo_ok" >&6; }
+    fi
+
+
+#--------------------------------------------------------------------
+# Check for support of chflags function
+#--------------------------------------------------------------------
+
+for ac_func in chflags
+do :
+  ac_fn_c_check_func "$LINENO" "chflags" "ac_cv_func_chflags"
+if test "x$ac_cv_func_chflags" = xyes; then :
   cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+#define HAVE_CHFLAGS 1
 _ACEOF
 
 fi
 done
 
-    fi
 
-cat >>confdefs.h <<\_ACEOF
-#define USE_VFORK 1
-_ACEOF
+#--------------------------------------------------------------------
+# Check for support of isnan() function or macro
+#--------------------------------------------------------------------
 
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking isnan" >&5
+$as_echo_n "checking isnan... " >&6; }
+if ${tcl_cv_isnan+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_DEFAULT_ENCODING "utf-8"
-_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <math.h>
+int
+main ()
+{
 
+isnan(0.0);			/* Generates an error if isnan is missing */
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_LOAD_FROM_MEMORY 1
+  ;
+  return 0;
+}
 _ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  tcl_cv_isnan=yes
+else
+  tcl_cv_isnan=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_isnan" >&5
+$as_echo "$tcl_cv_isnan" >&6; }
+if test $tcl_cv_isnan = no; then
 
+$as_echo "#define NO_ISNAN 1" >>confdefs.h
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_WIDE_CLICKS 1
-_ACEOF
+fi
 
+#--------------------------------------------------------------------
+# Darwin specific API checks and defines
+#--------------------------------------------------------------------
 
-for ac_header in AvailabilityMacros.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
+if test "`uname -s`" = "Darwin" ; then
+    for ac_func in getattrlist
+do :
+  ac_fn_c_check_func "$LINENO" "getattrlist" "ac_cv_func_getattrlist"
+if test "x$ac_cv_func_getattrlist" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_GETATTRLIST 1
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
 
-ac_header_compiler=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
+done
 
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
+    for ac_header in copyfile.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "copyfile.h" "ac_cv_header_copyfile_h" "$ac_includes_default"
+if test "x$ac_cv_header_copyfile_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_COPYFILE_H 1
 _ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
+
+fi
+
+done
+
+    for ac_func in copyfile
+do :
+  ac_fn_c_check_func "$LINENO" "copyfile" "ac_cv_func_copyfile"
+if test "x$ac_cv_func_copyfile" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_COPYFILE 1
 _ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
+
 fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
+done
+
+    if test $tcl_corefoundation = yes; then
+	for ac_header in libkern/OSAtomic.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "libkern/OSAtomic.h" "ac_cv_header_libkern_OSAtomic_h" "$ac_includes_default"
+if test "x$ac_cv_header_libkern_OSAtomic_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBKERN_OSATOMIC_H 1
+_ACEOF
 
-  ac_header_preproc=no
 fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  eval "$as_ac_Header=\$ac_header_preproc"
+done
+
+	for ac_func in OSSpinLockLock
+do :
+  ac_fn_c_check_func "$LINENO" "OSSpinLockLock" "ac_cv_func_OSSpinLockLock"
+if test "x$ac_cv_func_OSSpinLockLock" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_OSSPINLOCKLOCK 1
+_ACEOF
+
 fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+done
+
+    fi
+
+$as_echo "#define USE_VFORK 1" >>confdefs.h
+
 
-fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
+$as_echo "#define TCL_DEFAULT_ENCODING \"utf-8\"" >>confdefs.h
+
+
+$as_echo "#define TCL_LOAD_FROM_MEMORY 1" >>confdefs.h
+
+    for ac_header in AvailabilityMacros.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "AvailabilityMacros.h" "ac_cv_header_AvailabilityMacros_h" "$ac_includes_default"
+if test "x$ac_cv_header_AvailabilityMacros_h" = xyes; then :
   cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+#define HAVE_AVAILABILITYMACROS_H 1
 _ACEOF
 
 fi
@@ -17620,18 +9799,14 @@ fi
 done
 
     if test "$ac_cv_header_AvailabilityMacros_h" = yes; then
-	echo "$as_me:$LINENO: checking if weak import is available" >&5
-echo $ECHO_N "checking if weak import is available... $ECHO_C" >&6
-if test "${tcl_cv_cc_weak_import+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if weak import is available" >&5
+$as_echo_n "checking if weak import is available... " >&6; }
+if ${tcl_cv_cc_weak_import+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 	    hold_cflags=$CFLAGS; CFLAGS="$CFLAGS -Werror"
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 		    #ifdef __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
@@ -17651,60 +9826,30 @@ rand();
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_cc_weak_import=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cc_weak_import=no
+  tcl_cv_cc_weak_import=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 	    CFLAGS=$hold_cflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_cc_weak_import" >&5
-echo "${ECHO_T}$tcl_cv_cc_weak_import" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cc_weak_import" >&5
+$as_echo "$tcl_cv_cc_weak_import" >&6; }
 	if test $tcl_cv_cc_weak_import = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_WEAK_IMPORT 1
-_ACEOF
+$as_echo "#define HAVE_WEAK_IMPORT 1" >>confdefs.h
 
 	fi
-	echo "$as_me:$LINENO: checking if Darwin SUSv3 extensions are available" >&5
-echo $ECHO_N "checking if Darwin SUSv3 extensions are available... $ECHO_C" >&6
-if test "${tcl_cv_cc_darwin_c_source+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if Darwin SUSv3 extensions are available" >&5
+$as_echo_n "checking if Darwin SUSv3 extensions are available... " >&6; }
+if ${tcl_cv_cc_darwin_c_source+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 	    hold_cflags=$CFLAGS; CFLAGS="$CFLAGS -Werror"
-	    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 		    #ifdef __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
@@ -17725,45 +9870,19 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_compile "$LINENO"; then :
   tcl_cv_cc_darwin_c_source=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cc_darwin_c_source=no
+  tcl_cv_cc_darwin_c_source=no
 fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 	    CFLAGS=$hold_cflags
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_cc_darwin_c_source" >&5
-echo "${ECHO_T}$tcl_cv_cc_darwin_c_source" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cc_darwin_c_source" >&5
+$as_echo "$tcl_cv_cc_darwin_c_source" >&6; }
 	if test $tcl_cv_cc_darwin_c_source = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define _DARWIN_C_SOURCE 1
-_ACEOF
+$as_echo "#define _DARWIN_C_SOURCE 1" >>confdefs.h
 
 	fi
     fi
@@ -17775,21 +9894,23 @@ else
     DLTEST_SUFFIX=""
 fi
 
+# Completelly supports on unix (linux/darwin)
+
+$as_echo "#define TCL_WIDE_CLICKS 1" >>confdefs.h
+
+
+
 #--------------------------------------------------------------------
 # Check for support of fts functions (readdir replacement)
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking for fts" >&5
-echo $ECHO_N "checking for fts... $ECHO_C" >&6
-if test "${tcl_cv_api_fts+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fts" >&5
+$as_echo_n "checking for fts... " >&6; }
+if ${tcl_cv_api_fts+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 	    #include <sys/param.h>
@@ -17808,45 +9929,19 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_api_fts=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_api_fts=no
+  tcl_cv_api_fts=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_api_fts" >&5
-echo "${ECHO_T}$tcl_cv_api_fts" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_api_fts" >&5
+$as_echo "$tcl_cv_api_fts" >&6; }
 if test $tcl_cv_api_fts = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_FTS 1
-_ACEOF
+$as_echo "#define HAVE_FTS 1" >>confdefs.h
 
 fi
 
@@ -17858,300 +9953,24 @@ fi
 #--------------------------------------------------------------------
 
 
-
-for ac_header in sys/ioctl.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  eval "$as_ac_Header=\$ac_header_preproc"
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-
-fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
+    for ac_header in sys/ioctl.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "sys/ioctl.h" "ac_cv_header_sys_ioctl_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_ioctl_h" = xyes; then :
   cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+#define HAVE_SYS_IOCTL_H 1
 _ACEOF
 
 fi
 
 done
 
-
-for ac_header in sys/filio.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking $ac_header usability" >&5
-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <$ac_header>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking $ac_header presence" >&5
-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <$ac_header>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  eval "$as_ac_Header=\$ac_header_preproc"
-fi
-echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-
-fi
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
+    for ac_header in sys/filio.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "sys/filio.h" "ac_cv_header_sys_filio_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_filio_h" = xyes; then :
   cat >>confdefs.h <<_ACEOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+#define HAVE_SYS_FILIO_H 1
 _ACEOF
 
 fi
@@ -18159,10 +9978,10 @@ fi
 done
 
 
-    echo "$as_me:$LINENO: checking system version" >&5
-echo $ECHO_N "checking system version... $ECHO_C" >&6
-if test "${tcl_cv_sys_version+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking system version" >&5
+$as_echo_n "checking system version... " >&6; }
+if ${tcl_cv_sys_version+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 	if test -f /usr/lib/NextStep/software_version; then
@@ -18170,8 +9989,8 @@ else
 	else
 	    tcl_cv_sys_version=`uname -s`-`uname -r`
 	    if test "$?" -ne 0 ; then
-		{ echo "$as_me:$LINENO: WARNING: can't find uname command" >&5
-echo "$as_me: WARNING: can't find uname command" >&2;}
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: can't find uname command" >&5
+$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
@@ -18187,12 +10006,12 @@ echo "$as_me: WARNING: can't find uname command" >&2;}
 	fi
 
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_sys_version" >&5
-echo "${ECHO_T}$tcl_cv_sys_version" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_sys_version" >&5
+$as_echo "$tcl_cv_sys_version" >&6; }
     system=$tcl_cv_sys_version
 
-    echo "$as_me:$LINENO: checking FIONBIO vs. O_NONBLOCK for nonblocking I/O" >&5
-echo $ECHO_N "checking FIONBIO vs. O_NONBLOCK for nonblocking I/O... $ECHO_C" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking FIONBIO vs. O_NONBLOCK for nonblocking I/O" >&5
+$as_echo_n "checking FIONBIO vs. O_NONBLOCK for nonblocking I/O... " >&6; }
     case $system in
 	# There used to be code here to use FIONBIO under AIX.  However, it
 	# was reported that FIONBIO doesn't work under AIX 3.2.5.  Since
@@ -18201,49 +10020,43 @@ echo $ECHO_N "checking FIONBIO vs. O_NONBLOCK for nonblocking I/O... $ECHO_C" >&
 
 	OSF*)
 
-cat >>confdefs.h <<\_ACEOF
-#define USE_FIONBIO 1
-_ACEOF
+$as_echo "#define USE_FIONBIO 1" >>confdefs.h
 
-	    echo "$as_me:$LINENO: result: FIONBIO" >&5
-echo "${ECHO_T}FIONBIO" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: FIONBIO" >&5
+$as_echo "FIONBIO" >&6; }
 	    ;;
 	SunOS-4*)
 
-cat >>confdefs.h <<\_ACEOF
-#define USE_FIONBIO 1
-_ACEOF
+$as_echo "#define USE_FIONBIO 1" >>confdefs.h
 
-	    echo "$as_me:$LINENO: result: FIONBIO" >&5
-echo "${ECHO_T}FIONBIO" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: FIONBIO" >&5
+$as_echo "FIONBIO" >&6; }
 	    ;;
 	*)
-	    echo "$as_me:$LINENO: result: O_NONBLOCK" >&5
-echo "${ECHO_T}O_NONBLOCK" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: O_NONBLOCK" >&5
+$as_echo "O_NONBLOCK" >&6; }
 	    ;;
     esac
 
 
 #------------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking whether to use dll unloading" >&5
-echo $ECHO_N "checking whether to use dll unloading... $ECHO_C" >&6
-# Check whether --enable-dll-unloading or --disable-dll-unloading was given.
-if test "${enable_dll_unloading+set}" = set; then
-  enableval="$enable_dll_unloading"
-  tcl_ok=$enableval
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use dll unloading" >&5
+$as_echo_n "checking whether to use dll unloading... " >&6; }
+# Check whether --enable-dll-unloading was given.
+if test "${enable_dll_unloading+set}" = set; then :
+  enableval=$enable_dll_unloading; tcl_ok=$enableval
 else
   tcl_ok=yes
-fi;
+fi
+
 if test $tcl_ok = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_UNLOAD_DLLS 1
-_ACEOF
+$as_echo "#define TCL_UNLOAD_DLLS 1" >>confdefs.h
 
 fi
-echo "$as_me:$LINENO: result: $tcl_ok" >&5
-echo "${ECHO_T}$tcl_ok" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_ok" >&5
+$as_echo "$tcl_ok" >&6; }
 
 #------------------------------------------------------------------------
 #	Check whether the timezone data is supplied by the OS or has
@@ -18251,31 +10064,31 @@ echo "${ECHO_T}$tcl_ok" >&6
 #	be overriden on the configure command line either way.
 #------------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking for timezone data" >&5
-echo $ECHO_N "checking for timezone data... $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for timezone data" >&5
+$as_echo_n "checking for timezone data... " >&6; }
 
-# Check whether --with-tzdata or --without-tzdata was given.
-if test "${with_tzdata+set}" = set; then
-  withval="$with_tzdata"
-  tcl_ok=$withval
+# Check whether --with-tzdata was given.
+if test "${with_tzdata+set}" = set; then :
+  withval=$with_tzdata; tcl_ok=$withval
 else
   tcl_ok=auto
-fi;
+fi
+
 #
 # Any directories that get added here must also be added to the
 # search path in ::tcl::clock::Initialize (library/clock.tcl).
 #
 case $tcl_ok in
     no)
-	echo "$as_me:$LINENO: result: supplied by OS vendor" >&5
-echo "${ECHO_T}supplied by OS vendor" >&6
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: supplied by OS vendor" >&5
+$as_echo "supplied by OS vendor" >&6; }
     ;;
     yes)
 	# nothing to do here
     ;;
     auto*)
-	if test "${tcl_cv_dir_zoneinfo+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+	if ${tcl_cv_dir_zoneinfo+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
 	for dir in /usr/share/zoneinfo \
@@ -18292,22 +10105,20 @@ fi
 
 	if test -n "$tcl_cv_dir_zoneinfo"; then
 	    tcl_ok=no
-	    echo "$as_me:$LINENO: result: $dir" >&5
-echo "${ECHO_T}$dir" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $dir" >&5
+$as_echo "$dir" >&6; }
 	else
 	    tcl_ok=yes
 	fi
     ;;
     *)
-	{ { echo "$as_me:$LINENO: error: invalid argument: $tcl_ok" >&5
-echo "$as_me: error: invalid argument: $tcl_ok" >&2;}
-   { (exit 1); exit 1; }; }
+	as_fn_error $? "invalid argument: $tcl_ok" "$LINENO" 5
     ;;
 esac
 if test $tcl_ok = yes
 then
-    echo "$as_me:$LINENO: result: supplied by Tcl" >&5
-echo "${ECHO_T}supplied by Tcl" >&6
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: supplied by Tcl" >&5
+$as_echo "supplied by Tcl" >&6; }
     INSTALL_TZDATA=install-tzdata
 fi
 
@@ -18315,152 +10126,16 @@ fi
 #	DTrace support
 #--------------------------------------------------------------------
 
-# Check whether --enable-dtrace or --disable-dtrace was given.
-if test "${enable_dtrace+set}" = set; then
-  enableval="$enable_dtrace"
-  tcl_ok=$enableval
+# Check whether --enable-dtrace was given.
+if test "${enable_dtrace+set}" = set; then :
+  enableval=$enable_dtrace; tcl_ok=$enableval
 else
   tcl_ok=no
-fi;
-if test $tcl_ok = yes; then
-    if test "${ac_cv_header_sys_sdt_h+set}" = set; then
-  echo "$as_me:$LINENO: checking for sys/sdt.h" >&5
-echo $ECHO_N "checking for sys/sdt.h... $ECHO_C" >&6
-if test "${ac_cv_header_sys_sdt_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_sys_sdt_h" >&5
-echo "${ECHO_T}$ac_cv_header_sys_sdt_h" >&6
-else
-  # Is the header compilable?
-echo "$as_me:$LINENO: checking sys/sdt.h usability" >&5
-echo $ECHO_N "checking sys/sdt.h usability... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$ac_includes_default
-#include <sys/sdt.h>
-_ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  ac_header_compiler=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-ac_header_compiler=no
-fi
-rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
-echo "${ECHO_T}$ac_header_compiler" >&6
-
-# Is the header present?
-echo "$as_me:$LINENO: checking sys/sdt.h presence" >&5
-echo $ECHO_N "checking sys/sdt.h presence... $ECHO_C" >&6
-cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-#include <sys/sdt.h>
-_ACEOF
-if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
-  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } >/dev/null; then
-  if test -s conftest.err; then
-    ac_cpp_err=$ac_c_preproc_warn_flag
-    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
-  else
-    ac_cpp_err=
-  fi
-else
-  ac_cpp_err=yes
-fi
-if test -z "$ac_cpp_err"; then
-  ac_header_preproc=yes
-else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-  ac_header_preproc=no
 fi
-rm -f conftest.err conftest.$ac_ext
-echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
-echo "${ECHO_T}$ac_header_preproc" >&6
 
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
-  yes:no: )
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h: accepted by the compiler, rejected by the preprocessor!" >&5
-echo "$as_me: WARNING: sys/sdt.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h: proceeding with the compiler's result" >&5
-echo "$as_me: WARNING: sys/sdt.h: proceeding with the compiler's result" >&2;}
-    ac_header_preproc=yes
-    ;;
-  no:yes:* )
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h: present but cannot be compiled" >&5
-echo "$as_me: WARNING: sys/sdt.h: present but cannot be compiled" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h:     check for missing prerequisite headers?" >&5
-echo "$as_me: WARNING: sys/sdt.h:     check for missing prerequisite headers?" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h: see the Autoconf documentation" >&5
-echo "$as_me: WARNING: sys/sdt.h: see the Autoconf documentation" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h:     section \"Present But Cannot Be Compiled\"" >&5
-echo "$as_me: WARNING: sys/sdt.h:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h: proceeding with the preprocessor's result" >&5
-echo "$as_me: WARNING: sys/sdt.h: proceeding with the preprocessor's result" >&2;}
-    { echo "$as_me:$LINENO: WARNING: sys/sdt.h: in the future, the compiler will take precedence" >&5
-echo "$as_me: WARNING: sys/sdt.h: in the future, the compiler will take precedence" >&2;}
-    (
-      cat <<\_ASBOX
-## ------------------------------ ##
-## Report this to the tcl lists.  ##
-## ------------------------------ ##
-_ASBOX
-    ) |
-      sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-echo "$as_me:$LINENO: checking for sys/sdt.h" >&5
-echo $ECHO_N "checking for sys/sdt.h... $ECHO_C" >&6
-if test "${ac_cv_header_sys_sdt_h+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  ac_cv_header_sys_sdt_h=$ac_header_preproc
-fi
-echo "$as_me:$LINENO: result: $ac_cv_header_sys_sdt_h" >&5
-echo "${ECHO_T}$ac_cv_header_sys_sdt_h" >&6
-
-fi
-if test $ac_cv_header_sys_sdt_h = yes; then
+if test $tcl_ok = yes; then
+    ac_fn_c_check_header_mongrel "$LINENO" "sys/sdt.h" "ac_cv_header_sys_sdt_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_sdt_h" = xyes; then :
   tcl_ok=yes
 else
   tcl_ok=no
@@ -18471,10 +10146,10 @@ fi
 if test $tcl_ok = yes; then
     # Extract the first word of "dtrace", so it can be a program name with args.
 set dummy dtrace; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_path_DTRACE+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_DTRACE+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
   case $DTRACE in
   [\\/]* | ?:[\\/]*)
@@ -18487,38 +10162,37 @@ for as_dir in $as_dummy
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
 done
-done
+  done
+IFS=$as_save_IFS
 
   ;;
 esac
 fi
 DTRACE=$ac_cv_path_DTRACE
-
 if test -n "$DTRACE"; then
-  echo "$as_me:$LINENO: result: $DTRACE" >&5
-echo "${ECHO_T}$DTRACE" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
+$as_echo "$DTRACE" >&6; }
 else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
 fi
 
+
     test -z "$ac_cv_path_DTRACE" && tcl_ok=no
 fi
-echo "$as_me:$LINENO: checking whether to enable DTrace support" >&5
-echo $ECHO_N "checking whether to enable DTrace support... $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable DTrace support" >&5
+$as_echo_n "checking whether to enable DTrace support... " >&6; }
 MAKEFILE_SHELL='/bin/sh'
 if test $tcl_ok = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define USE_DTRACE 1
-_ACEOF
+$as_echo "#define USE_DTRACE 1" >>confdefs.h
 
     DTRACE_SRC="\${DTRACE_SRC}"
     DTRACE_HDR="\${DTRACE_HDR}"
@@ -18536,27 +10210,23 @@ _ACEOF
 	fi
     fi
 fi
-echo "$as_me:$LINENO: result: $tcl_ok" >&5
-echo "${ECHO_T}$tcl_ok" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_ok" >&5
+$as_echo "$tcl_ok" >&6; }
 
 #--------------------------------------------------------------------
 #  Does the C stack grow upwards or downwards? Or cross-compiling?
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking if the C stack grows upwards in memory" >&5
-echo $ECHO_N "checking if the C stack grows upwards in memory... $ECHO_C" >&6
-if test "${tcl_cv_stack_grows_up+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C stack grows upwards in memory" >&5
+$as_echo_n "checking if the C stack grows upwards in memory... " >&6; }
+if ${tcl_cv_stack_grows_up+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    if test "$cross_compiling" = yes; then
+    if test "$cross_compiling" = yes; then :
   tcl_cv_stack_grows_up=unknown
 else
-  cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 	int StackGrowsUp(int *parent) {
@@ -18573,42 +10243,25 @@ cat >>conftest.$ac_ext <<_ACEOF
 	}
 
 _ACEOF
-rm -f conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_run "$LINENO"; then :
   tcl_cv_stack_grows_up=yes
 else
-  echo "$as_me: program exited with status $ac_status" >&5
-echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-( exit $ac_status )
-tcl_cv_stack_grows_up=no
+  tcl_cv_stack_grows_up=no
 fi
-rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
+
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_stack_grows_up" >&5
-echo "${ECHO_T}$tcl_cv_stack_grows_up" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_stack_grows_up" >&5
+$as_echo "$tcl_cv_stack_grows_up" >&6; }
 if test $tcl_cv_stack_grows_up = unknown; then
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_CROSS_COMPILE 1
-_ACEOF
+$as_echo "#define TCL_CROSS_COMPILE 1" >>confdefs.h
 
 elif test $tcl_cv_stack_grows_up = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_STACK_GROWS_UP 1
-_ACEOF
+$as_echo "#define TCL_STACK_GROWS_UP 1" >>confdefs.h
 
 fi
 
@@ -18616,17 +10269,13 @@ fi
 # The check below checks whether the cpuid instruction is usable.
 #--------------------------------------------------------------------
 
-echo "$as_me:$LINENO: checking whether the cpuid instruction is usable" >&5
-echo $ECHO_N "checking whether the cpuid instruction is usable... $ECHO_C" >&6
-if test "${tcl_cv_cpuid+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the cpuid instruction is usable" >&5
+$as_echo_n "checking whether the cpuid instruction is usable... " >&6; }
+if ${tcl_cv_cpuid+:} false; then :
+  $as_echo_n "(cached) " >&6
 else
 
-    cat >conftest.$ac_ext <<_ACEOF
-/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -18645,45 +10294,19 @@ main ()
   return 0;
 }
 _ACEOF
-rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
-  (eval $ac_link) 2>conftest.er1
-  ac_status=$?
-  grep -v '^ *+' conftest.er1 >conftest.err
-  rm -f conftest.er1
-  cat conftest.err >&5
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-	 { ac_try='test -z "$ac_c_werror_flag"
-			 || test ! -s conftest.err'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; } &&
-	 { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:$LINENO: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
+if ac_fn_c_try_link "$LINENO"; then :
   tcl_cv_cpuid=yes
 else
-  echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-tcl_cv_cpuid=no
+  tcl_cv_cpuid=no
 fi
-rm -f conftest.err conftest.$ac_objext \
-      conftest$ac_exeext conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:$LINENO: result: $tcl_cv_cpuid" >&5
-echo "${ECHO_T}$tcl_cv_cpuid" >&6
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_cpuid" >&5
+$as_echo "$tcl_cv_cpuid" >&6; }
 if test $tcl_cv_cpuid = yes; then
 
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_CPUID 1
-_ACEOF
+$as_echo "#define HAVE_CPUID 1" >>confdefs.h
 
 fi
 
@@ -18714,38 +10337,38 @@ HTML_DIR='$(DISTDIR)/html'
 if test "`uname -s`" = "Darwin" ; then
 
     if test "`uname -s`" = "Darwin" ; then
-	echo "$as_me:$LINENO: checking how to package libraries" >&5
-echo $ECHO_N "checking how to package libraries... $ECHO_C" >&6
-	# Check whether --enable-framework or --disable-framework was given.
-if test "${enable_framework+set}" = set; then
-  enableval="$enable_framework"
-  enable_framework=$enableval
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to package libraries" >&5
+$as_echo_n "checking how to package libraries... " >&6; }
+	# Check whether --enable-framework was given.
+if test "${enable_framework+set}" = set; then :
+  enableval=$enable_framework; enable_framework=$enableval
 else
   enable_framework=no
-fi;
+fi
+
 	if test $enable_framework = yes; then
 	    if test $SHARED_BUILD = 0; then
-		{ echo "$as_me:$LINENO: WARNING: Frameworks can only be built if --enable-shared is yes" >&5
-echo "$as_me: WARNING: Frameworks can only be built if --enable-shared is yes" >&2;}
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Frameworks can only be built if --enable-shared is yes" >&5
+$as_echo "$as_me: WARNING: Frameworks can only be built if --enable-shared is yes" >&2;}
 		enable_framework=no
 	    fi
 	    if test $tcl_corefoundation = no; then
-		{ echo "$as_me:$LINENO: WARNING: Frameworks can only be used when CoreFoundation is available" >&5
-echo "$as_me: WARNING: Frameworks can only be used when CoreFoundation is available" >&2;}
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Frameworks can only be used when CoreFoundation is available" >&5
+$as_echo "$as_me: WARNING: Frameworks can only be used when CoreFoundation is available" >&2;}
 		enable_framework=no
 	    fi
 	fi
 	if test $enable_framework = yes; then
-	    echo "$as_me:$LINENO: result: framework" >&5
-echo "${ECHO_T}framework" >&6
+	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: framework" >&5
+$as_echo "framework" >&6; }
 	    FRAMEWORK_BUILD=1
 	else
 	    if test $SHARED_BUILD = 1; then
-		echo "$as_me:$LINENO: result: shared library" >&5
-echo "${ECHO_T}shared library" >&6
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: shared library" >&5
+$as_echo "shared library" >&6; }
 	    else
-		echo "$as_me:$LINENO: result: static library" >&5
-echo "${ECHO_T}static library" >&6
+		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: static library" >&5
+$as_echo "static library" >&6; }
 	    fi
 	    FRAMEWORK_BUILD=0
 	fi
@@ -18757,20 +10380,18 @@ echo "${ECHO_T}static library" >&6
     TCL_SHLIB_LD_EXTRAS="${TCL_SHLIB_LD_EXTRAS}"' -sectcreate __TEXT __info_plist Tcl-Info.plist'
     EXTRA_TCLSH_LIBS='-sectcreate __TEXT __info_plist Tclsh-Info.plist'
     EXTRA_APP_CC_SWITCHES='-mdynamic-no-pic'
-                        ac_config_files="$ac_config_files Tcl-Info.plist:../macosx/Tcl-Info.plist.in Tclsh-Info.plist:../macosx/Tclsh-Info.plist.in"
+    ac_config_files="$ac_config_files Tcl-Info.plist:../macosx/Tcl-Info.plist.in Tclsh-Info.plist:../macosx/Tclsh-Info.plist.in"
 
     TCL_YEAR="`date +%Y`"
 fi
 
 if test "$FRAMEWORK_BUILD" = "1" ; then
 
-cat >>confdefs.h <<\_ACEOF
-#define TCL_FRAMEWORK 1
-_ACEOF
+$as_echo "#define TCL_FRAMEWORK 1" >>confdefs.h
 
     # Construct a fake local framework structure to make linking with
     # '-framework Tcl' and running of tcltest work
-              ac_config_commands="$ac_config_commands Tcl.framework"
+    ac_config_commands="$ac_config_commands Tcl.framework"
 
     LD_LIBRARY_PATH_VAR="DYLD_FRAMEWORK_PATH"
     if test "${libdir}" = '${exec_prefix}/lib'; then
@@ -18920,7 +10541,7 @@ TCL_SHARED_BUILD=${SHARED_BUILD}
 
 
 
-                                        ac_config_files="$ac_config_files Makefile:../unix/Makefile.in dltest/Makefile:../unix/dltest/Makefile.in tclConfig.sh:../unix/tclConfig.sh.in tcl.pc:../unix/tcl.pc.in"
+ac_config_files="$ac_config_files Makefile:../unix/Makefile.in dltest/Makefile:../unix/dltest/Makefile.in tclConfig.sh:../unix/tclConfig.sh.in tcl.pc:../unix/tcl.pc.in"
 
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
@@ -18940,39 +10561,70 @@ _ACEOF
 
 # The following way of writing the cache mishandles newlines in values,
 # but we know of no workaround that is simple, portable, and efficient.
-# So, don't put newlines in cache variables' values.
+# So, we kill variables containing newlines.
 # Ultrix sh set writes to stderr and can't be redirected directly,
 # and sets the high bit in the cache file unless we assign to the vars.
-{
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
   (set) 2>&1 |
-    case `(ac_space=' '; set | grep ac_space) 2>&1` in
-    *ac_space=\ *)
-      # `set' does not quote correctly, so add quotes (double-quote
-      # substitution turns \\\\ into \\, and sed turns \\ into \).
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
       sed -n \
 	"s/'/'\\\\''/g;
 	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
-      ;;
+      ;; #(
     *)
       # `set' quotes correctly as required by POSIX, so do not add quotes.
-      sed -n \
-	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
       ;;
-    esac;
-} |
+    esac |
+    sort
+) |
   sed '
+     /^ac_cv_env_/b end
      t clear
-     : clear
+     :clear
      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
      t end
-     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
-     : end' >>confcache
-if diff $cache_file confcache >/dev/null 2>&1; then :; else
-  if test -w $cache_file; then
-    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
-    cat confcache >$cache_file
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
   else
-    echo "not updating unwritable cache $cache_file"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
   fi
 fi
 rm -f confcache
@@ -18981,63 +10633,56 @@ test "x$prefix" = xNONE && prefix=$ac_default_prefix
 # Let make expand exec_prefix.
 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
 
-# VPATH may cause trouble with some makes, so we remove $(srcdir),
-# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
-# trailing colons and then remove the whole line if VPATH becomes empty
-# (actually we leave an empty line to preserve line numbers).
-if test "x$srcdir" = x.; then
-  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{
-s/:*\$(srcdir):*/:/;
-s/:*\${srcdir}:*/:/;
-s/:*@srcdir@:*/:/;
-s/^\([^=]*=[	 ]*\):*/\1/;
-s/:*$//;
-s/^[^=]*=[	 ]*$//;
-}'
-fi
-
 # Transform confdefs.h into DEFS.
 # Protect against shell expansion while executing Makefile rules.
 # Protect against Makefile macro expansion.
 #
 # If the first sed substitution is executed (which looks for macros that
-# take arguments), then we branch to the quote section.  Otherwise,
+# take arguments), then branch to the quote section.  Otherwise,
 # look for a macro that doesn't take arguments.
-cat >confdef2opt.sed <<\_ACEOF
+ac_script='
+:mline
+/\\$/{
+ N
+ s,\\\n,,
+ b mline
+}
 t clear
-: clear
-s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\),-D\1=\2,g
+:clear
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
 t quote
-s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\),-D\1=\2,g
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
 t quote
-d
-: quote
-s,[	 `~#$^&*(){}\\|;'"<>?],\\&,g
-s,\[,\\&,g
-s,\],\\&,g
-s,\$,$$,g
-p
-_ACEOF
-# We use echo to avoid assuming a particular line-breaking character.
-# The extra dot is to prevent the shell from consuming trailing
-# line-breaks from the sub-command output.  A line-break within
-# single-quotes doesn't work because, if this script is created in a
-# platform that uses two characters for line-breaks (e.g., DOS), tr
-# would break.
-ac_LF_and_DOT=`echo; echo .`
-DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
-rm -f confdef2opt.sed
+b any
+:quote
+s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
+s/\[/\\&/g
+s/\]/\\&/g
+s/\$/$$/g
+H
+:any
+${
+	g
+	s/^\n//
+	s/\n/ /g
+	p
+}
+'
+DEFS=`sed -n "$ac_script" confdefs.h`
 
 
 
 CFLAGS="${CFLAGS} ${CPPFLAGS}"; CPPFLAGS=""
 
-: ${CONFIG_STATUS=./config.status}
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
 ac_clean_files_save=$ac_clean_files
 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
-echo "$as_me: creating $CONFIG_STATUS" >&6;}
-cat >$CONFIG_STATUS <<_ACEOF
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
 #! $SHELL
 # Generated by $as_me.
 # Run this file to recreate the current configuration.
@@ -19047,81 +10692,253 @@ cat >$CONFIG_STATUS <<_ACEOF
 debug=false
 ac_cs_recheck=false
 ac_cs_silent=false
-SHELL=\${CONFIG_SHELL-$SHELL}
-_ACEOF
 
-cat >>$CONFIG_STATUS <<\_ACEOF
-## --------------------- ##
-## M4sh Initialization.  ##
-## --------------------- ##
-
-# Be Bourne compatible
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
   emulate sh
   NULLCMD=:
-  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
   # is contrary to our usage.  Disable this feature.
   alias -g '${1+"$@"}'='"$@"'
-elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
-  set -o posix
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
 fi
-DUALCASE=1; export DUALCASE # for MKS sh
 
-# Support unset when possible.
-if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
-  as_unset=unset
-else
-  as_unset=false
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
 fi
 
 
-# Work around bugs in pre-3.0 UWIN ksh.
-$as_unset ENV MAIL MAILPATH
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
 PS1='$ '
 PS2='> '
 PS4='+ '
 
 # NLS nuisances.
-for as_var in \
-  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
-  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
-  LC_TELEPHONE LC_TIME
-do
-  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
-    eval $as_var=C; export $as_var
-  else
-    $as_unset $as_var
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
   fi
-done
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
 
-# Required to use basename.
-if expr a : '\(a\)' >/dev/null 2>&1; then
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
   as_expr=expr
 else
   as_expr=false
 fi
 
-if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
   as_basename=basename
 else
   as_basename=false
 fi
 
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
 
-# Name of the executable.
-as_me=`$as_basename "$0" ||
+as_me=`$as_basename -- "$0" ||
 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)$' \| \
-	 .     : '\(.\)' 2>/dev/null ||
-echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
-  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
-  	  /^X\/\(\/\).*/{ s//\1/; q; }
-  	  s/.*/./; q'`
-
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
 
-# PATH needs CR, and LINENO needs CR and PATH.
 # Avoid depending upon Character Ranges.
 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -19129,148 +10946,111 @@ as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 as_cr_digits='0123456789'
 as_cr_alnum=$as_cr_Letters$as_cr_digits
 
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  echo "#! /bin/sh" >conf$$.sh
-  echo  "exit 0"   >>conf$$.sh
-  chmod +x conf$$.sh
-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
-    PATH_SEPARATOR=';'
-  else
-    PATH_SEPARATOR=:
-  fi
-  rm -f conf$$.sh
-fi
-
-
-  as_lineno_1=$LINENO
-  as_lineno_2=$LINENO
-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
-  test "x$as_lineno_1" != "x$as_lineno_2" &&
-  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
-  # Find who we are.  Look in the path if we contain no path at all
-  # relative or not.
-  case $0 in
-    *[\\/]* ) as_myself=$0 ;;
-    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-done
-
-       ;;
-  esac
-  # We did not find ourselves, most probably we were run as `sh COMMAND'
-  # in which case we are not to be found in the path.
-  if test "x$as_myself" = x; then
-    as_myself=$0
-  fi
-  if test ! -f "$as_myself"; then
-    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
-echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
-   { (exit 1); exit 1; }; }
-  fi
-  case $CONFIG_SHELL in
-  '')
-    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  for as_base in sh bash ksh sh5; do
-	 case $as_dir in
-	 /*)
-	   if ("$as_dir/$as_base" -c '
-  as_lineno_1=$LINENO
-  as_lineno_2=$LINENO
-  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
-  test "x$as_lineno_1" != "x$as_lineno_2" &&
-  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
-	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
-	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
-	     CONFIG_SHELL=$as_dir/$as_base
-	     export CONFIG_SHELL
-	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
-	   fi;;
-	 esac
-       done
-done
-;;
-  esac
-
-  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
-  # uniformly replaced by the line number.  The first 'sed' inserts a
-  # line-number line before each line; the second 'sed' does the real
-  # work.  The second script uses 'N' to pair each line-number line
-  # with the numbered line, and appends trailing '-' during
-  # substitution so that $LINENO is not a special case at line end.
-  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
-  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
-  sed '=' <$as_myself |
-    sed '
-      N
-      s,$,-,
-      : loop
-      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
-      t loop
-      s,-$,,
-      s,^['$as_cr_digits']*\n,,
-    ' >$as_me.lineno &&
-  chmod +x $as_me.lineno ||
-    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
-echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
-   { (exit 1); exit 1; }; }
-
-  # Don't try to exec as it changes $[0], causing all sort of problems
-  # (the dirname of $[0] is not the place where we might find the
-  # original and so on.  Autoconf is especially sensible to this).
-  . ./$as_me.lineno
-  # Exit status is that of the last command.
-  exit
-}
-
-
-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
-  *c*,-n*) ECHO_N= ECHO_C='
-' ECHO_T='	' ;;
-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
-  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
 esac
 
-if expr a : '\(a\)' >/dev/null 2>&1; then
-  as_expr=expr
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
 else
-  as_expr=false
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
 fi
-
-rm -f conf$$ conf$$.exe conf$$.file
-echo >conf$$.file
-if ln -s conf$$.file conf$$ 2>/dev/null; then
-  # We could just check for DJGPP; but this test a) works b) is more generic
-  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
-  if test -f conf$$.exe; then
-    # Don't use ln at all; we don't have any links
-    as_ln_s='cp -p'
-  else
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
     as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
   fi
-elif ln conf$$.file conf$$ 2>/dev/null; then
-  as_ln_s=ln
 else
-  as_ln_s='cp -p'
+  as_ln_s='cp -pR'
 fi
-rm -f conf$$ conf$$.exe conf$$.file
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
 
+} # as_fn_mkdir_p
 if mkdir -p . 2>/dev/null; then
-  as_mkdir_p=:
+  as_mkdir_p='mkdir -p "$as_dir"'
 else
   test -d ./-p && rmdir ./-p
   as_mkdir_p=false
 fi
 
-as_executable_p="test -f"
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
 
 # Sed expression to map a string onto a valid CPP name.
 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
@@ -19279,31 +11059,20 @@ as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 
 
-# IFS
-# We need space, tab and new line, in precisely that order.
-as_nl='
-'
-IFS=" 	$as_nl"
-
-# CDPATH.
-$as_unset CDPATH
-
 exec 6>&1
-
-# Open the log real soon, to keep \$[0] and so on meaningful, and to
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
 # report actual input values of CONFIG_FILES etc. instead of their
-# values after options handling.  Logging --version etc. is OK.
-exec 5>>config.log
-{
-  echo
-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
-## Running $as_me. ##
-_ASBOX
-} >&5
-cat >&5 <<_CSEOF
-
+# values after options handling.
+ac_log="
 This file was extended by tcl $as_me 8.5, which was
-generated by GNU Autoconf 2.59.  Invocation command line was
+generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
   CONFIG_HEADERS  = $CONFIG_HEADERS
@@ -19311,43 +11080,41 @@ generated by GNU Autoconf 2.59.  Invocation command line was
   CONFIG_COMMANDS = $CONFIG_COMMANDS
   $ $0 $@
 
-_CSEOF
-echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
-echo >&5
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
 _ACEOF
 
-# Files that config.status was made for.
-if test -n "$ac_config_files"; then
-  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
-fi
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
 
-if test -n "$ac_config_headers"; then
-  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
-fi
 
-if test -n "$ac_config_links"; then
-  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
-fi
 
-if test -n "$ac_config_commands"; then
-  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
-fi
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_commands="$ac_config_commands"
 
-cat >>$CONFIG_STATUS <<\_ACEOF
+_ACEOF
 
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 ac_cs_usage="\
-\`$as_me' instantiates files from templates according to the
-current configuration.
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
 
-Usage: $0 [OPTIONS] [FILE]...
+Usage: $0 [OPTION]... [TAG]...
 
   -h, --help       print this help, then exit
-  -V, --version    print version number, then exit
-  -q, --quiet      do not print progress messages
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
   -d, --debug      don't remove temporary files
       --recheck    update $as_me by reconfiguring in the same conditions
-  --file=FILE[:TEMPLATE]
-		   instantiate the configuration file FILE
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
 
 Configuration files:
 $config_files
@@ -19355,83 +11122,78 @@ $config_files
 Configuration commands:
 $config_commands
 
-Report bugs to <bug-autoconf@gnu.org>."
-_ACEOF
+Report bugs to the package provider."
 
-cat >>$CONFIG_STATUS <<_ACEOF
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
 tcl config.status 8.5
-configured by $0, generated by GNU Autoconf 2.59,
-  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
 
-Copyright (C) 2003 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
 This config.status script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it."
-srcdir=$srcdir
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+test -n "\$AWK" || AWK=awk
 _ACEOF
 
-cat >>$CONFIG_STATUS <<\_ACEOF
-# If no file are specified by the user, then we need to provide default
-# value.  By we need to know if files were specified by the user.
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
 ac_need_defaults=:
 while test $# != 0
 do
   case $1 in
-  --*=*)
-    ac_option=`expr "x$1" : 'x\([^=]*\)='`
-    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
     ac_shift=:
     ;;
-  -*)
+  *)
     ac_option=$1
     ac_optarg=$2
     ac_shift=shift
     ;;
-  *) # This is not an option, so the user has probably given explicit
-     # arguments.
-     ac_option=$1
-     ac_need_defaults=false;;
   esac
 
   case $ac_option in
   # Handling of the options.
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF
   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
     ac_cs_recheck=: ;;
-  --version | --vers* | -V )
-    echo "$ac_cs_version"; exit 0 ;;
-  --he | --h)
-    # Conflict between --help and --header
-    { { echo "$as_me:$LINENO: error: ambiguous option: $1
-Try \`$0 --help' for more information." >&5
-echo "$as_me: error: ambiguous option: $1
-Try \`$0 --help' for more information." >&2;}
-   { (exit 1); exit 1; }; };;
-  --help | --hel | -h )
-    echo "$ac_cs_usage"; exit 0 ;;
-  --debug | --d* | -d )
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
     debug=: ;;
   --file | --fil | --fi | --f )
     $ac_shift
-    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
-    ac_need_defaults=false;;
-  --header | --heade | --head | --hea )
-    $ac_shift
-    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
     ac_need_defaults=false;;
+  --he | --h |  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
   | -silent | --silent | --silen | --sile | --sil | --si | --s)
     ac_cs_silent=: ;;
 
   # This is an error.
-  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
-Try \`$0 --help' for more information." >&5
-echo "$as_me: error: unrecognized option: $1
-Try \`$0 --help' for more information." >&2;}
-   { (exit 1); exit 1; }; } ;;
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
 
-  *) ac_config_targets="$ac_config_targets $1" ;;
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
 
   esac
   shift
@@ -19445,43 +11207,55 @@ if $ac_cs_silent; then
 fi
 
 _ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 if \$ac_cs_recheck; then
-  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
-  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
 fi
 
 _ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
 
-cat >>$CONFIG_STATUS <<_ACEOF
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 #
-# INIT-COMMANDS section.
+# INIT-COMMANDS
 #
-
 VERSION=${TCL_VERSION}
 
 _ACEOF
 
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 
-
-cat >>$CONFIG_STATUS <<\_ACEOF
+# Handling of arguments.
 for ac_config_target in $ac_config_targets
 do
-  case "$ac_config_target" in
-  # Handling of arguments.
-  "Tcl-Info.plist" ) CONFIG_FILES="$CONFIG_FILES Tcl-Info.plist:../macosx/Tcl-Info.plist.in" ;;
-  "Tclsh-Info.plist" ) CONFIG_FILES="$CONFIG_FILES Tclsh-Info.plist:../macosx/Tclsh-Info.plist.in" ;;
-  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile:../unix/Makefile.in" ;;
-  "dltest/Makefile" ) CONFIG_FILES="$CONFIG_FILES dltest/Makefile:../unix/dltest/Makefile.in" ;;
-  "tclConfig.sh" ) CONFIG_FILES="$CONFIG_FILES tclConfig.sh:../unix/tclConfig.sh.in" ;;
-  "tcl.pc" ) CONFIG_FILES="$CONFIG_FILES tcl.pc:../unix/tcl.pc.in" ;;
-  "Tcl.framework" ) CONFIG_COMMANDS="$CONFIG_COMMANDS Tcl.framework" ;;
-  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
-echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
-   { (exit 1); exit 1; }; };;
+  case $ac_config_target in
+    "Tcl-Info.plist") CONFIG_FILES="$CONFIG_FILES Tcl-Info.plist:../macosx/Tcl-Info.plist.in" ;;
+    "Tclsh-Info.plist") CONFIG_FILES="$CONFIG_FILES Tclsh-Info.plist:../macosx/Tclsh-Info.plist.in" ;;
+    "Tcl.framework") CONFIG_COMMANDS="$CONFIG_COMMANDS Tcl.framework" ;;
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile:../unix/Makefile.in" ;;
+    "dltest/Makefile") CONFIG_FILES="$CONFIG_FILES dltest/Makefile:../unix/dltest/Makefile.in" ;;
+    "tclConfig.sh") CONFIG_FILES="$CONFIG_FILES tclConfig.sh:../unix/tclConfig.sh.in" ;;
+    "tcl.pc") CONFIG_FILES="$CONFIG_FILES tcl.pc:../unix/tcl.pc.in" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
   esac
 done
 
+
 # If the user did not use the arguments to specify the items to instantiate,
 # then the envvar interface is used.  Set only those that are not.
 # We use the long form for the default assignment because of an extremely
@@ -19492,527 +11266,427 @@ if $ac_need_defaults; then
 fi
 
 # Have a temporary directory for convenience.  Make it in the build tree
-# simply because there is no reason to put it here, and in addition,
+# simply because there is no reason against having it here, and in addition,
 # creating and moving files from /tmp can sometimes cause problems.
-# Create a temporary directory, and hook for its removal unless debugging.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
 $debug ||
 {
-  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
-  trap '{ (exit 1); exit 1; }' 1 2 13 15
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
 }
-
 # Create a (secure) tmp directory for tmp files.
 
 {
-  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
-  test -n "$tmp" && test -d "$tmp"
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
 }  ||
 {
-  tmp=./confstat$$-$RANDOM
-  (umask 077 && mkdir $tmp)
-} ||
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
 {
-   echo "$me: cannot create a temporary directory in ." >&2
-   { (exit 1); exit 1; }
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
 }
 
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
 _ACEOF
 
-cat >>$CONFIG_STATUS <<_ACEOF
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
 
-#
-# CONFIG_FILES section.
-#
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
 
-# No need to generate the scripts if there are no CONFIG_FILES.
-# This happens for instance when ./config.status config.h
-if test -n "\$CONFIG_FILES"; then
-  # Protect against being on the right side of a sed subst in config.status.
-  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
-   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
-s,@SHELL@,$SHELL,;t t
-s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
-s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
-s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
-s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
-s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
-s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
-s,@exec_prefix@,$exec_prefix,;t t
-s,@prefix@,$prefix,;t t
-s,@program_transform_name@,$program_transform_name,;t t
-s,@bindir@,$bindir,;t t
-s,@sbindir@,$sbindir,;t t
-s,@libexecdir@,$libexecdir,;t t
-s,@datadir@,$datadir,;t t
-s,@sysconfdir@,$sysconfdir,;t t
-s,@sharedstatedir@,$sharedstatedir,;t t
-s,@localstatedir@,$localstatedir,;t t
-s,@libdir@,$libdir,;t t
-s,@includedir@,$includedir,;t t
-s,@oldincludedir@,$oldincludedir,;t t
-s,@infodir@,$infodir,;t t
-s,@mandir@,$mandir,;t t
-s,@build_alias@,$build_alias,;t t
-s,@host_alias@,$host_alias,;t t
-s,@target_alias@,$target_alias,;t t
-s,@DEFS@,$DEFS,;t t
-s,@ECHO_C@,$ECHO_C,;t t
-s,@ECHO_N@,$ECHO_N,;t t
-s,@ECHO_T@,$ECHO_T,;t t
-s,@LIBS@,$LIBS,;t t
-s,@MAN_FLAGS@,$MAN_FLAGS,;t t
-s,@CC@,$CC,;t t
-s,@CFLAGS@,$CFLAGS,;t t
-s,@LDFLAGS@,$LDFLAGS,;t t
-s,@CPPFLAGS@,$CPPFLAGS,;t t
-s,@ac_ct_CC@,$ac_ct_CC,;t t
-s,@EXEEXT@,$EXEEXT,;t t
-s,@OBJEXT@,$OBJEXT,;t t
-s,@CPP@,$CPP,;t t
-s,@EGREP@,$EGREP,;t t
-s,@TCL_THREADS@,$TCL_THREADS,;t t
-s,@RANLIB@,$RANLIB,;t t
-s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
-s,@AR@,$AR,;t t
-s,@ac_ct_AR@,$ac_ct_AR,;t t
-s,@TCL_LIBS@,$TCL_LIBS,;t t
-s,@DL_LIBS@,$DL_LIBS,;t t
-s,@DL_OBJS@,$DL_OBJS,;t t
-s,@PLAT_OBJS@,$PLAT_OBJS,;t t
-s,@PLAT_SRCS@,$PLAT_SRCS,;t t
-s,@LDAIX_SRC@,$LDAIX_SRC,;t t
-s,@CFLAGS_DEBUG@,$CFLAGS_DEBUG,;t t
-s,@CFLAGS_OPTIMIZE@,$CFLAGS_OPTIMIZE,;t t
-s,@CFLAGS_WARNING@,$CFLAGS_WARNING,;t t
-s,@LDFLAGS_DEBUG@,$LDFLAGS_DEBUG,;t t
-s,@LDFLAGS_OPTIMIZE@,$LDFLAGS_OPTIMIZE,;t t
-s,@CC_SEARCH_FLAGS@,$CC_SEARCH_FLAGS,;t t
-s,@LD_SEARCH_FLAGS@,$LD_SEARCH_FLAGS,;t t
-s,@STLIB_LD@,$STLIB_LD,;t t
-s,@SHLIB_LD@,$SHLIB_LD,;t t
-s,@TCL_SHLIB_LD_EXTRAS@,$TCL_SHLIB_LD_EXTRAS,;t t
-s,@TK_SHLIB_LD_EXTRAS@,$TK_SHLIB_LD_EXTRAS,;t t
-s,@SHLIB_LD_LIBS@,$SHLIB_LD_LIBS,;t t
-s,@SHLIB_CFLAGS@,$SHLIB_CFLAGS,;t t
-s,@SHLIB_SUFFIX@,$SHLIB_SUFFIX,;t t
-s,@MAKE_LIB@,$MAKE_LIB,;t t
-s,@MAKE_STUB_LIB@,$MAKE_STUB_LIB,;t t
-s,@INSTALL_LIB@,$INSTALL_LIB,;t t
-s,@DLL_INSTALL_DIR@,$DLL_INSTALL_DIR,;t t
-s,@INSTALL_STUB_LIB@,$INSTALL_STUB_LIB,;t t
-s,@CFLAGS_DEFAULT@,$CFLAGS_DEFAULT,;t t
-s,@LDFLAGS_DEFAULT@,$LDFLAGS_DEFAULT,;t t
-s,@LIBOBJS@,$LIBOBJS,;t t
-s,@DTRACE@,$DTRACE,;t t
-s,@TCL_VERSION@,$TCL_VERSION,;t t
-s,@TCL_MAJOR_VERSION@,$TCL_MAJOR_VERSION,;t t
-s,@TCL_MINOR_VERSION@,$TCL_MINOR_VERSION,;t t
-s,@TCL_PATCH_LEVEL@,$TCL_PATCH_LEVEL,;t t
-s,@TCL_YEAR@,$TCL_YEAR,;t t
-s,@TCL_LIB_FILE@,$TCL_LIB_FILE,;t t
-s,@TCL_LIB_FLAG@,$TCL_LIB_FLAG,;t t
-s,@TCL_LIB_SPEC@,$TCL_LIB_SPEC,;t t
-s,@TCL_STUB_LIB_FILE@,$TCL_STUB_LIB_FILE,;t t
-s,@TCL_STUB_LIB_FLAG@,$TCL_STUB_LIB_FLAG,;t t
-s,@TCL_STUB_LIB_SPEC@,$TCL_STUB_LIB_SPEC,;t t
-s,@TCL_STUB_LIB_PATH@,$TCL_STUB_LIB_PATH,;t t
-s,@TCL_INCLUDE_SPEC@,$TCL_INCLUDE_SPEC,;t t
-s,@TCL_BUILD_STUB_LIB_SPEC@,$TCL_BUILD_STUB_LIB_SPEC,;t t
-s,@TCL_BUILD_STUB_LIB_PATH@,$TCL_BUILD_STUB_LIB_PATH,;t t
-s,@TCL_SRC_DIR@,$TCL_SRC_DIR,;t t
-s,@CFG_TCL_SHARED_LIB_SUFFIX@,$CFG_TCL_SHARED_LIB_SUFFIX,;t t
-s,@CFG_TCL_UNSHARED_LIB_SUFFIX@,$CFG_TCL_UNSHARED_LIB_SUFFIX,;t t
-s,@TCL_SHARED_BUILD@,$TCL_SHARED_BUILD,;t t
-s,@LD_LIBRARY_PATH_VAR@,$LD_LIBRARY_PATH_VAR,;t t
-s,@TCL_BUILD_LIB_SPEC@,$TCL_BUILD_LIB_SPEC,;t t
-s,@TCL_LIB_VERSIONS_OK@,$TCL_LIB_VERSIONS_OK,;t t
-s,@TCL_SHARED_LIB_SUFFIX@,$TCL_SHARED_LIB_SUFFIX,;t t
-s,@TCL_UNSHARED_LIB_SUFFIX@,$TCL_UNSHARED_LIB_SUFFIX,;t t
-s,@TCL_HAS_LONGLONG@,$TCL_HAS_LONGLONG,;t t
-s,@INSTALL_TZDATA@,$INSTALL_TZDATA,;t t
-s,@DTRACE_SRC@,$DTRACE_SRC,;t t
-s,@DTRACE_HDR@,$DTRACE_HDR,;t t
-s,@DTRACE_OBJ@,$DTRACE_OBJ,;t t
-s,@MAKEFILE_SHELL@,$MAKEFILE_SHELL,;t t
-s,@BUILD_DLTEST@,$BUILD_DLTEST,;t t
-s,@TCL_PACKAGE_PATH@,$TCL_PACKAGE_PATH,;t t
-s,@TCL_MODULE_PATH@,$TCL_MODULE_PATH,;t t
-s,@TCL_LIBRARY@,$TCL_LIBRARY,;t t
-s,@PRIVATE_INCLUDE_DIR@,$PRIVATE_INCLUDE_DIR,;t t
-s,@HTML_DIR@,$HTML_DIR,;t t
-s,@EXTRA_CC_SWITCHES@,$EXTRA_CC_SWITCHES,;t t
-s,@EXTRA_APP_CC_SWITCHES@,$EXTRA_APP_CC_SWITCHES,;t t
-s,@EXTRA_INSTALL@,$EXTRA_INSTALL,;t t
-s,@EXTRA_INSTALL_BINARIES@,$EXTRA_INSTALL_BINARIES,;t t
-s,@EXTRA_BUILD_HTML@,$EXTRA_BUILD_HTML,;t t
-s,@EXTRA_TCLSH_LIBS@,$EXTRA_TCLSH_LIBS,;t t
-s,@DLTEST_LD@,$DLTEST_LD,;t t
-s,@DLTEST_SUFFIX@,$DLTEST_SUFFIX,;t t
-CEOF
 
-_ACEOF
+eval set X "  :F $CONFIG_FILES      :C $CONFIG_COMMANDS"
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
 
-  cat >>$CONFIG_STATUS <<\_ACEOF
-  # Split the substitutions into bite-sized pieces for seds with
-  # small command number limits, like on Digital OSF/1 and HP-UX.
-  ac_max_sed_lines=48
-  ac_sed_frag=1 # Number of current file.
-  ac_beg=1 # First line for current file.
-  ac_end=$ac_max_sed_lines # Line after last line for current file.
-  ac_more_lines=:
-  ac_sed_cmds=
-  while $ac_more_lines; do
-    if test $ac_beg -gt 1; then
-      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
-    else
-      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
-    fi
-    if test ! -s $tmp/subs.frag; then
-      ac_more_lines=false
-    else
-      # The purpose of the label and of the branching condition is to
-      # speed up the sed processing (if there are no `@' at all, there
-      # is no need to browse any of the substitutions).
-      # These are the two extra sed commands mentioned above.
-      (echo ':t
-  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
-      if test -z "$ac_sed_cmds"; then
-	ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
-      else
-	ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
-      fi
-      ac_sed_frag=`expr $ac_sed_frag + 1`
-      ac_beg=$ac_end
-      ac_end=`expr $ac_end + $ac_max_sed_lines`
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
     fi
-  done
-  if test -z "$ac_sed_cmds"; then
-    ac_sed_cmds=cat
-  fi
-fi # test -n "$CONFIG_FILES"
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
 
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF
-for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
-  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
-  case $ac_file in
-  - | *:- | *:-:* ) # input from stdin
-	cat >$tmp/stdin
-	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
-	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
-  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
-	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
-  * )   ac_file_in=$ac_file.in ;;
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
   esac
 
-  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
-  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+  ac_dir=`$as_dirname -- "$ac_file" ||
 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 	 X"$ac_file" : 'X\(//\)[^/]' \| \
 	 X"$ac_file" : 'X\(//\)$' \| \
-	 X"$ac_file" : 'X\(/\)' \| \
-	 .     : '\(.\)' 2>/dev/null ||
-echo X"$ac_file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
-  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
-  	  /^X\(\/\/\)$/{ s//\1/; q; }
-  	  /^X\(\/\).*/{ s//\1/; q; }
-  	  s/.*/./; q'`
-  { if $as_mkdir_p; then
-    mkdir -p "$ac_dir"
-  else
-    as_dir="$ac_dir"
-    as_dirs=
-    while test ! -d "$as_dir"; do
-      as_dirs="$as_dir $as_dirs"
-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| \
-	 .     : '\(.\)' 2>/dev/null ||
-echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
-  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
-  	  /^X\(\/\/\)$/{ s//\1/; q; }
-  	  /^X\(\/\).*/{ s//\1/; q; }
-  	  s/.*/./; q'`
-    done
-    test ! -n "$as_dirs" || mkdir $as_dirs
-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
-   { (exit 1); exit 1; }; }; }
-
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
   ac_builddir=.
 
-if test "$ac_dir" != .; then
-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
-  # A "../" for each directory in $ac_dir_suffix.
-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
-else
-  ac_dir_suffix= ac_top_builddir=
-fi
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
 
 case $srcdir in
-  .)  # No --srcdir option.  We are building in place.
+  .)  # We are building in place.
     ac_srcdir=.
-    if test -z "$ac_top_builddir"; then
-       ac_top_srcdir=.
-    else
-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
-    fi ;;
-  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
     ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir ;;
-  *) # Relative path.
-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
-esac
-
-# Do not use `cd foo && pwd` to compute absolute paths, because
-# the directories may not exist.
-case `pwd` in
-.) ac_abs_builddir="$ac_dir";;
-*)
-  case "$ac_dir" in
-  .) ac_abs_builddir=`pwd`;;
-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_top_builddir=${ac_top_builddir}.;;
-*)
-  case ${ac_top_builddir}. in
-  .) ac_abs_top_builddir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_srcdir=$ac_srcdir;;
-*)
-  case $ac_srcdir in
-  .) ac_abs_srcdir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
-  esac;;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
 esac
-case $ac_abs_builddir in
-.) ac_abs_top_srcdir=$ac_top_srcdir;;
-*)
-  case $ac_top_srcdir in
-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
-  esac;;
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
 esac
-
-
-
-  if test x"$ac_file" != x-; then
-    { echo "$as_me:$LINENO: creating $ac_file" >&5
-echo "$as_me: creating $ac_file" >&6;}
-    rm -f "$ac_file"
-  fi
-  # Let's still pretend it is `configure' which instantiates (i.e., don't
-  # use $as_me), people would be surprised to read:
-  #    /* config.h.  Generated by config.status.  */
-  if test x"$ac_file" = x-; then
-    configure_input=
-  else
-    configure_input="$ac_file.  "
-  fi
-  configure_input=$configure_input"Generated from `echo $ac_file_in |
-				     sed 's,.*/,,'` by configure."
-
-  # First look for the input files in the build tree, otherwise in the
-  # src tree.
-  ac_file_inputs=`IFS=:
-    for f in $ac_file_in; do
-      case $f in
-      -) echo $tmp/stdin ;;
-      [\\/$]*)
-	 # Absolute (can't be DOS-style, as IFS=:)
-	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
-echo "$as_me: error: cannot find input file: $f" >&2;}
-   { (exit 1); exit 1; }; }
-	 echo "$f";;
-      *) # Relative
-	 if test -f "$f"; then
-	   # Build tree
-	   echo "$f"
-	 elif test -f "$srcdir/$f"; then
-	   # Source tree
-	   echo "$srcdir/$f"
-	 else
-	   # /dev/null tree
-	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
-echo "$as_me: error: cannot find input file: $f" >&2;}
-   { (exit 1); exit 1; }; }
-	 fi;;
-      esac
-    done` || { (exit 1); exit 1; }
 _ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF
-  sed "$ac_vpsub
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
 $extrasub
 _ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 :t
 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
-s,@configure_input@,$configure_input,;t t
-s,@srcdir@,$ac_srcdir,;t t
-s,@abs_srcdir@,$ac_abs_srcdir,;t t
-s,@top_srcdir@,$ac_top_srcdir,;t t
-s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
-s,@builddir@,$ac_builddir,;t t
-s,@abs_builddir@,$ac_abs_builddir,;t t
-s,@top_builddir@,$ac_top_builddir,;t t
-s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
-" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
-  rm -f $tmp/stdin
-  if test x"$ac_file" != x-; then
-    mv $tmp/out $ac_file
-  else
-    cat $tmp/out
-    rm -f $tmp/out
-  fi
-
-done
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF
-
-#
-# CONFIG_COMMANDS section.
-#
-for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
-  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
-  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
-  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
-$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$ac_dest" : 'X\(//\)[^/]' \| \
-	 X"$ac_dest" : 'X\(//\)$' \| \
-	 X"$ac_dest" : 'X\(/\)' \| \
-	 .     : '\(.\)' 2>/dev/null ||
-echo X"$ac_dest" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
-  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
-  	  /^X\(\/\/\)$/{ s//\1/; q; }
-  	  /^X\(\/\).*/{ s//\1/; q; }
-  	  s/.*/./; q'`
-  { if $as_mkdir_p; then
-    mkdir -p "$ac_dir"
-  else
-    as_dir="$ac_dir"
-    as_dirs=
-    while test ! -d "$as_dir"; do
-      as_dirs="$as_dir $as_dirs"
-      as_dir=`(dirname "$as_dir") 2>/dev/null ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| \
-	 .     : '\(.\)' 2>/dev/null ||
-echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
-  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
-  	  /^X\(\/\/\)$/{ s//\1/; q; }
-  	  /^X\(\/\).*/{ s//\1/; q; }
-  	  s/.*/./; q'`
-    done
-    test ! -n "$as_dirs" || mkdir $as_dirs
-  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
-echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
-   { (exit 1); exit 1; }; }; }
-
-  ac_builddir=.
-
-if test "$ac_dir" != .; then
-  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
-  # A "../" for each directory in $ac_dir_suffix.
-  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
-else
-  ac_dir_suffix= ac_top_builddir=
-fi
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
 
-case $srcdir in
-  .)  # No --srcdir option.  We are building in place.
-    ac_srcdir=.
-    if test -z "$ac_top_builddir"; then
-       ac_top_srcdir=.
-    else
-       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
-    fi ;;
-  [\\/]* | ?:[\\/]* )  # Absolute path.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir ;;
-  *) # Relative path.
-    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_builddir$srcdir ;;
-esac
 
-# Do not use `cd foo && pwd` to compute absolute paths, because
-# the directories may not exist.
-case `pwd` in
-.) ac_abs_builddir="$ac_dir";;
-*)
-  case "$ac_dir" in
-  .) ac_abs_builddir=`pwd`;;
-  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
-  *) ac_abs_builddir=`pwd`/"$ac_dir";;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_top_builddir=${ac_top_builddir}.;;
-*)
-  case ${ac_top_builddir}. in
-  .) ac_abs_top_builddir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
-  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_srcdir=$ac_srcdir;;
-*)
-  case $ac_srcdir in
-  .) ac_abs_srcdir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
-  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
-  esac;;
-esac
-case $ac_abs_builddir in
-.) ac_abs_top_srcdir=$ac_top_srcdir;;
-*)
-  case $ac_top_srcdir in
-  .) ac_abs_top_srcdir=$ac_abs_builddir;;
-  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
-  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
-  esac;;
-esac
+  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+$as_echo "$as_me: executing $ac_file commands" >&6;}
+ ;;
+  esac
 
 
-  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
-echo "$as_me: executing $ac_dest commands" >&6;}
-  case $ac_dest in
-    Tcl.framework ) n=Tcl &&
+  case $ac_file$ac_mode in
+    "Tcl.framework":C) n=Tcl &&
         f=$n.framework && v=Versions/$VERSION &&
         rm -rf $f && mkdir -p $f/$v/Resources &&
         ln -s $v/$n $v/Resources $f && ln -s ../../../$n $f/$v &&
         ln -s ../../../../$n-Info.plist $f/$v/Resources/Info.plist &&
         unset n f v
      ;;
+
   esac
-done
-_ACEOF
+done # for ac_tag
 
-cat >>$CONFIG_STATUS <<\_ACEOF
 
-{ (exit 0); exit 0; }
+as_fn_exit 0
 _ACEOF
-chmod +x $CONFIG_STATUS
 ac_clean_files=$ac_clean_files_save
 
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
 
 # configure is writing to config.log, and then calls config.status.
 # config.status does its own redirection, appending to config.log.
@@ -20032,6 +11706,10 @@ if test "$no_create" != yes; then
   exec 5>>config.log
   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
   # would make configure fail if this is the last instruction.
-  $ac_cs_success || { (exit 1); exit 1; }
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
 fi
 
diff --git a/unix/configure.in b/unix/configure.in
index e4255b6..7ef450d 100644
--- a/unix/configure.in
+++ b/unix/configure.in
@@ -519,8 +519,6 @@ if test "`uname -s`" = "Darwin" ; then
 	[Are we to override what our default encoding is?])
     AC_DEFINE(TCL_LOAD_FROM_MEMORY, 1,
 	[Can this platform load code from memory?])
-    AC_DEFINE(TCL_WIDE_CLICKS, 1,
-	[Does this platform have wide high-resolution clicks?])
     AC_CHECK_HEADERS(AvailabilityMacros.h)
     if test "$ac_cv_header_AvailabilityMacros_h" = yes; then
 	AC_CACHE_CHECK([if weak import is available], tcl_cv_cc_weak_import, [
@@ -568,6 +566,11 @@ else
     DLTEST_SUFFIX=""
 fi
 
+# Completelly supports on unix (linux/darwin)
+AC_DEFINE(TCL_WIDE_CLICKS, 1,
+    [Does this platform have wide high-resolution clicks?])
+
+
 #--------------------------------------------------------------------
 # Check for support of fts functions (readdir replacement)
 #--------------------------------------------------------------------
diff --git a/unix/tclUnixTime.c b/unix/tclUnixTime.c
index f50a66f..96ec73b 100644
--- a/unix/tclUnixTime.c
+++ b/unix/tclUnixTime.c
@@ -176,30 +176,8 @@ TclpGetUTimeMonotonic(void)
 unsigned long
 TclpGetClicks(void)
 {
-    unsigned long now;
-
-#ifdef NO_GETTOD
-    if (tclGetTimeProcPtr != NativeGetTime) {
-	Tcl_Time time;
-
-	(*tclGetTimeProcPtr) (&time, tclTimeClientData);
-	now = time.sec*1000000 + time.usec;
-    } else {
-	/*
-	 * A semi-NativeGetTime, specialized to clicks.
-	 */
-	struct tms dummy;
-
-	now = (unsigned long) times(&dummy);
-    }
-#else
-    Tcl_Time time;
-
-    (*tclGetTimeProcPtr) (&time, tclTimeClientData);
-    now = time.sec*1000000 + time.usec;
-#endif
-
-    return now;
+    /* clicks should provide monotonic intervals */
+    return (unsigned long) TclpGetUTimeMonotonic();
 }
 #ifdef TCL_WIDE_CLICKS
 
@@ -227,17 +205,23 @@ TclpGetWideClicks(void)
 {
     Tcl_WideInt now;
 
-    if (tclGetTimeProcPtr != NativeGetTime) {
+    if (tclGetTimeProcPtr == NativeGetTime) {
+#ifndef MAC_OSX_TCL
+    	/* 1 wide click == 0.001 microseconds (1 nanosecond) */
+	struct timespec mntv;
+	
+	(void)clock_gettime(CLOCK_MONOTONIC, &mntv);
+	return ((Tcl_WideInt)mntv.tv_sec)*1000000*1000 + mntv.tv_nsec;
+#else	/* MAC_OSX_TCL: */
+	/* 1 wide click == (tb.numer / tb.denom / 1000) microseconds */
+	return (Tcl_WideInt) (mach_absolute_time() & INT64_MAX);
+#endif
+    } else {
+	/* 1 wide click == 1 microsecond (1000 nanoseconds) */
 	Tcl_Time time;
 
 	(*tclGetTimeProcPtr) (&time, tclTimeClientData);
 	now = ((Tcl_WideInt)time.sec)*1000000 + time.usec;
-    } else {
-#ifdef MAC_OSX_TCL
-	now = (Tcl_WideInt) (mach_absolute_time() & INT64_MAX);
-#else
-#error Wide high-resolution clicks not implemented on this platform
-#endif
     }
 
     return now;
@@ -266,10 +250,12 @@ TclpWideClicksToNanoseconds(
 {
     double nsec;
 
-    if (tclGetTimeProcPtr != NativeGetTime) {
-	nsec = clicks * 1000;
-    } else {
-#ifdef MAC_OSX_TCL
+    if (tclGetTimeProcPtr == NativeGetTime) {
+#ifndef MAC_OSX_TCL
+	/* 1 wide click == 0.001 microseconds (1 nanosecond) */
+	return clicks;
+#else	/* MAC_OSX_TCL: */
+	/* 1 wide click == (tb.numer / tb.denom) nanoseconds */
 	static mach_timebase_info_data_t tb;
 	static uint64_t maxClicksForUInt64;
 	
@@ -282,9 +268,10 @@ TclpWideClicksToNanoseconds(
 	} else {
 	    nsec = ((long double) (uint64_t) clicks) * tb.numer / tb.denom;
 	}
-#else
-#error Wide high-resolution clicks not implemented on this platform
 #endif
+    } else {
+	/* 1 wide click == 1 microsecond (1000 nanoseconds) */
+	nsec = clicks * 1000;
     }
 
     return nsec;
@@ -311,10 +298,12 @@ TclpWideClicksToNanoseconds(
 double
 TclpWideClickInMicrosec(void)
 {
-    if (tclGetTimeProcPtr != NativeGetTime) {
-	return 1.0;
-    } else {
-#ifdef MAC_OSX_TCL
+    if (tclGetTimeProcPtr == NativeGetTime) {
+#ifndef MAC_OSX_TCL
+	/* 1 wide click == 0.001 microseconds (1 nanosecond) */
+	return 0.001;
+#else	/* MAC_OSX_TCL: */
+	/* 1 wide click == (tb.numer / tb.denom / 1000) microseconds */
 	static int initialized = 0;
 	static double scale = 0.0;
 
@@ -329,9 +318,10 @@ TclpWideClickInMicrosec(void)
 	    initialized = 1;
 	    return scale;
 	}
-#else
-#error Wide high-resolution clicks not implemented on this platform
 #endif
+    } else {
+	/* 1 wide click == 1 microsecond (1000 nanoseconds) */
+	return 1.0;
     }
 }
 #endif /* TCL_WIDE_CLICKS */
-- 
cgit v0.12


From 0e4432a80db28d9dd87ba13040ea37b69b78733c Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:15 +0000
Subject: fix check event source threshold (corresponds 100-ns ranges, if the
 wide-clicks supported); because of variable width of 1 wide-click: windows -
 frequency dependent, unix - nanoseconds, darwin/osx - tb.numer / tb.denom
 nanoseconds.

---
 generic/tclNotify.c | 89 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 51 insertions(+), 38 deletions(-)

diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index 063954e..b16dea7 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -33,7 +33,8 @@ typedef struct EventSource {
 
 /*
  * Used for performance purposes, threshold to bypass check source (if don't wait)
- * Values under 1000 should be approximately under 1ms, e. g. 5 is ca. 0.005ms
+ * Value should be approximately correspond 100-ns ranges, if the wide-clicks
+ * supported, it is more precise so e. g. 5 is ca. 0.5 microseconds (500-ns).
  */
 #ifndef TCL_CHECK_EVENT_SOURCE_THRESHOLD
     #define TCL_CHECK_EVENT_SOURCE_THRESHOLD 5
@@ -890,8 +891,45 @@ Tcl_ServiceEvent(
 
     return 0;
 }
+
+#if TCL_CHECK_EVENT_SOURCE_THRESHOLD
+/*
+ *----------------------------------------------------------------------
+ *
+ * CheckSourceThreshold --
+ *
+ *	Check whether we should iterate over event sources for availability.
+ *
+ *	This is used to avoid too unneeded overhead (too often call checkProc).
+ *
+ * Results:
+ *	Returns 1 if threshold reached (check event sources), 0 otherwise.
+ *
+ *----------------------------------------------------------------------
+ */
 
-
+static inline int
+CheckSourceThreshold(
+    ThreadSpecificData *tsdPtr)
+{
+    /* don't need to wait/check for events too often */
+#ifndef TCL_WIDE_CLICKS
+    unsigned long clickdiff, clicks = TclpGetClicks();
+#else
+    Tcl_WideInt clickdiff, clicks;
+    /* in 100-ns */
+    clicks = TclpGetWideClicks() * (TclpWideClickInMicrosec() * 10);
+#endif
+    /* considering possible clicks-jump */
+    if ( (clickdiff = (clicks - tsdPtr->lastCheckClicks)) >= 0
+      && clickdiff <= TCL_CHECK_EVENT_SOURCE_THRESHOLD) {
+	return 0;
+    }
+    tsdPtr->lastCheckClicks = clicks;
+    return 1;
+}
+#endif
+
 /*
  *----------------------------------------------------------------------
  *
@@ -936,19 +974,11 @@ TclPeekEventQueued(
 	}
 
 	if (flags & TCL_DONT_WAIT) {
-    #if TCL_CHECK_EVENT_SOURCE_THRESHOLD
 	    /* don't need to wait/check for events too often */
-	#ifndef TCL_WIDE_CLICKS
-	    unsigned long clickdiff, clicks = TclpGetClicks();
-	#else
-	    Tcl_WideInt clickdiff, clicks = TclpGetWideClicks();
-	#endif
-	    /* considering possible clicks-jump */
-	    if ( (clickdiff = (clicks - tsdPtr->lastCheckClicks)) >= 0 
-	      && clickdiff <= TCL_CHECK_EVENT_SOURCE_THRESHOLD) {
+    #if TCL_CHECK_EVENT_SOURCE_THRESHOLD
+	    if (!CheckSourceThreshold(tsdPtr)) {
 		return 0;
 	    }
-	    tsdPtr->lastCheckClicks = clicks;
     #endif
 	}
 
@@ -966,8 +996,7 @@ TclPeekEventQueued(
 
     return 0;
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1004,8 +1033,7 @@ TclSetTimerEventMarker(
 	};
     }
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1029,8 +1057,7 @@ Tcl_GetServiceMode(void)
 
     return tsdPtr->serviceMode;
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1062,8 +1089,7 @@ Tcl_SetServiceMode(
     }
     return oldMode;
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1107,8 +1133,7 @@ Tcl_SetMaxBlockTime(
 	Tcl_SetTimer(&tsdPtr->blockTime);
     }
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1222,19 +1247,10 @@ Tcl_DoOneEvent(
 
 	    /* don't need to wait/check for events too often */
     #if TCL_CHECK_EVENT_SOURCE_THRESHOLD
-	#ifndef TCL_WIDE_CLICKS
-	    unsigned long clickdiff, clicks = TclpGetClicks();
-	#else
-	    Tcl_WideInt clickdiff, clicks = TclpGetWideClicks();
-	#endif
-	    /* considering possible clicks-jump */
-	    if ( (clickdiff = (clicks - tsdPtr->lastCheckClicks)) >= 0 
-	      && clickdiff <= TCL_CHECK_EVENT_SOURCE_THRESHOLD) {
+	    if (!CheckSourceThreshold(tsdPtr)) {
 		goto idleEvents;
 	    }
-	    tsdPtr->lastCheckClicks = clicks;
     #endif
-
 	    tsdPtr->blockTime.sec = 0;
 	    tsdPtr->blockTime.usec = 0;
 	    tsdPtr->blockTimeSet = 1;
@@ -1334,8 +1350,7 @@ Tcl_DoOneEvent(
     tsdPtr->serviceMode = oldMode;
     return result;
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1420,8 +1435,7 @@ Tcl_ServiceAll(void)
     tsdPtr->serviceMode = TCL_SERVICE_ALL;
     return result;
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1462,8 +1476,7 @@ Tcl_ThreadAlert(
     }
     Tcl_MutexUnlock(&listLock);
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
-- 
cgit v0.12


From 0a588d204138059ddc43ebceb74de18ccf9c7836 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:19 +0000
Subject: code review and small optimizations

---
 generic/tclNotify.c | 18 ++++++++++--------
 unix/tclUnixNotfy.c | 55 ++++++++++++++++++++++++++---------------------------
 2 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index b16dea7..0dd55c4 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -726,17 +726,18 @@ Tcl_ServiceEvent(
 	}
     }
 
+    /* Fast bypass case */
+    if ( !tsdPtr->firstEventPtr /* no other events */
+      || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
+    ) {
+	goto timer;
+    }
+
     /*
      * If timer marker reached, process timer events now.
      */
-    if (flags & TCL_TIMER_EVENTS) { /* timer allowed */
-	if ( tsdPtr->timerMarkerPtr == INT2PTR(-1) /* timer-event reached */
-	  || ( tsdPtr->timerMarkerPtr == INT2PTR(-2) /* next cycle, but ... */
-	    && ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */
-	  )
-	) {
-	    goto processTimer;
-	}
+    if ((flags & TCL_TIMER_EVENTS) && (tsdPtr->timerMarkerPtr == INT2PTR(-1))) {
+	goto processTimer;
     }
 
     /*
@@ -845,6 +846,7 @@ Tcl_ServiceEvent(
     }
     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
 
+  timer:
     /*
      * Process timer queue, if alloved and timers are enabled.
      */
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index db10512..87f88d7 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -871,7 +871,7 @@ void
 TclpUSleep(
     Tcl_WideInt usec)	/* Time to sleep. */
 {
-    Tcl_WideInt now, desired, sleepTime;
+    Tcl_WideInt now, desired;
 
     if (usec < 0) {
 	usec = 0;
@@ -903,24 +903,19 @@ TclpUSleep(
 	    delay.tv_sec  = usec / 1000000;
 	    delay.tv_usec = usec % 1000000;
 
-	    sleepTime = usec;
 	    (void) select(0, (SELECT_MASK *) 0, (SELECT_MASK *) 0,
 		(SELECT_MASK *) 0, &delay);
 
 	} else if (usec >= TCL_TMR_MIN_SLEEP) {
-	    sleepTime = usec - TCL_TMR_MIN_SLEEP;
-	    usleep(sleepTime);
+	    usleep((useconds_t)(usec - TCL_TMR_MIN_SLEEP));
 	} else {
 	    /* nanosleep has the same minimal sleep interval as usleep */
-#if 1
-	    sleepTime = 0;
-#else
+#if 0
 	    struct timespec delay;
 
 	    delay.tv_sec  = usec / 1000000;
 	    delay.tv_nsec = (usec % 1000000) * 1000; /* usec to nsec */
 
-	    sleepTime = usec;
 	    nanosleep(&delay, NULL);
 #endif
 	}
@@ -991,17 +986,18 @@ Tcl_WaitForEvent(
 
 	waitTime = TCL_TIME_TO_USEC(*timePtr);
 
-	/*
-	 * Note the time can be switched (time-jump), so use monotonic time here.
-	 */
-	endTime = TclpGetUTimeMonotonic() + waitTime;
-
 	/* 
 	 * If short wait or no wait at all, just process events already available
 	 * right now, avoid waiting too long somewhere (NRT-capability fix).
 	 */
 	if (!timePtr->sec && timePtr->usec < TCL_TMR_MIN_DELAY) {
+
 	    canWait = 0;
+	} else {
+	    /*
+	     * Note the time can be switched (time-jump), so use monotonic time here.
+	     */
+	    endTime = TclpGetUTimeMonotonic() + waitTime;
 	}
 
 #ifndef TCL_THREADS
@@ -1038,6 +1034,7 @@ Tcl_WaitForEvent(
 	goto nowait;
     }
 
+    waitForFiles = (tsdPtr->numFdBits > 0);
     if (!canWait) {
 	/*
 	 * Cannot emulate a polling select with a polling condition
@@ -1047,10 +1044,10 @@ Tcl_WaitForEvent(
 	 * state as ours currently is. We block until that happens.
 	 */
 
-	waitForFiles = 1;
-	tsdPtr->pollState = POLL_WANT;
+	if (waitForFiles) {
+	    tsdPtr->pollState = POLL_WANT;
+	}
     } else {
-	waitForFiles = (tsdPtr->numFdBits > 0);
 	tsdPtr->pollState = 0;
     }
 
@@ -1083,7 +1080,7 @@ Tcl_WaitForEvent(
 
     while (!tsdPtr->eventReady) {
 
-	if (timePtr) {
+	if (canWait && timePtr) {
 
 	    waitTime = endTime - TclpGetUTimeMonotonic();
 
@@ -1095,7 +1092,7 @@ Tcl_WaitForEvent(
 	    }
 	}
 
-#ifdef __CYGWIN__
+#  ifdef __CYGWIN__
 	if (!PeekMessageW(&msg, NULL, 0, 0, 0)) {
 	    DWORD timeout;
 
@@ -1111,11 +1108,13 @@ Tcl_WaitForEvent(
 	    MsgWaitForMultipleObjects(1, &tsdPtr->event, 0, timeout, 1279);
 	    pthread_mutex_lock(&notifierMutex);
 	}
-#else
+#  else
 	/* prevent too long waiting (NRT-capability) */
 	if ( !canWait ) {
 	    /* short sleep */
-	    TclpUSleep(waitTime);
+	    if (waitTime) {
+		TclpUSleep(waitTime);
+	    }
 	    break; /* end of wait */
 	}
 	else
@@ -1134,7 +1133,7 @@ Tcl_WaitForEvent(
 		ptime.tv_sec++;
 	    }
 
-#if defined(__APPLE__) && defined(__LP64__)
+#    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
@@ -1146,7 +1145,7 @@ Tcl_WaitForEvent(
 		ptime.tv_sec = now.sec;
 		ptime.tv_nsec = 1000 * now.usec + 10; /* + 10 nanosecond */
 	    }
-#else
+#    else
 	    /* remove overhead in nsec */
 	    if (ptime.tv_nsec < TCL_TMR_OVERHEAD * 1000) {
 	    	ptime.tv_nsec += 1000000*1000;
@@ -1154,7 +1153,7 @@ Tcl_WaitForEvent(
 	    }
 	    ptime.tv_nsec -= TCL_TMR_OVERHEAD * 1000;
 	    
-#endif /* __APPLE__ && __LP64__ */
+#    endif /* __APPLE__ && __LP64__ */
 
 	    if (ptime.tv_nsec > 1000000*1000) {
 		ptime.tv_nsec -= 1000000*1000;
@@ -1167,7 +1166,7 @@ Tcl_WaitForEvent(
 	} else {
 	    pthread_cond_wait(&tsdPtr->waitCV, &notifierMutex);
 	}
-#endif /* __CYGWIN__ */
+#  endif /* __CYGWIN__ */
 
 	break; /* end of wait */
     }
@@ -1175,7 +1174,7 @@ Tcl_WaitForEvent(
 	tsdPtr->eventReady--;
     }
 
-#ifdef __CYGWIN__
+#  ifdef __CYGWIN__
     while (PeekMessageW(&msg, NULL, 0, 0, 0)) {
 	/*
 	 * Retrieve and dispatch the message.
@@ -1192,7 +1191,7 @@ Tcl_WaitForEvent(
 	}
     }
     ResetEvent(tsdPtr->event);
-#endif /* __CYGWIN__ */
+#  endif /* __CYGWIN__ */
 
     if (waitForFiles && tsdPtr->onList) {
 	/*
@@ -1218,7 +1217,7 @@ Tcl_WaitForEvent(
 	}
     }
 
-#else
+#else /* !TCL_THREADS */
     tsdPtr->readyMasks = tsdPtr->checkMasks;
     numFound = select(tsdPtr->numFdBits, &tsdPtr->readyMasks.readable,
 	    &tsdPtr->readyMasks.writable, &tsdPtr->readyMasks.exception,
@@ -1234,7 +1233,7 @@ Tcl_WaitForEvent(
 	FD_ZERO(&tsdPtr->readyMasks.writable);
 	FD_ZERO(&tsdPtr->readyMasks.exception);
     }
-#endif /* TCL_THREADS */
+#endif /* !TCL_THREADS */
 
     /*
      * Queue all detected file events before returning.
-- 
cgit v0.12


From b6086dc8f3a848a02491d01415b6f379ef0b1284 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:24 +0000
Subject: after at: added simple workaround for absolute timers/sleep ("after
 at real-time"): because we use monotonic time in all wait functions, so to
 avoid too long wait by the absolute timers (to be able to trigger it) if time
 jumped to the expected absolute time, just let block for maximal 1 second if
 absolute timers available.

test-cases: time-jumps (TIP #302) test covered now.
Note: on some platforms it is only possible if the user has corresponding privileges to change system date and time.
Ex.:  sudo LD_LIBRARY_PATH=. ./tclsh ../tests/timer.test -match timer-20.*
---
 generic/tclTimer.c |  29 ++++++++-
 tests/timer.test   | 174 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 200 insertions(+), 3 deletions(-)

diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 074b61d..d22d326 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -943,9 +943,24 @@ TimerSetupProc(
 	#endif
 
 	if (timeOffs > 0) {
-	    blockTime.sec = (long) (timeOffs / 1000000);
-	    blockTime.usec = (unsigned long) (timeOffs % 1000000);
-
+	    blockTime.sec = 0;
+	    if (timeOffs >= 1000000) {
+		/*
+		 * Note we use monotonic time by all wait functions, so to
+		 * avoid too long wait by the absolute timers (to be able
+		 * to trigger it) if time jumped to the expected time, just
+		 * let block for maximal 1s if absolute timers available.
+		 */
+		if (tsdPtr->absTimerList) {
+		    /* we've some absolute timers - won't wait longer as 1s. */
+		    timeOffs = 1000000;
+		}
+		blockTime.sec = (long) (timeOffs / 1000000);
+		blockTime.usec = (unsigned long)(timeOffs % 1000000);
+	    } else {
+		blockTime.sec = 0;
+		blockTime.usec = (unsigned long)timeOffs;
+	    }
 	} else {
 	    blockTime.sec = 0;
 	    blockTime.usec = 0;
@@ -1792,6 +1807,14 @@ AfterDelay(
 	    }
 	}
 	diff = endTime - now;
+	if (absolute && diff >= 1000000) {
+	    /*
+	     * Note by absolute sleep we should avoid too long waits, to be
+	     * able to process further if time jumped to the expected time, so
+	     * just let wait maximal 1 second.
+	     */
+	    diff = 1000000;
+	}
 	if (iPtr->limit.timeEvent == NULL || diff < limOffs) {
 	    if (diff > 0) {
 		TclpUSleep(diff);
diff --git a/tests/timer.test b/tests/timer.test
index 2dbcae3..0b20d71 100644
--- a/tests/timer.test
+++ b/tests/timer.test
@@ -581,6 +581,180 @@ test timer-11.3 {[after] correct timer ordering (insert ahead)} \
     } \
     -result {ev:0 ev:0.1 ev:0.25 ev:0.5 ev:0.75 ev:1}
 
+# -----------------------------------------------------------------------------
+# 
+# timer-20.x --
+# 
+#    Following test-cases cover event-driven functionality during time-jump's
+#
+#    Note: on some platforms it is only possible if the user has corresponding
+#          privileges to change system date and time.
+#
+# Ex.:  sudo LD_LIBRARY_PATH=. ./tclsh ../tests/timer.test -match timer-20.*
+# -----------------------------------------------------------------------------
+
+proc timejump {args} {
+  set tnow [clock clicks]
+  set tm [clock format [clock add [clock seconds] {*}$args] -format %H:%M:%S]
+  #puts -nonewline "***[format \[%04X\] [pid]]*** jump to $tm ($args) "
+  if {$::tcl_platform(platform) eq "windows"} {
+    exec $::env(COMSPEC) /c time $tm
+  } else {
+    exec date +%T -s $tm
+  }
+  #puts "***[format \[%04X\] [pid]]*** [clock format [clock seconds] -format {%Y-%m-%d %H:%M:%S}] =="
+}
+
+testConstraint ChangeTimePrivilege [expr {![catch { timejump 0 minutes }]}]
+testConstraint NewVWaitAfter	   [expr {![catch { vwait 0 nothing }]}]
+
+# provide monotonic command, if "clock monotonic" not available (old core):
+if {![catch {::tcl::clock::monotonic}]} {
+  namespace inscope ::tcl::clock {namespace export monotonic}
+  namespace import ::tcl::clock::monotonic
+} else {
+  proc monotonic {} {
+    variable tickFactor
+    # warming-up:
+    clock clicks; clock microseconds
+    # calc tick2usec factor:
+    set tick [::tcl::clock::clicks]; set usec [::tcl::clock::microseconds]
+    after 100
+    set tickFactor [expr {double([::tcl::clock::clicks] - $tick) / ([::tcl::clock::microseconds] - $usec)}]
+    proc monotonic {} {
+      variable tickFactor
+      expr {wide([::tcl::clock::clicks] / $tickFactor)} 
+    }
+    monotonic
+  }
+}
+# asynchronous function doing 3 time jumps (+1 min, +1 min, -2 minutes) in 250-ms:
+proc delayedtimejump {delay {async 1} {startms {}}} {
+  # async code (executed in separate process):
+  if {$async} {
+    set code ""
+    foreach pr {timejump delayedtimejump} {
+	append code [list proc $pr [info args $pr] [info body $pr]] \n
+    }
+    append code "delayedtimejump $delay 0 [::tcl::clock::milliseconds]"
+    exec [info nameofexecutable] << $code &
+    return
+  }
+  # time-jumps (1st in 250-ms, 2nd and 3rd in given delay):
+  set delay1 250
+  if {$startms ne {}} {
+     set delay1 [expr {250 - ([::tcl::clock::milliseconds] - $startms)}]
+     if {$delay1 < 0} { set delay1 0 }
+  }
+  after $delay1; timejump +1 minutes
+  after $delay; timejump +1 minutes
+  after $delay; timejump -2 minutes
+}
+
+proc test-timer-with-jump {code maxCount expMT {maxOffs 100}} {
+    set mitm [set sttm [clock seconds]]
+    set stmt [monotonic]
+    set expMT [expr {$expMT * 1000}]
+    set maxOffs [expr {$maxOffs * 1000}]
+    set res {}
+    set jumped 0
+    for {set i 0} {$i < $maxCount} {incr i} {
+	set rt [::tcl::clock::microseconds]
+	set mt [monotonic]
+	# execute:
+	if 1 $code
+	# verify monotonic time:
+	set mt [expr {[monotonic] - $mt}]
+	set rt [expr {[::tcl::clock::microseconds] - $rt}]
+	# give +/- 100-ms for some slow or busy systems:
+	if {$mt < $expMT - $maxOffs || $mt > $expMT + $maxOffs} {
+	  lappend res "$i. too large discrepancy mt: $mt ~ $expMT (rt: $rt)"
+	} else {
+	  #lappend res "$i. debug, # mt: $mt, rt: $rt"
+	}
+	# be sure we are in the future and then comming back:
+	if {$jumped > 2} break; # we are already back
+	if {[clock seconds] - $mitm > 30 || [clock seconds] - $mitm < -30} {
+	   set mitm [clock seconds]
+	   incr jumped
+	}
+    }
+    # wait for time-jump back (from the future):
+    set future [clock add $sttm +30 seconds]
+    set aftto [after 10000 {set tout 1}]
+    while {[clock seconds] >= $future} {
+	if {[vwait 100 tout]} {
+	   error "unexpected case: too long wait for time-reset."
+	}
+    }
+    after cancel $aftto
+    after 10
+    # result:
+    if {[llength $res]} {
+      return [join $res \n]
+    }
+    return $jumped
+}
+
+test timer-20.1 {time jump: after relative} {ChangeTimePrivilege} {
+    delayedtimejump 250; # delayed time jump in 250-ms
+    test-timer-with-jump {
+	after 150 {set x 1}; vwait x
+    } 20 150
+} 3
+
+test timer-20.2 {time jump: vwait timeout} {ChangeTimePrivilege NewVWaitAfter} {
+    delayedtimejump 250; # delayed time jump in 250-ms
+    test-timer-with-jump {
+	vwait -timer 150 nothing; # we want listen timer only
+    } 20 150
+} 3
+
+test timer-20.3 {time jump: simple sleep} {ChangeTimePrivilege} {
+    delayedtimejump 250; # delayed time jump in 250-ms
+    test-timer-with-jump {
+	after 150
+    } 20 150
+} 3
+
+
+# Increase delay between time-jumps (1.5s) for possible retarded reaction of 
+# the notifier by absolute timers (retarded recognition of the time-jump so
+# the time can jump again (also backwards) without recognition.
+# Note also we cannot test absolute timers by the backwards time-jump.
+
+test timer-20.4 {time jump: after absolute time - "after at real-time code"} {ChangeTimePrivilege NewVWaitAfter} {
+    set sttm [clock seconds]
+    set i 0
+    foreach tm [list \
+      [clock add $sttm +1 minute -2 second] \
+      [clock add $sttm +2 minute -2 second] \
+    ] {
+      after at $tm [list set x$i 1]
+      incr i
+    }
+    delayedtimejump 1500; # delayed time jump in 1.5s
+    test-timer-with-jump {
+    	# we want listen timer only:
+	if {![vwait -timer 10000 x$i]} {
+	   error "too long wait for \"x$i\" (should be maximal 1 second)"
+	}
+    } 2 250 3000; # max 3 seconds difference (compared to 1 minute)
+} 2
+
+test timer-20.5 {time jump: sleep to absolute time - "after at real-time"} {ChangeTimePrivilege NewVWaitAfter} {
+    set sttm [clock seconds]
+    set offsLst [list \
+      [clock add $sttm +1 minute] \
+      [clock add $sttm +2 minute] \
+    ]
+    delayedtimejump 1500; # delayed time jump in 1.5s
+    test-timer-with-jump {
+	upvar offsLst offsLst
+	after at [lindex $offsLst $i]
+    } 2 250 3000; # max 3 seconds difference (compared to 1 minute)
+} 2
+
 # cleanup
 ::tcltest::cleanupTests
 return
-- 
cgit v0.12


From a369fed234a0461b2b58bf22bed7910c61689651 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:29 +0000
Subject: cleanup...

---
 win/tclWinTime.c | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

diff --git a/win/tclWinTime.c b/win/tclWinTime.c
index 1dbcc27..0647d99 100644
--- a/win/tclWinTime.c
+++ b/win/tclWinTime.c
@@ -700,14 +700,6 @@ NativeGetMicroseconds(
 		unsigned int regs[4];
 
 		GetSystemInfo(&systemInfo);
-		if (TclWinCPUID(1, regs) == TCL_OK) {
-		printf("********* system pen: %d, hyperthread: %d, cpu-count: %d\n, cpu-num: %d\n", 
-			(regs[0]&0x00000F00) == 0x00000F00 /* Pentium 4 */
-			,((regs[0] & 0x0FF00000)	/* Extended family (bits 20-27) */
-			&& (regs[3] & 0x10000000)),
-			((regs[1]&0x00FF0000) >> 16)/* CPU count */,
-			systemInfo.dwNumberOfProcessors
-		);}
 
 		if (TclWinCPUID(0, regs) == TCL_OK
 			&& regs[1] == 0x756e6547	/* "Genu" */
@@ -724,7 +716,6 @@ NativeGetMicroseconds(
 		} else {
 		    timeInfo.perfCounterAvailable = FALSE;
 		}
-		printf("********* available %d\n", timeInfo.perfCounterAvailable);
 
 	    }
 #endif /* above code is Win32 only */
@@ -770,7 +761,6 @@ NativeGetMicroseconds(
 	 */
 	if (InterlockedCompareExchange(&timeInfo.lastCIEpoch, 
 				ciEpoch, ciEpoch) != ciEpoch) {
-	    printf("**** not equal: %d != %d\n", ciEpoch, timeInfo.lastCIEpoch);
 	    EnterCriticalSection(&timeInfo.cs);
 	    if (ciEpoch != timeInfo.lastCIEpoch) {
 		memcpy(&ci, &timeInfo.lastCI, sizeof(ci));
@@ -823,7 +813,6 @@ NativeGetMicroseconds(
 	    if (MsToT100ns(-800) < tdiff && tdiff < MsToT100ns(800)) {
 
 		/* Allow small drift if discrepancy larger as expected */
-//!!!		printf("************* tdiff: %I64d\n", tdiff);
 		if (tdiff <= MsToT100ns(-VT_MAX_DISCREPANCY)) {
 		    vt0 += MsToT100ns(VT_MAX_DRIFT_TIME);
 		}
@@ -845,9 +834,7 @@ NativeGetMicroseconds(
 		  && (lastTime -= vt0) > 0 /* offset to vt0 */
 		  && lastTime < MsToT100ns(800) /* bypass time-switch (drifts only) */
 		) {
-//!!!		    printf("************* forwards 1: %I64d, last-time: %I64d, distance: %I64d\n", lastTime, vt0, (vt0 - trSysTime));
 		    vt0 += lastTime; /* hold on the time a bit */
-//!!!		    printf("************* forwards 1: %I64d, last-time: %I64d, distance: %I64d\n", lastTime, ci.virtTimeBase, (vt0 - trSysTime));
 		}
 
 		/* difference for addjustment of monotonic base */
@@ -860,7 +847,6 @@ NativeGetMicroseconds(
 		 */
 		vt0 = sysTime;
 		tdiff = 0;
-//!!!		printf("************* reset time: %I64d *****************\n", vt0);
 	    }
 
 	    /*
@@ -888,9 +874,7 @@ NativeGetMicroseconds(
 	    memcpy(&timeInfo.lastCI, &ci, sizeof(ci));
 	    /* Increase epoch, to inform all other threads about new data */
 	    InterlockedIncrement(&timeInfo.lastCIEpoch);
-
-//!!!	    printf("************* recalibrated: %I64d, %I64d adj. %I64d, distance: %I64d\n", vt0, ci.virtTimeBase, ci.perfCounter, (vt0 - trSysTime));
-	  
+  
 	  } /* end lock */
 	  LeaveCriticalSection(&timeInfo.cs);
 	} /* common info lastCI contains actual data */
-- 
cgit v0.12


From 3e7f9a47b4949a000fe065bb42a55163056cc1b7 Mon Sep 17 00:00:00 2001
From: sebres <sebres@users.sourceforge.net>
Date: Mon, 3 Jul 2017 13:32:33 +0000
Subject: performance test cases extended

---
 tests-perf/timer-event.perf.tcl | 45 +++++++++++++++++++++++++++++++++--------
 1 file changed, 37 insertions(+), 8 deletions(-)

diff --git a/tests-perf/timer-event.perf.tcl b/tests-perf/timer-event.perf.tcl
index a5ea8e1..6732a81 100644
--- a/tests-perf/timer-event.perf.tcl
+++ b/tests-perf/timer-event.perf.tcl
@@ -33,41 +33,69 @@ proc test-queue {howmuch} {
 
   puts "*** $howmuch events ***"
   _test_run 0 [string map [list \$howmuch $howmuch \\# \#] {
+
+    # generate $howmuch idle-events:
+    {time {after idle {set foo bar}} $howmuch; llength [after info]}
     # update / after idle:
-    setup {puts [time {after idle {set foo bar}} $howmuch]}
     {update; \# $howmuch idle-events}
+    
+    # generate $howmuch idle-events:
+    {time {after idle {set foo bar}} $howmuch; llength [after info]}
     # update idletasks / after idle:
-    setup {puts [time {after idle {set foo bar}} $howmuch]}
     {update idletasks; \# $howmuch idle-events}
 
+    # generate $howmuch immediate events:
+    {time {after 0 {set foo bar}} $howmuch; llength [after info]}
     # update / after 0:
-    setup {puts [time {after 0 {set foo bar}} $howmuch]}
     {update; \# $howmuch timer-events}
+    
+    # generate $howmuch 1-ms events:
+    {time {after 1 {set foo bar}} $howmuch; llength [after info]}
+    setup {after 1}
     # update / after 1:
-    setup {puts [time {after 1 {set foo bar}} $howmuch]; after 1}
     {update; \# $howmuch timer-events}
 
+    # generate $howmuch immediate events (+ 1 event of the second generation):
+    {time {after 0 {after 0 {}}} $howmuch; llength [after info]}
+    # update / after 0 (double generation):
+    {while {1} {update; if {![llength [after info]]} break }; \# all generations of events}
+
     # cancel forwards "after idle" / $howmuch idle-events in queue:
     setup {set i 0; time {set ev([incr i]) [after idle {set foo bar}]} $howmuch}
     {set i 0; time {after cancel $ev([incr i])} $howmuch}
-    cleanup {update}
+    cleanup {update; unset -nocomplain ev}
     # cancel backwards "after idle" / $howmuch idle-events in queue:
     setup {set i 0; time {set ev([incr i]) [after idle {set foo bar}]} $howmuch}
     {incr i; time {after cancel $ev([incr i -1])} $howmuch}
-    cleanup {update}
+    cleanup {update; unset -nocomplain ev}
 
     # cancel forwards "after 0" / $howmuch timer-events in queue:
     setup {set i 0; time {set ev([incr i]) [after 0 {set foo bar}]} $howmuch}
     {set i 0; time {after cancel $ev([incr i])} $howmuch}
-    cleanup {update}
+    cleanup {update; unset -nocomplain ev}
     # cancel backwards "after 0" / $howmuch timer-events in queue:
     setup {set i 0; time {set ev([incr i]) [after 0 {set foo bar}]} $howmuch}
     {incr i; time {after cancel $ev([incr i -1])} $howmuch}
-    cleanup {update}
+    cleanup {update; unset -nocomplain ev}
     # end $howmuch events.
   }]
 }
 
+proc test-access {{reptime 1000}} {
+  foreach count {5000 50000} {
+  _test_run $reptime [string map [list \$count $count] {
+    # event random access: after idle + after info (by $count events)
+    setup {set i -1; time {set ev([incr i]) [after idle {}]} $count; array size ev }
+    {after info $ev([expr {int(rand()*$count)}])}
+    cleanup {update; unset -nocomplain ev}
+    # event random access: after 0 + after info (by $count events)
+    setup {set i -1; time {set ev([incr i]) [after 0 {}]} $count; array size ev}
+    {after info $ev([expr {int(rand()*$count)}])}
+    cleanup {update; unset -nocomplain ev}
+  }]
+  }
+}
+
 proc test-exec {{reptime 1000}} {
   _test_run $reptime {
     # after idle + after cancel
@@ -164,6 +192,7 @@ proc test-long {{reptime 1000}} {
 
 proc test {{reptime 1000}} {
   test-exec $reptime
+  test-access $reptime
   if {![catch {update -noidle}]} {
     test-exec-new $reptime
     test-nrt-capability $reptime
-- 
cgit v0.12