Tcl Source Code

    Tcl_Obj *const objv[])	/* Argument objects. */
{
    register Tcl_Obj *objPtr;
    Tcl_Obj *objs[4];
    register int i, result;
    int count;
    double totalMicroSec;
#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
    ULONGLONG start, stop;
#else
    DWORD start, stop;
#endif
#else
#ifdef HAVE_CLOCK_GETTIME
    int monoClock = 1;
    struct timespec start, stop;
#else
#ifndef TCL_WIDE_CLICKS
    Tcl_Time start, stop;
#else
    Tcl_WideInt start, stop;
#endif
#endif
#endif

    if (objc == 2) {
	count = 1;
    } else if (objc == 3) {
	result = TclGetIntFromObj(interp, objv[2], &count);
	if (result != TCL_OK) {
	    return result;
	}
    } else {
	Tcl_WrongNumArgs(interp, 1, objv, "command ?count?");
	return TCL_ERROR;
    }

    objPtr = objv[1];
    i = count;
#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
    start = GetTickCount64();
#else
    start = GetTickCount();
#endif
#else
#ifdef HAVE_CLOCK_GETTIME
    if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) {
	clock_gettime(CLOCK_REALTIME, &start);
	monoClock = 0;
    }
#else
#ifndef TCL_WIDE_CLICKS
    Tcl_GetTime(&start);
#else
    start = TclpGetWideClicks();
#endif
#endif
#endif
    while (i-- > 0) {
	result = Tcl_EvalObjEx(interp, objPtr, 0);
	if (result != TCL_OK) {
	    return result;
	}
    }
#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
    stop = GetTickCount64();
#else
    stop = GetTickCount();
#endif
    totalMicroSec = (stop - start) * 1000.0;
#else
#ifdef HAVE_CLOCK_GETTIME
    clock_gettime(monoClock ? CLOCK_MONOTONIC : CLOCK_REALTIME, &stop);
    totalMicroSec = ((double) (stop.tv_sec - start.tv_sec)) * 1.0e6
	    + (stop.tv_nsec - start.tv_nsec) / 1000.0;
#else
#ifndef TCL_WIDE_CLICKS
    Tcl_GetTime(&stop);
    totalMicroSec = ((double) (stop.sec - start.sec)) * 1.0e6
	    + (stop.usec - start.usec);
#else
    stop = TclpGetWideClicks();
    totalMicroSec = ((double) TclpWideClicksToNanoseconds(stop - start))/1.0e3;
#endif
#endif
#endif

    if (count <= 1) {
	/*
	 * Use int obj since we know time is not fractional. [Bug 1202178]
	 */

	Tcl_Release(interp);
    }

    if ((iPtr->limit.active & TCL_LIMIT_TIME) &&
	    ((iPtr->limit.timeGranularity == 1) ||
		(ticker % iPtr->limit.timeGranularity == 0))) {
	Tcl_Time now;
#if (_WIN32_WINNT >= 0x0600) && defined(WIN32_USE_TICKCOUNT)
	ULONGLONG ticks = GetTickCount64();

	now.sec = ticks / 1000;
	now.usec = (ticks % 1000) * 1000;
#else
#ifdef HAVE_CLOCK_GETTIME
	struct timespec ts;

	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	    clock_gettime(CLOCK_REALTIME, &ts);
	}
	now.sec = ts.tv_sec;
	now.usec = ts.tv_nsec * 1000;
#else
	Tcl_GetTime(&now);
#endif
#endif
	if (iPtr->limit.time.sec < now.sec ||
		(iPtr->limit.time.sec == now.sec &&
		iPtr->limit.time.usec < now.usec)) {
	    iPtr->limit.exceeded |= TCL_LIMIT_TIME;
	    Tcl_Preserve(interp);
	    RunLimitHandlers(iPtr->limit.timeHandlers, interp);
	    if (iPtr->limit.time.sec > now.sec ||

void
Tcl_LimitTypeSet(
    Tcl_Interp *interp,
    int type)
{
    Interp *iPtr = (Interp *) interp;
#if (_WIN32_WINNT < 0x0600) && defined(WIN32_USE_TICKCOUNT)
    if (type == TCL_LIMIT_TIME) {
	/* not implemented for _WIN32 */
	return;
    }
#endif

    iPtr->limit.active |= type;
}

/*
 *----------------------------------------------------------------------
 *

    Interp *masterPtr = (Interp *) masterInterp;

    if (masterPtr->limit.active & TCL_LIMIT_COMMANDS) {
	slavePtr->limit.active |= TCL_LIMIT_COMMANDS;
	slavePtr->limit.cmdCount = 0;
	slavePtr->limit.cmdGranularity = masterPtr->limit.cmdGranularity;
    }
#if (_WIN32_WINNT < 0x0600) && defined(WIN32_USE_TICKCOUNT)
    /* not implemented for _WIN32 */
#else
    if (masterPtr->limit.active & TCL_LIMIT_TIME) {
	slavePtr->limit.active |= TCL_LIMIT_TIME;
	memcpy(&slavePtr->limit.time, &masterPtr->limit.time,
		sizeof(Tcl_Time));
	slavePtr->limit.timeGranularity = masterPtr->limit.timeGranularity;
    }
#endif
}

/*
 *----------------------------------------------------------------------
 *
 * SlaveCommandLimitCmd --
 *

{
    Tcl_Time time;

    /*
     * Compute when the event should fire.
     */

#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
    ULONGLONG ticks = GetTickCount64();

    time.sec = (long) ((ticks+milliseconds)/1000);
    time.usec = (long) (((ticks+milliseconds)%1000)*1000);
#else
    if (milliseconds > 0x7FFFFFFF) {
	milliseconds = 0x7FFFFFFF;
    } else if (milliseconds < 0) {
	milliseconds = 0;
    }
    time.sec = milliseconds + GetTickCount();
    time.usec = 0;
#endif
#else
#ifdef HAVE_CLOCK_GETTIME
    struct timespec ts;

    if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	clock_gettime(CLOCK_REALTIME, &ts);
    }
    time.sec = ts.tv_sec;
    time.usec = ts.tv_nsec / 1000;
