Tcl Source Code

    Tcl_EventCheckProc *checkProc;
    ClientData clientData;
    struct EventSource *nextPtr;
} EventSource;

/*
 * Used for performance purposes, threshold to bypass check source (if don't wait)
 * 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
#endif

/*
 * The following structure keeps track of the state of the notifier on a

	    }
	    return result;
	}
    }

    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

/*
 *----------------------------------------------------------------------
 *
 * TclPeekEventQueued --
 *
 *	Check whether some event (except idle) available (async, queued, timer).
 *

	/* once from here */
	if (!repeat) {
	    break;
	}

	if (flags & TCL_DONT_WAIT) {

	    /* don't need to wait/check for events too often */







    #if TCL_CHECK_EVENT_SOURCE_THRESHOLD
	    if (!CheckSourceThreshold(tsdPtr)) {
		return 0;
	    }

    #endif
	}

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

	     * if setup-proc resp. check-proc will not generate new events.
	     * Force timer execution if flags specified (from checkProc).
	     */
	    tsdPtr->timerMarkerPtr = flags ? INT2PTR(-1) : INT2PTR(-2);
	};
    }
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetServiceMode --
 *
 *	This routine returns the current service mode of the notifier.
 *

int
Tcl_GetServiceMode(void)
{
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    return tsdPtr->serviceMode;
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetServiceMode --
 *
 *	This routine sets the current service mode of the tsdPtr->
 *

    oldMode = tsdPtr->serviceMode;
    tsdPtr->serviceMode = mode;
    if (tclStubs.tcl_ServiceModeHook) {
	tclStubs.tcl_ServiceModeHook(mode);
    }
    return oldMode;
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetMaxBlockTime --
 *
 *	This function is invoked by event sources to tell the notifier how
 *	long it may block the next time it blocks. The timePtr argument gives

     * immediately.
     */

    if (!tsdPtr->inTraversal) {
	Tcl_SetTimer(&tsdPtr->blockTime);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_DoOneEvent --
 *
 *	Process a single event of some sort. If there's no work to do, wait
 *	for an event to occur, then process it.

	 * otherwise reset the block time to infinity.
	 */

	if (flags & TCL_DONT_WAIT) {

	    /* don't need to wait/check for events too often */
    #if TCL_CHECK_EVENT_SOURCE_THRESHOLD






	    if (!CheckSourceThreshold(tsdPtr)) {

		goto idleEvents;
	    }

    #endif

	    tsdPtr->blockTime.sec = 0;
	    tsdPtr->blockTime.usec = 0;
	    tsdPtr->blockTimeSet = 1;
	    timePtr = &tsdPtr->blockTime;
	    goto wait; /* for notifier resp. system events */
	}

    
    /* Reset block time earliest at the end of event cycle */
    tsdPtr->blockTimeSet = 0;

    tsdPtr->serviceMode = oldMode;
    return result;
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_ServiceAll --
 *
 *	This routine checks all of the event sources, processes events that
 *	are on the Tcl event queue, and then calls the any idle handlers.

    } else {
	Tcl_SetTimer(&tsdPtr->blockTime);
    }
    tsdPtr->inTraversal = 0;
    tsdPtr->serviceMode = TCL_SERVICE_ALL;
    return result;
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_ThreadAlert --
 *
 *	This function wakes up the notifier associated with the specified
 *	thread (if there is one).

		tclStubs.tcl_AlertNotifier(tsdPtr->clientData);
	    }
	    break;
	}
    }
    Tcl_MutexUnlock(&listLock);
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_Sleep --
 *
 *	Delay execution for the specified number of milliseconds.
 *