Tkinter isn't supported under Carbon. Under MacOSX native it is, but

that version doesn't need these workarounds.

3 files changed, 0 insertions, 975 deletions

diff --git a/Mac/tclmods/license-terms.txt b/Mac/tclmods/license-terms.txt
deleted file mode 100644
index 96ad966..0000000
--- a/Mac/tclmods/license-terms.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-This software is copyrighted by the Regents of the University of
-California, Sun Microsystems, Inc., and other parties.  The following
-terms apply to all files associated with the software unless explicitly
-disclaimed in individual files.
-
-The authors hereby grant permission to use, copy, modify, distribute,
-and license this software and its documentation for any purpose, provided
-that existing copyright notices are retained in all copies and that this
-notice is included verbatim in any distributions. No written agreement,
-license, or royalty fee is required for any of the authorized uses.
-Modifications to this software may be copyrighted by their authors
-and need not follow the licensing terms described here, provided that
-the new terms are clearly indicated on the first page of each file where
-they apply.
-
-IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
-FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
-ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
-DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
-THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
-IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
-NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
-MODIFICATIONS.
-
-GOVERNMENT USE: If you are acquiring this software on behalf of the
-U.S. government, the Government shall have only "Restricted Rights"
-in the software and related documentation as defined in the Federal 
-Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
-are acquiring the software on behalf of the Department of Defense, the
-software shall be classified as "Commercial Computer Software" and the
-Government shall have only "Restricted Rights" as defined in Clause
-252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the
-authors grant the U.S. Government and others acting in its behalf
-permission to use and distribute the software in accordance with the
-terms specified in this license. 
diff --git a/Mac/tclmods/tclMacNotify.c b/Mac/tclmods/tclMacNotify.c
deleted file mode 100644
index 8fc313a..0000000
--- a/Mac/tclmods/tclMacNotify.c
+++ /dev/null
@@ -1,429 +0,0 @@
-/* 
- * tclMacNotify.c --
- *
- *	This file contains Macintosh-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-1996 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: @(#) tclMacNotify.c 1.36 97/05/07 19:09:29
- */
-
-#ifdef USE_GUSI
-/* Move this include up otherwise tclPort.h tried to redefine signals */
-#include <sys/signal.h>
-#endif
-#include "tclInt.h"
-#include "tclPort.h"
-#include "tclMac.h"
-#include "tclMacInt.h"
-#include <signal.h>
-#include <Events.h>
-#include <LowMem.h>
-#include <Processes.h>
-#include <Timer.h>
-
-
-/* 
- * This is necessary to work around a bug in Apple's Universal header files
- * for the CFM68K libraries.
- */
-
-#ifdef __CFM68K__
-#undef GetEventQueue
-extern pascal QHdrPtr GetEventQueue(void)
- THREEWORDINLINE(0x2EBC, 0x0000, 0x014A);
-#pragma import list GetEventQueue
-#define GetEvQHdr() GetEventQueue()
-#endif
-
-/*
- * The follwing static indicates whether this module has been initialized.
- */
-
-static int initialized = 0;
-
-/*
- * The following structure contains the state information for the
- * notifier module.
- */
-
-static struct {
-    int timerActive;		/* 1 if timer is running. */
-    Tcl_Time timer;		/* Time when next timer event is expected. */
-    int flags;			/* OR'ed set of flags defined below. */
-    Point lastMousePosition;	/* Last known mouse location. */
-    RgnHandle utilityRgn;	/* Region used as the mouse region for
-				 * WaitNextEvent and the update region when
-				 * checking for events. */   
-    Tcl_MacConvertEventPtr eventProcPtr;
-				/* This pointer holds the address of the
-				 * function that will handle all incoming
-				 * Macintosh events. */
-} notifier;
-
-/*
- * The following defines are used in the flags field of the notifier struct.
- */
-
-#define NOTIFY_IDLE	(1<<1)	/* Tcl_ServiceIdle should be called. */
-#define NOTIFY_TIMER	(1<<2)	/* Tcl_ServiceTimer should be called. */
-
-/*
- * Prototypes for procedures that are referenced only in this file:
- */
-
-static int		HandleMacEvents _ANSI_ARGS_((void));
-static void		InitNotifier _ANSI_ARGS_((void));
-static void		NotifierExitHandler _ANSI_ARGS_((
-			    ClientData clientData));
-
-/*
- *----------------------------------------------------------------------
- *
- * InitNotifier --
- *
- *	Initializes the notifier structure.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Creates a new exit handler.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-InitNotifier(void)
-{
-    initialized = 1;
-    memset(&notifier, 0, sizeof(notifier));
-    Tcl_CreateExitHandler(NotifierExitHandler, NULL);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * NotifierExitHandler --
- *
- *	This function is called to cleanup the notifier state before
- *	Tcl is unloaded.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-NotifierExitHandler(
-    ClientData clientData)	/* Not used. */
-{
-    initialized = 0;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * HandleMacEvents --
- *
- *	This function checks for events from the Macintosh event queue.
- *
- * Results:
- *	Returns 1 if event found, 0 otherwise.
- *
- * Side effects:
- *	Pulls events off of the Mac event queue and then calls
- *	convertEventProc.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-HandleMacEvents(void)
-{
-    EventRecord theEvent;
-    int eventFound = 0, needsUpdate = 0;
-    Point currentMouse;
-    WindowRef windowRef;
-    Rect mouseRect;
-
-    /*
-     * Check for mouse moved events.  These events aren't placed on the
-     * system event queue unless we call WaitNextEvent.
-     */
-
-    GetGlobalMouse(&currentMouse);
-    if ((notifier.eventProcPtr != NULL) &&
-	    !EqualPt(currentMouse, notifier.lastMousePosition)) {
-	notifier.lastMousePosition = currentMouse;
-	theEvent.what = nullEvent;
-	if ((*notifier.eventProcPtr)(&theEvent) == true) {
-	    eventFound = 1;
-	}
-    }
-
-    /*
-     * Check for update events.  Since update events aren't generated
-     * until we call GetNextEvent, we may need to force a call to
-     * GetNextEvent, even if the queue is empty.
-     */
-
-    for (windowRef = FrontWindow(); windowRef != NULL;
-	    windowRef = GetNextWindow(windowRef)) {
-	GetWindowUpdateRgn(windowRef, notifier.utilityRgn);
-	if (!EmptyRgn(notifier.utilityRgn)) {
-	    needsUpdate = 1;
-	    break;
-	}
-    }
-    
-    /*
-     * Process events from the OS event queue.
-     */
-
-    while (needsUpdate || (GetEvQHdr()->qHead != NULL)) {
-	GetGlobalMouse(&currentMouse);
-	SetRect(&mouseRect, currentMouse.h, currentMouse.v,
-		currentMouse.h + 1, currentMouse.v + 1);
-	RectRgn(notifier.utilityRgn, &mouseRect);
-	
-	WaitNextEvent(everyEvent, &theEvent, 5, notifier.utilityRgn);
-	needsUpdate = 0;
-	if ((notifier.eventProcPtr != NULL)
-		&& ((*notifier.eventProcPtr)(&theEvent) == true)) {
-	    eventFound = 1;
-	}
-    }
-    
-    return eventFound;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_SetTimer --
- *
- *	This procedure sets the current notifier timer value.  The
- *	notifier will ensure that Tcl_ServiceAll() is called after
- *	the specified interval, even if no events have occurred.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Replaces any previous timer.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_SetTimer(
-    Tcl_Time *timePtr)		/* New value for interval timer. */
-{
-    if (!timePtr) {
-	notifier.timerActive = 0;
-    } else {
-	/*
-	 * Compute when the timer should fire.
-	 */
-	
-	TclpGetTime(&notifier.timer);
-	notifier.timer.sec += timePtr->sec;
-	notifier.timer.usec += timePtr->usec;
-	if (notifier.timer.usec >= 1000000) {
-	    notifier.timer.usec -= 1000000;
-	    notifier.timer.sec += 1;
-	}
-	notifier.timerActive = 1;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_WaitForEvent --
- *
- *	This function is called by Tcl_DoOneEvent to wait for new
- *	events on the message queue.  If the block time is 0, then
- *	Tcl_WaitForEvent just polls the event queue without blocking.
- *
- * Results:
- *	Always returns 0.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_WaitForEvent(
-    Tcl_Time *timePtr)		/* Maximum block time. */
-{
-    int found;
-    EventRecord macEvent;
-    long sleepTime = 5;
-    long ms;
-    Point currentMouse;
-    void * timerToken;
-    Rect mouseRect;
-
-    /*
-     * Compute the next timeout value.
-     */
-
-    if (!timePtr) {
-	ms = INT_MAX;
-    } else {
-	ms = (timePtr->sec * 1000) + (timePtr->usec / 1000);
-    }
-    timerToken = TclMacStartTimer((long) ms);
-   
-    /*
-     * Poll the Mac event sources.  This loop repeats until something
-     * happens: a timeout, a socket event, mouse motion, or some other
-     * window event.  Note that we don't call WaitNextEvent if another
-     * event is found to avoid context switches.  This effectively gives
-     * events coming in via WaitNextEvent a slightly lower priority.
-     */
-
-    found = 0;
-    if (notifier.utilityRgn == NULL) {
-	notifier.utilityRgn = NewRgn();
-    }
-
-    while (!found) {
-	/*
-	 * Check for generated and queued events.
-	 */
-
-	if (HandleMacEvents()) {
-	    found = 1;
-	}
-
-	/*
-	 * Check for time out.
-	 */
-
-	if (!found && TclMacTimerExpired(timerToken)) {
-	    found = 1;
-	}
-	
-	/*
-	 * Mod by Jack: poll for select() events. Code is in TclSelectNotify.c
-	 */
-	{
-	    int Tcl_PollSelectEvent(void);
-	    if (!found && Tcl_PollSelectEvent())
-		found = 1;
-	}
-
-	/*
-	 * Check for window events.  We may receive a NULL event for
-	 * various reasons. 1) the timer has expired, 2) a mouse moved
-	 * event is occuring or 3) the os is giving us time for idle
-	 * events.  Note that we aren't sharing the processor very
-	 * well here.  We really ought to do a better job of calling
-	 * WaitNextEvent for time slicing purposes.
-	 */
-
-	if (!found) {
-	    /*
-	     * Set up mouse region so we will wake if the mouse is moved.
-	     * We do this by defining the smallest possible region around
-	     * the current mouse position.
-	     */
-
-	    GetGlobalMouse(&currentMouse);
-	    SetRect(&mouseRect, currentMouse.h, currentMouse.v,
-		    currentMouse.h + 1, currentMouse.v + 1);
-	    RectRgn(notifier.utilityRgn, &mouseRect);
-	
-	    WaitNextEvent(everyEvent, &macEvent, sleepTime,
-		    notifier.utilityRgn);
-
-	    if (notifier.eventProcPtr != NULL) {
-		if ((*notifier.eventProcPtr)(&macEvent) == true) {
-		    found = 1;
-		}
-	    }
-	}
-    }
-    TclMacRemoveTimer(timerToken);
-    return 0;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_Sleep --
- *
- *	Delay execution for the specified number of milliseconds.  This
- *	is not a very good call to make.  It will block the system -
- *	you will not even be able to switch applications.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Time passes.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_Sleep(
-    int ms)			/* Number of milliseconds to sleep. */
-{
-    EventRecord dummy;
-    void *timerToken;
-    
-    if (ms <= 0) {
-	return;
-    }
-    
-    timerToken = TclMacStartTimer((long) ms);
-    while (1) {
-	WaitNextEvent(0, &dummy, (ms / 16.66) + 1, NULL);
-	
-	if (TclMacTimerExpired(timerToken)) {
-	    break;
-	}
-    }
-    TclMacRemoveTimer(timerToken);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_MacSetEventProc --
- *
- *	This function sets the event handling procedure for the 
- *	application.  This function will be passed all incoming Mac
- *	events.  This function usually controls the console or some
- *	other entity like Tk.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Changes the event handling function.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_MacSetEventProc(
-    Tcl_MacConvertEventPtr procPtr)
-{
-    notifier.eventProcPtr = procPtr;
-}
diff --git a/Mac/tclmods/tclSelectNotify.c b/Mac/tclmods/tclSelectNotify.c
deleted file mode 100644
index a728442..0000000
--- a/Mac/tclmods/tclSelectNotify.c
+++ /dev/null
@@ -1,507 +0,0 @@
-/*
- * tclSelectNotify.c --
- *
- * Partial even handling, select only. This file is adapted from TclUnixNotify.c, and
- * meant as an add-in for Mac (and possibly Windows) environments where select *is* available.
- * TclMacNotify.c works together with this file.
- *
- * Copyright (c) 1995-1997 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.42 97/07/02 20:55:44
- */
-
-#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)
-	#pragma import on
-#endif
-
-#include <unistd.h>
-
-#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)
-	#pragma import reset
-#endif
-
-#ifdef USE_GUSI
-/* Move this include up otherwise tclPort.h tried to redefine signals */
-#include <sys/signal.h>
-#endif
-#include "tclInt.h"
-#include "tclPort.h"
-#include <signal.h> 
-
-#ifndef MASK_SIZE
-#define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
-#endif
-#ifndef SELECT_MASK
-#define SELECT_MASK fd_set
-#endif
-
-/* Prototype (too lazy to create new .h) */
-int Tcl_PollSelectEvent(void);
-
-/*
- * This structure is used to keep track of the notifier info for a 
- * a registered file.
- */
-
-typedef struct FileHandler {
-    int fd;
-    int mask;			/* Mask of desired events: TCL_READABLE,
-				 * etc. */
-    int readyMask;		/* Mask of events that have been seen since the
-				 * last time file handlers were invoked for
-				 * this file. */
-    Tcl_FileProc *proc;		/* Procedure to call, in the style of
-				 * Tcl_CreateFileHandler. */
-    ClientData clientData;	/* Argument to pass to proc. */
-    struct FileHandler *nextPtr;/* Next in list of all files we care about. */
-} FileHandler;
-
-/*
- * The following structure is what is added to the Tcl event queue when
- * file handlers are ready to fire.
- */
-
-typedef struct FileHandlerEvent {
-    Tcl_Event header;		/* Information that is standard for
-				 * all events. */
-    int fd;			/* File descriptor that is ready.  Used
-				 * to find the FileHandler structure for
-				 * the file (can't point directly to the
-				 * FileHandler structure because it could
-				 * go away while the event is queued). */
-} FileHandlerEvent;
-
-/*
- * The following static structure contains the state information for the
- * select based implementation of the Tcl notifier.
- */
-
-static struct {
-    FileHandler *firstFileHandlerPtr;
-				/* Pointer to head of file handler list. */
-    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_CreateFileHandler. */
-    fd_mask readyMasks[3*MASK_SIZE];
-				/* This array reflects the readable/writable
-				 * conditions that were found to exist by the
-				 * last call to select. */
-    int numFdBits;		/* Number of valid bits in checkMasks
-				 * (one more than highest fd for which
-				 * Tcl_WatchFile has been called). */
-} notifier;
-
-/*
- * The following static indicates whether this module has been initialized.
- */
-
-static int initialized = 0;
-
-/*
- * Static routines defined in this file.
- */
-
-static void		InitNotifier _ANSI_ARGS_((void));
-static void		NotifierExitHandler _ANSI_ARGS_((
-			    ClientData clientData));
-static int		FileHandlerEventProc _ANSI_ARGS_((Tcl_Event *evPtr,
-			    int flags));
-
-/*
- *----------------------------------------------------------------------
- *
- * InitNotifier --
- *
- *	Initializes the notifier state.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Creates a new exit handler.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-InitNotifier()
-{
-    initialized = 1;
-    memset(&notifier, 0, sizeof(notifier));
-    Tcl_CreateExitHandler(NotifierExitHandler, NULL);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * NotifierExitHandler --
- *
- *	This function is called to cleanup the notifier state before
- *	Tcl is unloaded.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Destroys the notifier window.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-NotifierExitHandler(clientData)
-    ClientData clientData;		/* Not used. */
-{
-    initialized = 0;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_CreateFileHandler --
- *
- *	This procedure registers a file handler with the Xt notifier.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Creates a new file handler structure and registers one or more
- *	input procedures with Xt.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_CreateFileHandler(fd, mask, proc, clientData)
-    int fd;			/* Handle of stream to watch. */
-    int mask;			/* OR'ed combination of TCL_READABLE,
-				 * TCL_WRITABLE, and TCL_EXCEPTION:
-				 * indicates conditions under which
-				 * proc should be called. */
-    Tcl_FileProc *proc;		/* Procedure to call for each
-				 * selected event. */
-    ClientData clientData;	/* Arbitrary data to pass to proc. */
-{
-    FileHandler *filePtr;
-    int index, bit;
-    
-    if (!initialized) {
-	InitNotifier();
-    }
-
-    for (filePtr = notifier.firstFileHandlerPtr; filePtr != NULL;
-	    filePtr = filePtr->nextPtr) {
-	if (filePtr->fd == fd) {
-	    break;
-	}
-    }
-    if (filePtr == NULL) {
-	filePtr = (FileHandler*) ckalloc(sizeof(FileHandler)); /* MLK */
-	filePtr->fd = fd;
-	filePtr->readyMask = 0;
-	filePtr->nextPtr = notifier.firstFileHandlerPtr;
-	notifier.firstFileHandlerPtr = filePtr;
-    }
-    filePtr->proc = proc;
-    filePtr->clientData = clientData;
-    filePtr->mask = mask;
-
-    /*
-     * Update the check masks for this file.
-     */
-
-    index = fd/(NBBY*sizeof(fd_mask));
-    bit = 1 << (fd%(NBBY*sizeof(fd_mask)));
-    if (mask & TCL_READABLE) {
-	notifier.checkMasks[index] |= bit;
-    } else {
-	notifier.checkMasks[index] &= ~bit;
-    } 
-    if (mask & TCL_WRITABLE) {
-	(notifier.checkMasks+MASK_SIZE)[index] |= bit;
-    } else {
-	(notifier.checkMasks+MASK_SIZE)[index] &= ~bit;
-    }
-    if (mask & TCL_EXCEPTION) {
-	(notifier.checkMasks+2*(MASK_SIZE))[index] |= bit;
-    } else {
-	(notifier.checkMasks+2*(MASK_SIZE))[index] &= ~bit;
-    }
-    if (notifier.numFdBits <= fd) {
-	notifier.numFdBits = fd+1;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DeleteFileHandler --
- *
- *	Cancel a previously-arranged callback arrangement for
- *	a file.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	If a callback was previously registered on file, remove it.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_DeleteFileHandler(fd)
-    int fd;		/* Stream id for which to remove callback procedure. */
-{
-    FileHandler *filePtr, *prevPtr;
-    int index, bit, mask, i;
-
-    if (!initialized) {
-	InitNotifier();
-    }
-
-    /*
-     * Find the entry for the given file (and return if there
-     * isn't one).
-     */
-
-    for (prevPtr = NULL, filePtr = notifier.firstFileHandlerPtr; ;
-	    prevPtr = filePtr, filePtr = filePtr->nextPtr) {
-	if (filePtr == NULL) {
-	    return;
-	}
-	if (filePtr->fd == fd) {
-	    break;
-	}
-    }
-
-    /*
-     * Update the check masks for this file.
-     */
-
-    index = fd/(NBBY*sizeof(fd_mask));
-    bit = 1 << (fd%(NBBY*sizeof(fd_mask)));
-
-    if (filePtr->mask & TCL_READABLE) {
-	notifier.checkMasks[index] &= ~bit;
-    }
-    if (filePtr->mask & TCL_WRITABLE) {
-	(notifier.checkMasks+MASK_SIZE)[index] &= ~bit;
-    }
-    if (filePtr->mask & TCL_EXCEPTION) {
-	(notifier.checkMasks+2*(MASK_SIZE))[index] &= ~bit;
-    }
-
-    /*
-     * Find current max fd.
-     */
-
-    if (fd+1 == notifier.numFdBits) {
-	for (notifier.numFdBits = 0; index >= 0; index--) {
-	    mask = notifier.checkMasks[index]
-		| (notifier.checkMasks+MASK_SIZE)[index]
-		| (notifier.checkMasks+2*(MASK_SIZE))[index];
-	    if (mask) {
-		for (i = (NBBY*sizeof(fd_mask)); i > 0; i--) {
-		    if (mask & (1 << (i-1))) {
-			break;
-		    }
-		}
-		notifier.numFdBits = index * (NBBY*sizeof(fd_mask)) + i;
-		break;
-	    }
-	}
-    }
-
-    /*
-     * Clean up information in the callback record.
-     */
-
-    if (prevPtr == NULL) {
-	notifier.firstFileHandlerPtr = filePtr->nextPtr;
-    } else {
-	prevPtr->nextPtr = filePtr->nextPtr;
-    }
-    ckfree((char *) filePtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * FileHandlerEventProc --
- *
- *	This procedure is called by Tcl_ServiceEvent when a file event
- *	reaches the front of the event queue.  This procedure is
- *	responsible for actually handling the event by invoking the
- *	callback for the file handler.
- *
- * 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_FILE_EVENTS flag bit isn't set.
- *
- * Side effects:
- *	Whatever the file handler's callback procedure does.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-FileHandlerEventProc(evPtr, flags)
-    Tcl_Event *evPtr;		/* Event to service. */
-    int flags;			/* Flags that indicate what events to
-				 * handle, such as TCL_FILE_EVENTS. */
-{
-    FileHandler *filePtr;
-    FileHandlerEvent *fileEvPtr = (FileHandlerEvent *) evPtr;
-    int mask;
-
-    if (!(flags & TCL_FILE_EVENTS)) {
-	return 0;
-    }
-
-    /*
-     * Search through the file handlers to find the one whose handle matches
-     * the event.  We do this rather than keeping a pointer to the file
-     * handler directly in the event, so that the handler can be deleted
-     * while the event is queued without leaving a dangling pointer.
-     */
-
-    for (filePtr = notifier.firstFileHandlerPtr; filePtr != NULL;
-	    filePtr = filePtr->nextPtr) {
-	if (filePtr->fd != fileEvPtr->fd) {
-	    continue;
-	}
-
-	/*
-	 * The code is tricky for two reasons:
-	 * 1. The file handler's desired events could have changed
-	 *    since the time when the event was queued, so AND the
-	 *    ready mask with the desired mask.
-	 * 2. The file could have been closed and re-opened since
-	 *    the time when the event was queued.  This is why the
-	 *    ready mask is stored in the file handler rather than
-	 *    the queued event:  it will be zeroed when a new
-	 *    file handler is created for the newly opened file.
-	 */
-
-	mask = filePtr->readyMask & filePtr->mask;
-	filePtr->readyMask = 0;
-	if (mask != 0) {
-	    (*filePtr->proc)(filePtr->clientData, mask);
-	}
-	break;
-    }
-    return 1;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_PollSelectEvent --
- *
- *	This function is called by Tcl_WaitForEvent to wait for new
- *	events on the message queue.  If the block time is 0, then
- *	Tcl_WaitForEvent just polls without blocking.
- *
- * Results:
- *	Returns 1 if any event handled, 0 otherwise.
- *
- * Side effects:
- *	Queues file events that are detected by the select.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_PollSelectEvent(void)
-{
-    FileHandler *filePtr;
-    FileHandlerEvent *fileEvPtr;
-    struct timeval timeout, *timeoutPtr;
-    int bit, index, mask, numFound;
-
-    if (!initialized) {
-	InitNotifier();
-    }
-
-    /*
-     * Set up the timeout structure. 
-     */
-
-    timeout.tv_sec = 0;
-    timeout.tv_usec = 0;
-    timeoutPtr = &timeout;
-
-    memcpy((VOID *) notifier.readyMasks, (VOID *) notifier.checkMasks,
-	    3*MASK_SIZE*sizeof(fd_mask));
-    numFound = select(notifier.numFdBits,
-	    (SELECT_MASK *) &notifier.readyMasks[0],
-	    (SELECT_MASK *) &notifier.readyMasks[MASK_SIZE],
-	    (SELECT_MASK *) &notifier.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 *) notifier.readyMasks, 0, 3*MASK_SIZE*sizeof(fd_mask));
-    }
-    
-    /*
-     * Return if nothing to do.
-     */
-    if ( numFound == 0 )
-    	return 0;
-
-    /*
-     * Queue all detected file events before returning.
-     */
-
-    for (filePtr = notifier.firstFileHandlerPtr;
-	    (filePtr != NULL) && (numFound > 0);
-	    filePtr = filePtr->nextPtr) {
-	index = filePtr->fd / (NBBY*sizeof(fd_mask));
-	bit = 1 << (filePtr->fd % (NBBY*sizeof(fd_mask)));
-	mask = 0;
-
-	if (notifier.readyMasks[index] & bit) {
-	    mask |= TCL_READABLE;
-	}
-	if ((notifier.readyMasks+MASK_SIZE)[index] & bit) {
-	    mask |= TCL_WRITABLE;
-	}
-	if ((notifier.readyMasks+2*(MASK_SIZE))[index] & bit) {
-	    mask |= TCL_EXCEPTION;
-	}
-
-	if (!mask) {
-	    continue;
-	} else {
-	    numFound--;
-	}
-
-	/*
-	 * Don't bother to queue an event if the mask was previously
-	 * non-zero since an event must still be on the queue.
-	 */
-
-	if (filePtr->readyMask == 0) {
-	    fileEvPtr = (FileHandlerEvent *) ckalloc(
-		sizeof(FileHandlerEvent));
-	    fileEvPtr->header.proc = FileHandlerEventProc;
-	    fileEvPtr->fd = filePtr->fd;
-	    Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
-	}
-	filePtr->readyMask = mask;
-    }
-    return 1;
-}