#else
    Tcl_GetTime(&time);
#endif
    time.sec += milliseconds/1000;
    time.usec += (milliseconds%1000)*1000;
    if (time.usec >= 1000000) {
	time.usec -= 1000000;
	time.sec += 1;
    }
    return TclCreateAbsoluteTimerHandler(&time, proc, clientData);

    /*
     * Add the event to the queue in the correct position
     * (ordered by event firing time).
     */

    for (tPtr2 = tsdPtr->firstTimerHandlerPtr, prevPtr = NULL; tPtr2 != NULL;
	    prevPtr = tPtr2, tPtr2 = tPtr2->nextPtr) {
#if (_WIN32_WINNT < 0x0600) && defined(WIN32_USE_TICKCOUNT)
	if (timerHandlerPtr->time.sec - tPtr2->time.sec < 0) {
	    break;
	}
#else
	if (TCL_TIME_BEFORE(timerHandlerPtr->time, tPtr2->time)) {
	    break;
	}
#endif
    }
    timerHandlerPtr->nextPtr = tPtr2;
    if (prevPtr == NULL) {
	tsdPtr->firstTimerHandlerPtr = timerHandlerPtr;
    } else {
	prevPtr->nextPtr = timerHandlerPtr;
    }

	blockTime.sec = 0;
	blockTime.usec = 0;
    } else if ((flags & TCL_TIMER_EVENTS) && tsdPtr->firstTimerHandlerPtr) {
	/*
	 * Compute the timeout for the next timer on the list.
	 */

#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
	ULONGLONG ticks = GetTickCount64();

	blockTime.sec = (long)
	    ((ULONGLONG) tsdPtr->firstTimerHandlerPtr->time.sec -
		(ticks / 1000));
	blockTime.usec = (long)
	    ((ULONGLONG) tsdPtr->firstTimerHandlerPtr->time.usec -
		(ticks % 1000) * 1000);
	if (blockTime.usec < 0) {
	    blockTime.sec -= 1;
	    blockTime.usec += 1000000;
	}
	if (blockTime.sec < 0) {
	    blockTime.sec = 0;
	    blockTime.usec = 0;
	}
#else
	blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - GetTickCount();
	if (blockTime.sec <= 0) {
	    blockTime.sec = 0;
	    blockTime.usec = 0;
	} else {
	    blockTime.usec = (blockTime.sec % 1000) * 1000;
	    blockTime.sec /= 1000;
	}
#endif
#else
#ifdef HAVE_CLOCK_GETTIME
	struct timespec ts;

	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	    clock_gettime(CLOCK_REALTIME, &ts);
	}
	blockTime.sec = ts.tv_sec;
	blockTime.usec = ts.tv_nsec / 1000;
#else
	Tcl_GetTime(&blockTime);
#endif
	blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - blockTime.sec;
	blockTime.usec = tsdPtr->firstTimerHandlerPtr->time.usec -
		blockTime.usec;
	if (blockTime.usec < 0) {
	    blockTime.sec -= 1;
	    blockTime.usec += 1000000;
	}
	if (blockTime.sec < 0) {
	    blockTime.sec = 0;
	    blockTime.usec = 0;
	}
#endif
    } else {
	return;
    }

    Tcl_SetMaxBlockTime(&blockTime);
}


    ThreadSpecificData *tsdPtr = InitTimer();

    if ((flags & TCL_TIMER_EVENTS) && tsdPtr->firstTimerHandlerPtr) {
	/*
	 * Compute the timeout for the next timer on the list.
	 */

#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
	ULONGLONG ticks = GetTickCount64();

	blockTime.sec = (long)
	    ((ULONGLONG) tsdPtr->firstTimerHandlerPtr->time.sec -
		(ticks / 1000));
	blockTime.usec = (long)
	    ((ULONGLONG) tsdPtr->firstTimerHandlerPtr->time.usec -
		(ticks % 1000) * 1000);
	if (blockTime.usec < 0) {
	    blockTime.sec -= 1;
	    blockTime.usec += 1000000;
	}
	if (blockTime.sec < 0) {
	    blockTime.sec = 0;
	    blockTime.usec = 0;
	}
#else
	blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - GetTickCount();
	if (blockTime.sec <= 0) {
	    blockTime.sec = 0;
	    blockTime.usec = 0;
	} else {
	    blockTime.usec = (blockTime.sec % 1000) * 1000;
	    blockTime.sec /= 1000;
	}
#endif
#else
#ifdef HAVE_CLOCK_GETTIME
	struct timespec ts;

	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	    clock_gettime(CLOCK_REALTIME, &ts);
	}
	blockTime.sec = ts.tv_sec;
	blockTime.usec = ts.tv_nsec / 1000;
#else
	Tcl_GetTime(&blockTime);
