Peter Howkins
352 lines
9.4 KiB
C
352 lines
9.4 KiB
C
/*
|
|
* CDE - Common Desktop Environment
|
|
*
|
|
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
|
*
|
|
* These libraries and programs are free software; you can
|
|
* redistribute them and/or modify them under the terms of the GNU
|
|
* Lesser General Public License as published by the Free Software
|
|
* Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* These libraries and programs are distributed in the hope that
|
|
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
|
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU Lesser General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with these libraries and programs; if not, write
|
|
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
* Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
/* $TOG: tclUnixNotfy.c /main/3 1998/04/06 13:37:34 mgreess $ */
|
|
/*
|
|
* tclUnixNotify.c --
|
|
*
|
|
* This file contains Unix-specific procedures for the notifier,
|
|
* which is the lowest-level part of the Tcl event loop. This file
|
|
* works together with ../generic/tclNotify.c.
|
|
*
|
|
* Copyright (c) 1995 Sun Microsystems, Inc.
|
|
*
|
|
* See the file "license.terms" for information on usage and redistribution
|
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
|
*
|
|
* SCCS: @(#) tclUnixNotfy.c 1.30 96/03/22 12:45:31
|
|
*/
|
|
|
|
#include "tclInt.h"
|
|
#include "tclPort.h"
|
|
#include <signal.h>
|
|
#include <sys/time.h>
|
|
|
|
/*
|
|
* The information below is used to provide read, write, and
|
|
* exception masks to select during calls to Tcl_DoOneEvent.
|
|
*/
|
|
|
|
static fd_mask checkMasks[3*MASK_SIZE];
|
|
/* This array is used to build up the masks
|
|
* to be used in the next call to select.
|
|
* Bits are set in response to calls to
|
|
* Tcl_WatchFile. */
|
|
static fd_mask readyMasks[3*MASK_SIZE];
|
|
/* This array reflects the readable/writable
|
|
* conditions that were found to exist by the
|
|
* last call to select. */
|
|
static int numFdBits; /* Number of valid bits in checkMasks
|
|
* (one more than highest fd for which
|
|
* Tcl_WatchFile has been called). */
|
|
|
|
/*
|
|
* Static routines in this file:
|
|
*/
|
|
|
|
static int MaskEmpty _ANSI_ARGS_((long *maskPtr));
|
|
|
|
/*
|
|
*----------------------------------------------------------------------
|
|
*
|
|
* Tcl_WatchFile --
|
|
*
|
|
* Arrange for Tcl_DoOneEvent to include this file in the masks
|
|
* for the next call to select. This procedure is invoked by
|
|
* event sources, which are in turn invoked by Tcl_DoOneEvent
|
|
* before it invokes select.
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side effects:
|
|
*
|
|
* The notifier will generate a file event when the I/O channel
|
|
* given by fd next becomes ready in the way indicated by mask.
|
|
* If fd is already registered then the old mask will be replaced
|
|
* with the new one. Once the event is sent, the notifier will
|
|
* not send any more events about the fd until the next call to
|
|
* Tcl_NotifyFile.
|
|
*
|
|
*----------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
Tcl_WatchFile(
|
|
Tcl_File file, /* Generic file handle for a stream. */
|
|
int mask /* OR'ed combination of TCL_READABLE,
|
|
* TCL_WRITABLE, and TCL_EXCEPTION:
|
|
* indicates conditions to wait for
|
|
* in select. */
|
|
)
|
|
{
|
|
int fd, type, index;
|
|
fd_mask bit;
|
|
|
|
fd = (int) (intptr_t) Tcl_GetFileInfo(file, &type);
|
|
|
|
if (type != TCL_UNIX_FD) {
|
|
panic("Tcl_WatchFile: unexpected file type");
|
|
}
|
|
|
|
if (fd >= FD_SETSIZE) {
|
|
panic("Tcl_WatchFile can't handle file id %d", fd);
|
|
}
|
|
|
|
index = fd/(NBBY*sizeof(fd_mask));
|
|
bit = 1 << (fd%(NBBY*sizeof(fd_mask)));
|
|
if (mask & TCL_READABLE) {
|
|
checkMasks[index] |= bit;
|
|
}
|
|
if (mask & TCL_WRITABLE) {
|
|
(checkMasks+MASK_SIZE)[index] |= bit;
|
|
}
|
|
if (mask & TCL_EXCEPTION) {
|
|
(checkMasks+2*(MASK_SIZE))[index] |= bit;
|
|
}
|
|
if (numFdBits <= fd) {
|
|
numFdBits = fd+1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
*----------------------------------------------------------------------
|
|
*
|
|
* Tcl_FileReady --
|
|
*
|
|
* Indicates what conditions (readable, writable, etc.) were
|
|
* present on a file the last time the notifier invoked select.
|
|
* This procedure is typically invoked by event sources to see
|
|
* if they should queue events.
|
|
*
|
|
* Results:
|
|
* The return value is 0 if none of the conditions specified by mask
|
|
* was true for fd the last time the system checked. If any of the
|
|
* conditions were true, then the return value is a mask of those
|
|
* that were true.
|
|
*
|
|
* Side effects:
|
|
* None.
|
|
*
|
|
*----------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
Tcl_FileReady(
|
|
Tcl_File file, /* Generic file handle for a stream. */
|
|
int mask /* OR'ed combination of TCL_READABLE,
|
|
* TCL_WRITABLE, and TCL_EXCEPTION:
|
|
* indicates conditions caller cares about. */
|
|
)
|
|
{
|
|
int index, result, type, fd;
|
|
fd_mask bit;
|
|
|
|
fd = (int) (intptr_t) Tcl_GetFileInfo(file, &type);
|
|
if (type != TCL_UNIX_FD) {
|
|
panic("Tcl_FileReady: unexpected file type");
|
|
}
|
|
|
|
index = fd/(NBBY*sizeof(fd_mask));
|
|
bit = 1 << (fd%(NBBY*sizeof(fd_mask)));
|
|
result = 0;
|
|
if ((mask & TCL_READABLE) && (readyMasks[index] & bit)) {
|
|
result |= TCL_READABLE;
|
|
}
|
|
if ((mask & TCL_WRITABLE) && ((readyMasks+MASK_SIZE)[index] & bit)) {
|
|
result |= TCL_WRITABLE;
|
|
}
|
|
if ((mask & TCL_EXCEPTION) && ((readyMasks+(2*MASK_SIZE))[index] & bit)) {
|
|
result |= TCL_EXCEPTION;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
*----------------------------------------------------------------------
|
|
*
|
|
* MaskEmpty --
|
|
*
|
|
* Returns nonzero if mask is empty (has no bits set).
|
|
*
|
|
* Results:
|
|
* Nonzero if the mask is empty, zero otherwise.
|
|
*
|
|
* Side effects:
|
|
* None
|
|
*
|
|
*----------------------------------------------------------------------
|
|
*/
|
|
|
|
static int
|
|
MaskEmpty(
|
|
long *maskPtr
|
|
)
|
|
{
|
|
long *runPtr, *tailPtr;
|
|
int found, sz;
|
|
|
|
sz = 3 * ((MASK_SIZE) / sizeof(long)) * sizeof(fd_mask);
|
|
for (runPtr = maskPtr, tailPtr = maskPtr + sz, found = 0;
|
|
runPtr < tailPtr;
|
|
runPtr++) {
|
|
if (*runPtr != 0) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
return !found;
|
|
}
|
|
|
|
/*
|
|
*----------------------------------------------------------------------
|
|
*
|
|
* Tcl_WaitForEvent --
|
|
*
|
|
* This procedure does the lowest level wait for events in a
|
|
* platform-specific manner. It uses information provided by
|
|
* previous calls to Tcl_WatchFile, plus the timePtr argument,
|
|
* to determine what to wait for and how long to wait.
|
|
*
|
|
* Results:
|
|
* The return value is normally TCL_OK. However, if there are
|
|
* no events to wait for (e.g. no files and no timers) so that
|
|
* the procedure would block forever, then it returns TCL_ERROR.
|
|
*
|
|
* Side effects:
|
|
* May put the process to sleep for a while, depending on timePtr.
|
|
* When this procedure returns, an event of interest to the application
|
|
* has probably, but not necessarily, occurred.
|
|
*
|
|
*----------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
Tcl_WaitForEvent(
|
|
Tcl_Time *timePtr /* Specifies the maximum amount of time
|
|
* that this procedure should block before
|
|
* returning. The time is given as an
|
|
* interval, not an absolute wakeup time.
|
|
* NULL means block forever. */
|
|
)
|
|
{
|
|
struct timeval timeout, *timeoutPtr;
|
|
int numFound;
|
|
|
|
memcpy((VOID *) readyMasks, (VOID *) checkMasks,
|
|
3*MASK_SIZE*sizeof(fd_mask));
|
|
if (timePtr == NULL) {
|
|
if ((numFdBits == 0) || (MaskEmpty((long *) readyMasks))) {
|
|
return TCL_ERROR;
|
|
}
|
|
timeoutPtr = NULL;
|
|
} else {
|
|
timeoutPtr = &timeout;
|
|
timeout.tv_sec = timePtr->sec;
|
|
timeout.tv_usec = timePtr->usec;
|
|
}
|
|
numFound = select(numFdBits, (SELECT_MASK *) &readyMasks[0],
|
|
(SELECT_MASK *) &readyMasks[MASK_SIZE],
|
|
(SELECT_MASK *) &readyMasks[2*MASK_SIZE], timeoutPtr);
|
|
|
|
/*
|
|
* Some systems don't clear the masks after an error, so
|
|
* we have to do it here.
|
|
*/
|
|
|
|
if (numFound == -1) {
|
|
memset((VOID *) readyMasks, 0, 3*MASK_SIZE*sizeof(fd_mask));
|
|
}
|
|
|
|
/*
|
|
* Reset the check masks in preparation for the next call to
|
|
* select.
|
|
*/
|
|
|
|
numFdBits = 0;
|
|
memset((VOID *) checkMasks, 0, 3*MASK_SIZE*sizeof(fd_mask));
|
|
return TCL_OK;
|
|
}
|
|
|
|
/*
|
|
*----------------------------------------------------------------------
|
|
*
|
|
* 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. */
|
|
)
|
|
{
|
|
static struct timeval delay;
|
|
Tcl_Time before, after;
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
TclGetTime(&before);
|
|
after = before;
|
|
after.sec += ms/1000;
|
|
after.usec += (ms%1000)*1000;
|
|
if (after.usec > 1000000) {
|
|
after.usec -= 1000000;
|
|
after.sec += 1;
|
|
}
|
|
while (1) {
|
|
delay.tv_sec = after.sec - before.sec;
|
|
delay.tv_usec = after.usec - before.usec;
|
|
if (delay.tv_usec < 0) {
|
|
delay.tv_usec += 1000000;
|
|
delay.tv_sec -= 1;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
(void) select(0, (SELECT_MASK *) 0, (SELECT_MASK *) 0,
|
|
(SELECT_MASK *) 0, &delay);
|
|
TclGetTime(&before);
|
|
}
|
|
}
|
|
|