Removed async I/O support.

files/Makefile.in

@@ -8,7 +8,6 @@ VPATH      = @srcdir@
 MODULE     = files
 
 C_SRCS = \
-	async.c \
 	change.c \
 	directory.c \
 	dos_fs.c \

files/async.c

-/*
- * Generic async UNIX file IO handling
- *
- * Copyright 1996,1997 Alex Korobka
- * Copyright 1998 Marcus Meissner
- */
-/*
- * This file handles asynchronous signaling for UNIX filedescriptors. 
- * The passed handler gets called when input arrived for the filedescriptor.
- * 
- * This is done either by the kernel or (in the WINSOCK case) by the pipe
- * handler, since pipes do not support asynchronous signaling.
- * (Not all possible filedescriptors support async IO. Generic files do not
- *  for instance, sockets do, ptys don't.)
- * 
- * To make this a bit better, we would need an additional thread doing select()
- */
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#ifdef HAVE_SYS_PARAM_H
-# include <sys/param.h>
-#endif
-#ifdef HAVE_SYS_FILIO_H
-# include <sys/filio.h>
-#endif
-#ifdef HAVE_SYS_FILE_H
-# include <sys/file.h>
-#endif
-
-#include "xmalloc.h"
-#include "windef.h"
-#include "miscemu.h"
-#include "selectors.h"
-#include "sig_context.h"
-#include "async.h"
-#include "debugtools.h"
-
-typedef struct _async_fd {
-	int	unixfd;
-	void	(*handler)(int fd,void *private);
-	void	*private;
-} ASYNC_FD;
-
-static ASYNC_FD	*asyncfds = NULL;
-static int	 nrofasyncfds = 0;
-
-/***************************************************************************
- *		ASYNC_sigio				[internal]
- * 
- * Signal handler for asynchronous IO.
- *
- * Note: This handler and the function it calls may not block. Neither they
- * are allowed to use blocking IO (write/read). No memory management.
- * No possible blocking synchronization of any kind.
- */
-HANDLER_DEF(ASYNC_sigio) {
-	struct timeval	timeout;
-	fd_set	rset,wset;
-	int	i,maxfd=0;
-
-	HANDLER_INIT();
-
-	if (!nrofasyncfds) 
-		return;
-	FD_ZERO(&rset);
-	FD_ZERO(&wset);
-	for (i=nrofasyncfds;i--;) {
-		if (asyncfds[i].unixfd == -1)
-			continue;
-		FD_SET(asyncfds[i].unixfd,&rset);
-		FD_SET(asyncfds[i].unixfd,&wset);
-		if (maxfd<asyncfds[i].unixfd)
-			maxfd=asyncfds[i].unixfd;
-	}
-	/* select() with timeout values set to 0 is nonblocking. */
-	memset(&timeout,0,sizeof(timeout));
-	if (select(maxfd+1,&rset,&wset,NULL,&timeout)<=0)
-		return; /* Can't be. hmm */
-	for (i=nrofasyncfds;i--;)
-		if (	(FD_ISSET(asyncfds[i].unixfd,&rset)) ||
-			(FD_ISSET(asyncfds[i].unixfd,&wset))
-		)
-			asyncfds[i].handler(asyncfds[i].unixfd,asyncfds[i].private);
-}
-
-/***************************************************************************
- *		ASYNC_MakeFDAsync			[internal]
- *
- * Makes the passed filedescriptor async (or not) depending on flag.
- */
-static BOOL ASYNC_MakeFDAsync(int unixfd,int async) {
-#if !defined(FASYNC) && defined(FIOASYNC)
-#define FASYNC FIOASYNC
-#endif
-
-#ifdef FASYNC
-    int	flags;
-#endif
-
-#ifdef F_SETOWN
-    if (-1==fcntl(unixfd,F_SETOWN,getpid()))
-    	perror("fcntl F_SETOWN <pid>");
-#endif
-#ifdef FASYNC
-    if (-1==fcntl(unixfd,F_GETFL,&flags)) {
-	perror("fcntl F_GETFL");
-	return FALSE;
-    }
-    if (async)
-	flags|=FASYNC | O_NONBLOCK;
-    else
-	flags&=~(FASYNC | O_NONBLOCK);
-    if (-1==fcntl(unixfd,F_SETFL,&flags)) {
-	perror("fcntl F_SETFL FASYNC");
-	return FALSE;
-    }
-    return TRUE;
-#else
-    return FALSE;
-#endif
-}
-
-/***************************************************************************
- *		ASYNC_RegisterFD			[internal]
- *
- * Register a UNIX filedescriptor with handler and private data pointer. 
- * this function is _NOT_ safe to be called from a signal handler.
- *
- * Additional Constraint:  The handler passed to this function _MUST_ adhere
- * to the same signalsafeness as ASYNC_sigio itself. (nonblocking, no thread/
- * signal unsafe operations, no blocking synchronization)
- */
-void ASYNC_RegisterFD(int unixfd,void (*handler)(int fd,void *private),void *private) {
-    int	i;
-
-    SIGNAL_MaskAsyncEvents( TRUE );
-    for (i=0;i<nrofasyncfds;i++) {
-	if (asyncfds[i].unixfd==unixfd) {
-	    /* Might be a leftover entry. Make fd async anyway... */
-	    if (asyncfds[i].handler==handler) {
-	        ASYNC_MakeFDAsync(unixfd,1);
-		SIGNAL_MaskAsyncEvents( FALSE );
-	    	return;
-	    }
-	}
-    }
-   for (i=0;i<nrofasyncfds;i++)
-	if (asyncfds[i].unixfd == -1)
-		break;
-   if (i==nrofasyncfds) {
-       if (nrofasyncfds)
-	   asyncfds=(ASYNC_FD*)xrealloc(asyncfds,sizeof(ASYNC_FD)*(nrofasyncfds+1));
-       else
-	   asyncfds=(ASYNC_FD*)xmalloc(sizeof(ASYNC_FD)*1);
-       nrofasyncfds++;
-   }
-   asyncfds[i].unixfd	= unixfd;
-   asyncfds[i].handler	= handler;
-   asyncfds[i].private	= private;
-   ASYNC_MakeFDAsync(unixfd,1);
-   SIGNAL_MaskAsyncEvents( FALSE );
-}
-
-/***************************************************************************
- *		ASYNC_UnregisterFD			[internal]
- *
- * Unregister a UNIX filedescriptor with handler. This function is basically
- * signal safe, but try to not call it in the signal handler anyway.
- */
-void ASYNC_UnregisterFD(int unixfd,void (*handler)(int fd,void *private)) {
-    int	i;
-
-    for (i=nrofasyncfds;i--;)
-	if ((asyncfds[i].unixfd==unixfd)||(asyncfds[i].handler==handler))
-	    break;
-    if (i==nrofasyncfds)
-    	return;
-    asyncfds[i].unixfd	= -1;
-    asyncfds[i].handler	= NULL;
-    asyncfds[i].private	= NULL;
-    return;
-}

files/file.c

@@ -45,7 +45,6 @@
 #include "ldt.h"
 #include "process.h"
 #include "task.h"
-#include "async.h"
 #include "wincon.h"
 #include "debugtools.h"
 

include/async.h

-#ifndef __WINE_ASYNC_H
-#define __WINE_ASYNC_H
-
-extern void ASYNC_RegisterFD(int unixfd,void (*handler)(int fd,void *private),void *private);
-extern void ASYNC_UnregisterFD(int unixfd,void (*handler)(int fd,void *private));
-#endif

win32/console.c

@@ -39,7 +39,6 @@
 #include "wine/winuser16.h"
 #include "wine/keyboard16.h"
 #include "thread.h"
-#include "async.h"
 #include "file.h"
 #include "process.h"
 #include "winerror.h"