#endif
	blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - blockTime.sec;
	blockTime.usec = tsdPtr->firstTimerHandlerPtr->time.usec -
		blockTime.usec;
	if (blockTime.usec < 0) {
	    blockTime.sec -= 1;
	    blockTime.usec += 1000000;
	}
	if (blockTime.sec < 0) {
	    blockTime.sec = 0;
	    blockTime.usec = 0;
	}
#endif

	/*
	 * If the first timer has expired, stick an event on the queue.
	 */

	if (blockTime.sec == 0 && blockTime.usec == 0 &&
		!tsdPtr->timerPending) {

    int flags)			/* Flags that indicate what events to handle,
				 * such as TCL_FILE_EVENTS. */
{
    TimerHandler *timerHandlerPtr, **nextPtrPtr;
    Tcl_Time time;
    int currentTimerId;
    ThreadSpecificData *tsdPtr = InitTimer();
#ifdef HAVE_CLOCK_GETTIME
    struct timespec ts;
#endif
#if (_WIN32_WINNT >= 0x0600) && defined(WIN32_USE_TICKCOUNT)
    ULONGLONG ticks;
#endif

    /*
     * 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.
     */

     *	  most recently created handler appearing after earlier ones with the
     *	  same expiration time, we don't have to worry about newer generation
     *	  timers appearing before later ones.
     */

    tsdPtr->timerPending = 0;
    currentTimerId = tsdPtr->lastTimerId;
#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
    ticks = GetTickCount64();
    time.sec = ticks / 1000;
    time.usec = (ticks % 1000) * 1000;
#else
    time.sec = GetTickCount();
    time.usec = 0;
#endif
#else
#ifdef HAVE_CLOCK_GETTIME
    if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	clock_gettime(CLOCK_REALTIME, &ts);
    }
    time.sec = ts.tv_sec;
    time.usec = ts.tv_nsec / 1000;
#else
    Tcl_GetTime(&time);
#endif
#endif
    while (1) {
	nextPtrPtr = &tsdPtr->firstTimerHandlerPtr;
	timerHandlerPtr = tsdPtr->firstTimerHandlerPtr;
	if (timerHandlerPtr == NULL) {
	    break;
	}

#if (_WIN32_WINNT < 0x0600) && defined(WIN32_USE_TICKCOUNT)
	if (time.sec - timerHandlerPtr->time.sec < 0) {
	    break;
	}
#else
	if (TCL_TIME_BEFORE(time, timerHandlerPtr->time)) {
	    break;
	}

#endif
	/*
	 * Bail out if the next timer is of a newer generation.
	 */

	if ((currentTimerId - PTR2INT(timerHandlerPtr->token)) < 0) {
	    break;
	}

    /*
     * At this point, either index = -1 and ms contains the number of ms
     * to wait, or else index is the index of a subcommand.
     */

    switch (index) {
    case -1: {
#ifdef HAVE_CLOCK_GETTIME
	struct timespec ts;
#endif
#if (_WIN32_WINNT >= 0x0600) && defined(WIN32_USE_TICKCOUNT)
	ULONGLONG ticks;
#endif

	if (ms < 0) {
	    ms = 0;
	}
	if (objc == 2) {
	    return AfterDelay(interp, ms);
	}
	afterPtr = ckalloc(sizeof(AfterInfo));

	 * the future, and wrap-around is unlikely to occur in less than about
	 * 1-10 years. Thus it's unlikely that any old ids will still be
	 * around when wrap-around occurs.
	 */

	afterPtr->id = tsdPtr->afterId;
	tsdPtr->afterId += 1;
+#ifdef WIN32_USE_TICKCOUNT
+#if (_WIN32_WINNT >= 0x0600)
+	ticks = GetTickCount64();
+	wakeup.sec = ticks / 1000;
+	wakeup.usec = (ticks % 1000) * 1000;
+	wakeup.sec += (long)(ms / 1000);
+	wakeup.usec += ((long)(ms % 1000)) * 1000;
+	if (wakeup.usec > 1000000) {
+	    wakeup.sec++;
+	    wakeup.usec -= 1000000;
+	}
#else
	if (ms > 0x7FFFFFFF) {
	    ms = 0x7FFFFFFF;
	} else if (ms < 0) {
	    ms = 0;
	}
	wakeup.sec = ms + GetTickCount();
	wakeup.usec = 0;
#endif
#else
#ifdef HAVE_CLOCK_GETTIME
	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	    clock_gettime(CLOCK_REALTIME, &ts);
	}
	wakeup.sec = ts.tv_sec;
	wakeup.usec = ts.tv_nsec / 1000;
#else
	Tcl_GetTime(&wakeup);
#endif
	wakeup.sec += (long)(ms / 1000);
	wakeup.usec += ((long)(ms % 1000)) * 1000;
	if (wakeup.usec > 1000000) {
	    wakeup.sec++;
	    wakeup.usec -= 1000000;
	}
#endif
	afterPtr->token = TclCreateAbsoluteTimerHandler(&wakeup,
		AfterProc, afterPtr);
	afterPtr->nextPtr = assocPtr->firstAfterPtr;
	assocPtr->firstAfterPtr = afterPtr;
	Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
	return TCL_OK;
    }

 */

static int
AfterDelay(
    Tcl_Interp *interp,
    Tcl_WideInt ms)
{
    Tcl_Time endTime, now;
#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
    Interp *iPtr = (Interp *) interp;
    ULONGLONG ticks = GetTickCount64();
    Tcl_WideInt diff;

    now.sec = ticks/1000;
    now.usec = (ticks%1000)*1000;
    endTime = now;
    endTime.sec += (long)(ms/1000);
    endTime.usec += ((int)(ms%1000))*1000;
    if (endTime.usec >= 1000000) {
	endTime.sec++;
	endTime.usec -= 1000000;
    }
#else
    int diff;

    now.sec = GetTickCount();
    now.usec = 0;
    if (ms > 0x7FFFFFFF) {
	ms = 0x7FFFFFFF;
    } else if (ms < 0) {
	ms = 0;
    }
    endTime.sec = now.sec + ms;
    endTime.usec = 0;
#endif
#else
    Interp *iPtr = (Interp *) interp;
    Tcl_WideInt diff;
#ifdef HAVE_CLOCK_GETTIME
    struct timespec ts;

    if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	clock_gettime(CLOCK_REALTIME, &ts);
    }
    now.sec = ts.tv_sec;
    now.usec = ts.tv_nsec/1000;
#else
    Tcl_GetTime(&now);
#endif
    endTime = now;
    endTime.sec += (long)(ms/1000);
    endTime.usec += ((int)(ms%1000))*1000;
    if (endTime.usec >= 1000000) {
	endTime.sec++;
	endTime.usec -= 1000000;
    }
#endif

    do {
	if (Tcl_AsyncReady()) {
	    if (Tcl_AsyncInvoke(interp, TCL_OK) != TCL_OK) {
		return TCL_ERROR;
	    }
	}
	if (Tcl_Canceled(interp, TCL_LEAVE_ERR_MSG) == TCL_ERROR) {
	    return TCL_ERROR;
	}
#if (_WIN32_WINNT < 0x0600) && defined(WIN32_USE_TICKCOUNT)
	diff = endTime.sec - now.sec;
	if (diff > 0) {
	    Tcl_Sleep((long) diff);
	} else {
	    break;
	}
	now.sec = GetTickCount();
#else
	if (iPtr->limit.timeEvent != NULL
		&& TCL_TIME_BEFORE(iPtr->limit.time, now)) {
	    iPtr->limit.granularityTicker = 0;
	    if (Tcl_LimitCheck(interp) != TCL_OK) {
		return TCL_ERROR;
	    }
	}

	    if (Tcl_Canceled(interp, TCL_LEAVE_ERR_MSG) == TCL_ERROR) {
		return TCL_ERROR;
	    }
	    if (Tcl_LimitCheck(interp) != TCL_OK) {
		return TCL_ERROR;
	    }
	}
#if (_WIN32_WINNT >= 0x0600) && defined(WIN32_USE_TICKCOUNT)
	ticks = GetTickCount64();
	now.sec = ticks / 1000;
	now.usec = (ticks % 1000) * 1000;
#else
#ifdef HAVE_CLOCK_GETTIME
	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	    clock_gettime(CLOCK_REALTIME, &ts);
	}
	now.sec = ts.tv_sec;
	now.usec = ts.tv_nsec / 1000;
#else
        Tcl_GetTime(&now);
#endif
#endif
#endif
    }
#if (_WIN32_WINNT < 0x0600) && defined(WIN32_USE_TICKCOUNT)
    while (now.sec - endTime.sec < 0);
#else
    while (TCL_TIME_BEFORE(now, endTime));
#endif
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * GetAfterEvent --

	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 pthread_condattr_setclock
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

$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
  LIBS="$LIBS -lnsl"
fi

fi


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clock_gettime in -lrt" >&5
$as_echo_n "checking for clock_gettime in -lrt... " >&6; }
if ${ac_cv_lib_rt_clock_gettime+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lrt  $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.  */
#ifdef __cplusplus
extern "C"
#endif
char clock_gettime ();
int
main ()
{
return clock_gettime ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_rt_clock_gettime=yes
else
  ac_cv_lib_rt_clock_gettime=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_clock_gettime" >&5
$as_echo "$ac_cv_lib_rt_clock_gettime" >&6; }
if test "x$ac_cv_lib_rt_clock_gettime" = xyes; then :
  LIBS="$LIBS -lrt"
fi

    for ac_func in clock_gettime clock_nanosleep
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



# Add the threads support libraries
LIBS="$LIBS$THREADS_LIBS"


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to build libraries" >&5

	fi

	# Does the pthread-implementation provide
	# 'pthread_attr_setstacksize' ?

	ac_saved_libs=$LIBS
	LIBS="$LIBS $THREADS_LIBS"
	AC_CHECK_FUNCS(pthread_attr_setstacksize pthread_atfork pthread_condattr_setclock)
	LIBS=$ac_saved_libs
    else
	TCL_THREADS=0
    fi
    # Do checking message here to not mess up interleaved configure output
    AC_MSG_CHECKING([for building with threads])
    if test "${TCL_THREADS}" = 1; then

    if test "$tcl_checkBoth" = 1; then
	tk_oldLibs=$LIBS
	LIBS="$LIBS -lsocket -lnsl"
	AC_CHECK_FUNC(accept, tcl_checkNsl=0, [LIBS=$tk_oldLibs])
    fi
    AC_CHECK_FUNC(gethostbyname, , [AC_CHECK_LIB(nsl, gethostbyname,
	    [LIBS="$LIBS -lnsl"])])
    AC_CHECK_LIB(rt, clock_gettime, [LIBS="$LIBS -lrt"])
    AC_CHECK_FUNCS(clock_gettime clock_nanosleep)
])

#--------------------------------------------------------------------
# SC_TCL_EARLY_FLAGS
#
#	Check for what flags are needed to be passed so the correct OS
#	features are available.

#undef HAVE_BLKCNT_T

/* Defined when compiler supports casting to union type. */
#undef HAVE_CAST_TO_UNION

/* Define to 1 if you have the `chflags' function. */
#undef HAVE_CHFLAGS

/* Define to 1 if you have the `clock_gettime' function. */
#undef HAVE_CLOCK_GETTIME

/* Define to 1 if you have the `copyfile' function. */
#undef HAVE_COPYFILE

/* Define to 1 if you have the <copyfile.h> header file. */
#undef HAVE_COPYFILE_H

#undef HAVE_OSSPINLOCKLOCK

/* Define to 1 if you have the `pthread_atfork' function. */
#undef HAVE_PTHREAD_ATFORK

/* Define to 1 if you have the `pthread_attr_setstacksize' function. */
#undef HAVE_PTHREAD_ATTR_SETSTACKSIZE

/* Define to 1 if you have the `pthread_condattr_setclock' function. */
#undef HAVE_PTHREAD_CONDATTR_SETCLOCK

/* Does putenv() copy strings or incorporate them by reference? */
#undef HAVE_PUTENV_THAT_COPIES

/* Are characters signed? */
#undef HAVE_SIGNED_CHAR

				 * TCL_EXCEPTION. */
    int timeout)		/* Maximum amount of time to wait for one of
				 * the conditions in mask to occur, in
				 * milliseconds. A value of 0 means don't wait
				 * at all, and a value of -1 means wait
				 * forever. */
{
    Tcl_Time abortTime = {0, 0}, now = { 0, 0 }; /* silence gcc 4 warning */
    struct timeval blockTime, *timeoutPtr;
    int numFound, result = 0;
    fd_set readableMask;
    fd_set writableMask;
    fd_set exceptionMask;
#ifdef HAVE_CLOCK_GETTIME
    int monoClock = 1;
    struct timespec ts;
#endif

#ifndef _DARWIN_C_SOURCE
    /*
     * Sanity check fd.
     */

    if (fd >= FD_SETSIZE) {
	Tcl_Panic("TclUnixWaitForFile can't handle file id %d", fd);
	/* must never get here, or select masks overrun will occur below */
    }
#endif

    /*
     * If there is a non-zero finite timeout, compute the time when we give
     * up.
     */

    if (timeout > 0) {
#ifdef HAVE_CLOCK_GETTIME
	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	    clock_gettime(CLOCK_REALTIME, &ts);
	    monoClock = 0;
	}
	now.sec = ts.tv_sec;
	now.usec = ts.tv_nsec / 1000;
#else
	Tcl_GetTime(&now);
#endif
	abortTime.sec = now.sec + timeout/1000;
	abortTime.usec = now.usec + (timeout%1000)*1000;
	if (abortTime.usec >= 1000000) {
	    abortTime.usec -= 1000000;
	    abortTime.sec += 1;
	}
	timeoutPtr = &blockTime;

	    continue;
	}

	/*
	 * The select returned early, so we need to recompute the timeout.
	 */

#ifdef HAVE_CLOCK_GETTIME
	clock_gettime(monoClock ? CLOCK_MONOTONIC : CLOCK_REALTIME, &ts);
	now.sec = ts.tv_sec;
	now.usec = ts.tv_nsec / 1000;
#else
	Tcl_GetTime(&now);
#endif
	if ((abortTime.sec < now.sec)
		|| (abortTime.sec==now.sec && abortTime.usec<=now.usec)) {
	    break;
	}
    }
    return result;
}

    /*
     * 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.
     */

#ifdef HAVE_CLOCK_GETTIME
    int monoClock = 1;
    struct timespec ts;

    if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	clock_gettime(CLOCK_REALTIME, &ts);
	monoClock = 0;
    }
    before.sec = ts.tv_sec;
    before.usec = ts.tv_nsec / 1000;
#else
    Tcl_GetTime(&before);
#endif
    after = before;
    after.sec += ms/1000;
    after.usec += (ms%1000)*1000;
    if (after.usec > 1000000) {
	after.usec -= 1000000;
	after.sec += 1;
    }

	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);
#ifdef HAVE_CLOCK_GETTIME
	clock_gettime(monoClock ? CLOCK_MONOTONIC : CLOCK_REALTIME, &ts);
	before.sec = ts.tv_sec;
	before.usec = ts.tv_nsec / 1000;
#else
	Tcl_GetTime(&before);
#endif
    }
}

#endif /* HAVE_COREFOUNDATION */
/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

	 * that an event is ready to be processed
	 * by sending this event. */
    void *hwnd;			/* Messaging window. */
#else /* !__CYGWIN__ */
    pthread_cond_t waitCV;	/* Any other thread alerts a notifier that an
				 * event is ready to be processed by signaling
				 * this condition variable. */
#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_PTHREAD_CONDATTR_SETCLOCK)
    int monoClock;		/* When true use CLOCK_MONOTONIC */
#endif
#endif /* __CYGWIN__ */
    int waitCVinitialized;	/* Variable to flag initialization of the structure */
    int eventReady;		/* True if an event is ready to be processed.
				 * Used as condition flag together with waitCV
				 * above. */
#endif /* TCL_THREADS */
} ThreadSpecificData;

	    RegisterClassW(&class);
	    tsdPtr->hwnd = CreateWindowExW(NULL, class.lpszClassName,
		    class.lpszClassName, 0, 0, 0, 0, 0, NULL, NULL,
		    TclWinGetTclInstance(), NULL);
	    tsdPtr->event = CreateEventW(NULL, 1 /* manual */,
		    0 /* !signaled */, NULL);
#else
#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_PTHREAD_CONDATTR_SETCLOCK)
	    pthread_condattr_t attr;

	    pthread_condattr_init(&attr);
	    tsdPtr->monoClock =
		    pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) == 0;
	    if (tsdPtr->monoClock) {
		if (pthread_cond_init(&tsdPtr->waitCV, &attr)) {
		    tsdPtr->monoClock = 0;
		    pthread_cond_init(&tsdPtr->waitCV, NULL);
		}
	    } else {
		pthread_cond_init(&tsdPtr->waitCV, NULL);
	    }
	    pthread_condattr_destroy(&attr);
#else
	    pthread_cond_init(&tsdPtr->waitCV, NULL);
#endif
#endif /* __CYGWIN__ */
	    tsdPtr->waitCVinitialized = 1;
	}

	pthread_mutex_lock(&notifierInitMutex);
#if defined(HAVE_PTHREAD_ATFORK)
	/*

		}
		pthread_mutex_unlock(&notifierMutex);
		MsgWaitForMultipleObjects(1, &tsdPtr->event, 0, timeout, 1279);
		pthread_mutex_lock(&notifierMutex);
	    }
#else
	    if (timePtr != NULL) {

		struct timespec ptime;

#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_PTHREAD_CONDATTR_SETCLOCK)
		if (tsdPtr->monoClock) {
		    clock_gettime(CLOCK_MONOTONIC, &ptime);
		} else {
		    clock_gettime(CLOCK_REALTIME, &ptime);
		}
		ptime.tv_sec += timePtr->sec +
		    (timePtr->usec * 1000 + ptime.tv_nsec) / 1000000000;
		ptime.tv_nsec = (timePtr->usec * 1000 + ptime.tv_nsec) %
		    1000000000;
#else
		Tcl_Time now;

		Tcl_GetTime(&now);
		ptime.tv_sec = timePtr->sec + now.sec +
		    (timePtr->usec + now.usec) / 1000000;
		ptime.tv_nsec = 1000 * ((timePtr->usec + now.usec) % 1000000);
#endif
		pthread_cond_timedwait(&tsdPtr->waitCV, &notifierMutex, &ptime);
	    } else {
		pthread_cond_wait(&tsdPtr->waitCV, &notifierMutex);
	    }
#endif /* __CYGWIN__ */
	}
	tsdPtr->eventReady = 0;

#ifdef __CYGWIN__
	while (PeekMessageW(&msg, NULL, 0, 0, 0)) {

#   if defined (__llvm__) && \
	    (__GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 2 || \
	    (__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ > 0))))
#	undef USE_VFORK
#   endif /* __llvm__ */
#endif /* __APPLE__ */

/*
 *---------------------------------------------------------------------------
 * Use clock_gettime() only if _POSIX_MONOTONIC_CLOCK present.
 *---------------------------------------------------------------------------
 */

#if defined(HAVE_CLOCK_GETTIME) && !defined(_POSIX_MONOTONIC_CLOCK)
#   undef HAVE_CLOCK_GETTIME
#endif

#ifdef TCL_THREADS
#   ifndef HAVE_CLOCK_GETTIME
#	undef HAVE_PTHREAD_CONDATTR_SETCLOCK
#   endif
#   ifndef HAVE_PTHREAD_CONDATTR_SETCLOCK
#	undef HAVE_CLOCK_GETTIME
#   endif
#endif

/*
 *---------------------------------------------------------------------------
 * The following macros and declarations represent the interface between
 * generic and unix-specific parts of Tcl. Some of the macros may override
 * functions declared in tclInt.h.
 *---------------------------------------------------------------------------
 */

    Tcl_Condition *condPtr,	/* Really (pthread_cond_t **) */
    Tcl_Mutex *mutexPtr,	/* Really (pthread_mutex_t **) */
    const Tcl_Time *timePtr) /* Timeout on waiting period */
{
    pthread_cond_t *pcondPtr;
    pthread_mutex_t *pmutexPtr;
    struct timespec ptime;
#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_PTHREAD_CONDATTR_SETCLOCK)
    int *flagPtr;
#endif

    if (*condPtr == NULL) {
	pthread_mutex_lock(&masterLock);

	/*
	 * Double check inside mutex to avoid race, then initialize condition
	 * variable if necessary.
	 */

	if (*condPtr == NULL) {
#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_PTHREAD_CONDATTR_SETCLOCK)
	    pthread_condattr_t attr;

	    pcondPtr = ckalloc(sizeof(pthread_cond_t) + sizeof(int));
	    flagPtr = (int *) (pcondPtr + 1);
	    pthread_condattr_init(&attr);
	    *flagPtr = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) == 0;
	    if (*flagPtr) {
		if (pthread_cond_init(pcondPtr, &attr)) {
		    *flagPtr = 0;
		    pthread_cond_init(pcondPtr, NULL);
		}
	    } else {
		pthread_cond_init(pcondPtr, NULL);
	    }
	    pthread_condattr_destroy(&attr);
#else
	    pcondPtr = ckalloc(sizeof(pthread_cond_t));
	    pthread_cond_init(pcondPtr, NULL);
#endif
	    *condPtr = (Tcl_Condition) pcondPtr;
	    TclRememberCondition(condPtr);
	}
	pthread_mutex_unlock(&masterLock);
    }
    pmutexPtr = *((pthread_mutex_t **)mutexPtr);
    pcondPtr = *((pthread_cond_t **)condPtr);
    if (timePtr == NULL) {
	pthread_cond_wait(pcondPtr, pmutexPtr);
    } else {
#if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_PTHREAD_CONDATTR_SETCLOCK)
	flagPtr = (int *) (pcondPtr + 1);
	if (*flagPtr) {
	    clock_gettime(CLOCK_MONOTONIC, &ptime);
	} else {
	    clock_gettime(CLOCK_REALTIME, &ptime);
	}
	ptime.tv_sec += timePtr->sec +
	    (timePtr->usec * 1000 + ptime.tv_nsec) / 1000000000;
	ptime.tv_nsec = (timePtr->usec * 1000 + ptime.tv_nsec) % 1000000000;
#else
	Tcl_Time now;

	/*
	 * Make sure to take into account the microsecond component of the
	 * current time, including possible overflow situations. [Bug #411603]
	 */

	Tcl_GetTime(&now);
	ptime.tv_sec = timePtr->sec + now.sec +
	    (timePtr->usec + now.usec) / 1000000;
	ptime.tv_nsec = 1000 * ((timePtr->usec + now.usec) % 1000000);
#endif
	pthread_cond_timedwait(pcondPtr, pmutexPtr, &ptime);
    }
}

/*
 *----------------------------------------------------------------------
 *

 */

unsigned long
TclpGetClicks(void)
{
    unsigned long now;

#ifdef HAVE_CLOCK_GETTIME
    struct timespec ts;

    if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1) {
	clock_gettime(CLOCK_REALTIME, &ts);
    }
    now = ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
#else
#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
#endif

    return now;
}
#ifdef TCL_WIDE_CLICKS

/*

void
Tcl_SetTimeProc(
    Tcl_GetTimeProc *getProc,
    Tcl_ScaleTimeProc *scaleProc,
    ClientData clientData)
{
#ifndef HAVE_CLOCK_GETTIME
    tclGetTimeProcPtr = getProc;
    tclScaleTimeProcPtr = scaleProc;
    tclTimeClientData = clientData;
#endif
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_QueryTimeProc --
 *

                          embed manifest if possible (default: yes)

Optional Packages:
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --with-encoding         encoding for configuration values
  --with-celib=DIR        use Windows/CE support library from DIR
  --with-tickcount        use GetTickCount for timers, turns off interp time
                          limits

Some influential environment variables:
  CC          C compiler command
  CFLAGS      C compiler flags
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
              nonstandard directory <lib dir>
  LIBS        libraries to pass to the linker, e.g. -l<library>

*mingw32*)
    TCL_EXE="tclsh"
    ;;
*)
    TCL_EXE="TCL_LIBRARY=\"\${LIBRARY_DIR}\"; export TCL_LIBRARY; ./\${TCLSH}"
    ;;
esac

# *** HaO 2016-03-30 this may be at the wrong place.
# *** should be in Line 4410 betwen
#	_ACEOF
# and
#	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

# Check whether --with-tickcount or --without-tickcount was given.
if test "${with_tickcount+set}" = set; then
  withval="$with_tickcount"
  tcl_ok=$withval
else
  tcl_ok=no
fi;
echo "$as_me:$LINENO: result: $tcl_ok" >&5
echo "${ECHO_T}$tcl_ok" >&6
if test $tcl_ok = yes; then

cat >>confdefs.h <<\_ACEOF
#define WIN32_USE_TICKCOUNT 1
_ACEOF

fi


#------------------------------------------------------------------------
#	Add stuff for zlib; note that this is mostly done in the makefile now
#	as we just assume that the platform hasn't got a usable z.lib
#------------------------------------------------------------------------

if test "${enable_shared+set}" = "set"; then :

  ], [
    AC_SUBST(ZLIB_LIBS,[\${ZLIB_DIR_NATIVE}/win32/zdll.lib])
  ])
], [
  AC_SUBST(ZLIB_OBJS,[\${ZLIB_OBJS}])
])
AC_DEFINE(HAVE_ZLIB, 1, [Is there an installed zlib?])

AC_ARG_WITH(tickcount,
    AC_HELP_STRING([--with-tickcount],
	[use GetTickCount for timers, turns off interp time limits]),
    [tcl_ok=$withval], [tcl_ok=no])
AC_MSG_RESULT([$tcl_ok])
if test $tcl_ok = yes; then
    AC_DEFINE(WIN32_USE_TICKCOUNT, 1, [Use GetTickCount for timers?])
fi

AC_CHECK_TYPE([intptr_t], [
    AC_DEFINE([HAVE_INTPTR_T], 1, [Do we have the intptr_t type?])], [
    AC_CACHE_CHECK([for pointer-size signed integer type], tcl_cv_intptr_t, [
    for tcl_cv_intptr_t in "int" "long" "long long" none; do
	if test "$tcl_cv_intptr_t" != none; then
	    AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT],

	int status;

	/*
	 * Compute the timeout in milliseconds.
	 */

	if (timePtr) {
#if (_WIN32_WINNT < 0x0600) && defined(WIN32_USE_TICKCOUNT)
	    timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
	    if (timeout == INFINITE) {
		timeout--;
	    }
#else
	    /*
	     * TIP #233 (Virtualized Time). Convert virtual domain delay to
	     * real-time.
	     */

	    Tcl_Time myTime;

	    myTime.sec  = timePtr->sec;
	    myTime.usec = timePtr->usec;

	    if (myTime.sec != 0 || myTime.usec != 0) {
		tclScaleTimeProcPtr(&myTime, tclTimeClientData);
	    }

	    timeout = myTime.sec * 1000 + myTime.usec / 1000;
#endif
	} else {
	    timeout = INFINITE;
	}

	/*
	 * Check to see if there are any messages in the queue before waiting
	 * because MsgWaitForMultipleObjects will not wake up if there are

 *----------------------------------------------------------------------
 */

void
Tcl_Sleep(
    int ms)			/* Number of milliseconds to sleep. */
{
#ifdef WIN32_USE_TICKCOUNT
#if (_WIN32_WINNT >= 0x0600)
    ULONGLONG now;		/* Current wall clock time. */
    ULONGLONG desired;		/* Desired wakeup time. */
    ULONGLONG sleepTime;

    now = GetTickCount64();
#else
    DWORD now;			/* Current wall clock time. */
    DWORD desired;		/* Desired wakeup time. */
    DWORD sleepTime;

    now = GetTickCount();
#endif

    if (ms < 0) {
	ms = 0;
#if (_WIN32_WINNT < 0x0600)
    } else if (ms > 0x7FFFFFFF) {
	ms = 0x7FFFFFFF;
#endif
    }
    desired = now + ms;
    sleepTime = ms;
    for (;;) {
	SleepEx(sleepTime, TRUE);
#if (_WIN32_WINNT >= 0x0600)
	now = GetTickCount64();
	if (now - desired >= 0) {
	    break;
	}
#else
	now = GetTickCount();
	if ((long) now - (long) desired >= 0) {
	    break;
	}
#endif
	sleepTime = desired - now;
    }
#else
    /*
     * Simply calling 'Sleep' for the requisite number of milliseconds can
     * make the process appear to wake up early because it isn't synchronized
     * with the CPU performance counter that is used in tclWinTime.c. This
     * behavior is probably benign, but messes up some of the corner cases in
     * the test suite. We get around this problem by repeating the 'Sleep'
     * call as many times as necessary to make the clock advance by the

	vdelay.sec  = desired.sec  - now.sec;
	vdelay.usec = desired.usec - now.usec;

	tclScaleTimeProcPtr(&vdelay, tclTimeClientData);
	sleepTime = vdelay.sec * 1000 + vdelay.usec / 1000;
    }
#endif
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

    0
};

/*
 * Declarations for functions defined later in this file.
 */

#ifndef WIN32_USE_TICKCOUNT
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);
#endif
static void		NativeScaleTime(Tcl_Time* timebuf,
			    ClientData clientData);
static void		NativeGetTime(Tcl_Time* timebuf,
			    ClientData clientData);

/*
 * TIP #233 (Virtualized Time): Data for the time hooks, if any.

     * Note: Outer check for 'initialized' is a performance win since it
     * avoids an extra mutex lock in the common case.
     */

    if (!timeInfo.initialized) {
	TclpInitLock();
	if (!timeInfo.initialized) {
#ifdef WIN32_USE_TICKCOUNT
	    timeInfo.perfCounterAvailable = 0;
#else
	    timeInfo.perfCounterAvailable =
		    QueryPerformanceFrequency(&timeInfo.nominalFreq);

	    /*
	     * Some hardware abstraction layers use the CPU clock in place of
	     * the real-time clock as a performance counter reference. This
	     * results in:

		 * outlive unloading tclXX.dll
		 */

		WaitForSingleObject(timeInfo.readyEvent, INFINITE);
		CloseHandle(timeInfo.readyEvent);
		Tcl_CreateExitHandler(StopCalibration, NULL);
	    }
#endif /* !WIN32_USE_TICKCOUNT */
	    timeInfo.initialized = TRUE;
	}
	TclpInitUnlock();
    }

    if (timeInfo.perfCounterAvailable && timeInfo.curCounterFreq.QuadPart!=0) {
	/*

	_ftime(&t);
	timePtr->sec = (long)t.time;
	timePtr->usec = t.millitm * 1000;
    }
}

#ifndef WIN32_USE_TICKCOUNT
/*
 *----------------------------------------------------------------------
 *
 * StopCalibration --
 *
 *	Turns off the calibration thread in preparation for exiting the
 *	process.

     * paused state so we need to timeout and continue.
     */

    WaitForSingleObject(timeInfo.calibrationThread, 100);
    CloseHandle(timeInfo.exitEvent);
    CloseHandle(timeInfo.calibrationThread);
}
#endif /* !WIN32_USE_TICKCOUNT */

/*
 *----------------------------------------------------------------------
 *
 * TclpGetDate --
 *
 *	This function converts between seconds and struct tm. If useGMT is

    if (tmPtr->tm_wday < 0) {
	tmPtr->tm_wday += 7;
    }

    return tmPtr;
}

#ifndef WIN32_USE_TICKCOUNT
/*
 *----------------------------------------------------------------------
 *
 * CalibrationThread --
 *
 *	Thread that manages calibration of the hi-resolution time derived from
 *	the performance counter, to keep it synchronized with the system

	if (++timeInfo.sampleNo >= SAMPLES) {
	    timeInfo.sampleNo = 0;
	}

	return estFreq;
    }
}
#endif /* !WIN32_USE_TICKCOUNT */

/*
 *----------------------------------------------------------------------
 *
 * TclpGmtime --
 *
 *	Wrapper around the 'gmtime' library function to make it thread safe.

void
Tcl_SetTimeProc(
    Tcl_GetTimeProc *getProc,
    Tcl_ScaleTimeProc *scaleProc,
    ClientData clientData)
{
#if !defined(WIN32_USE_TICKCOUNT) || (_WIN32_WINNT >= 0x0600)
    tclGetTimeProcPtr = getProc;
    tclScaleTimeProcPtr = scaleProc;
    tclTimeClientData = clientData;
#endif
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_QueryTimeProc --
 *