* to do read/write operation. Additionally
				 * used as signal to stop (state set to -1) */
    volatile LONG state;	/* Indicates current state of the thread */
    ClientData clientData;	/* Referenced data of the main thread */
} PipeThreadInfo;


/* If pipe-workers will use some tcl subsystem, we can use ckalloc without
 * more overhead for finalize thread (should be executed anyway)
 *
 * #define _PTI_USE_CKALLOC 1
 */

/*
 * State of the pipe-worker.
 * 
 * State PTI_STATE_STOP possible from idle state only, worker owns TI structure.
 * Otherwise PTI_STATE_END used (main thread hold ownership of the TI).
 */

#define PTI_STATE_IDLE	0
#define PTI_STATE_WORK	1
#define PTI_STATE_STOP	2
#define PTI_STATE_END	4
#define PTI_STATE_DOWN  8
#define PTI_STATE_IDLE	0	/* idle or not yet initialzed */
#define PTI_STATE_WORK	1	/* in work */
#define PTI_STATE_STOP	2	/* thread should stop work (owns TI structure) */
#define PTI_STATE_END	4	/* thread should stop work (worker is busy) */
#define PTI_STATE_DOWN  8	/* worker is down */


PipeThreadInfo *
PipeThreadCreateTI(
    PipeThreadInfo **pipeTIPtr,
    ClientData clientData)
{
    PipeThreadInfo *pipeTI;
#ifndef _PTI_USE_CKALLOC
    pipeTI = malloc(sizeof(PipeThreadInfo));
#else
    pipeTI = ckalloc(sizeof(PipeThreadInfo));
#endif
    pipeTI->evControl = CreateEvent(NULL, FALSE, FALSE, NULL);
    pipeTI->state = PTI_STATE_IDLE;
    pipeTI->clientData = clientData;
    return (*pipeTIPtr = pipeTI);
}

int
PipeThreadWaitForSignal(
    PipeThreadInfo **pipeTIPtr)
{
    PipeThreadInfo *pipeTI = *pipeTIPtr;
    LONG state;

	    /*
	     * Wait at most 20 milliseconds for the reader thread to
	     * close (regarding TIP#398-fast-exit).
	     */

	    /* if we want TIP#398-fast-exit. */
	    if (WaitForSingleObject(hThread,
		    TclInExit() ? 0 : 0) == WAIT_TIMEOUT) {
		    TclInExit() ? 0 : 20) == WAIT_TIMEOUT) {

		/*
		 * The thread must be blocked waiting for the pipe to
		 * become readable in ReadFile(). There isn't a clean way
		 * to exit the thread from this condition. We should
		 * terminate the child process instead to get the reader
		 * thread to fall out of ReadFile with a FALSE. (below) is

	    }
	}
    }

    *pipeTIPtr = NULL;
    if (pipeTI) {
	CloseHandle(pipeTI->evControl);
    #ifndef _PTI_USE_CKALLOC
	free(pipeTI);
    #else
	ckfree(pipeTI);
    #endif
    }
}

void
PipeThreadExit(
    PipeThreadInfo **pipeTIPtr)
{

    if (!pipeTI) {
	return;
    }
    *pipeTIPtr = NULL;
    if ((state = InterlockedExchange(&pipeTI->state,
	    PTI_STATE_DOWN)) == PTI_STATE_STOP) {
	CloseHandle(pipeTI->evControl);
    #ifndef _PTI_USE_CKALLOC
	free(pipeTI);
    #else
	ckfree(pipeTI);
	/* be sure all subsystems used are finalized */
	Tcl_FinalizeThread();
    #endif
    }
}

typedef struct PipeInfo {
    struct PipeInfo *nextPtr;	/* Pointer to next registered pipe. */
    Tcl_Channel channel;	/* Pointer to channel structure. */
    int validMask;		/* OR'ed combination of TCL_READABLE,

    infoPtr->threadId = Tcl_GetCurrentThread();

    if (readFile != NULL) {
	/*
	 * Start the background reader thread.
	 */

	PipeThreadInfo *pipeTI = ckalloc(sizeof(PipeThreadInfo));
	pipeTI->evControl = CreateEvent(NULL, FALSE, FALSE, NULL);
	pipeTI->state = PTI_STATE_IDLE;
	pipeTI->clientData = infoPtr;
	infoPtr->readTI = pipeTI;
	infoPtr->readable = CreateEvent(NULL, TRUE, TRUE, NULL);
	infoPtr->readThread = CreateThread(NULL, 256, PipeReaderThread,
		pipeTI, 0, &id);
		PipeThreadCreateTI(&infoPtr->readTI, infoPtr), 0, &id);
	SetThreadPriority(infoPtr->readThread, THREAD_PRIORITY_HIGHEST);
	infoPtr->validMask |= TCL_READABLE;
    } else {
    	infoPtr->readTI = NULL;
	infoPtr->readThread = 0;
    }
    if (writeFile != NULL) {
	/*
	 * Start the background writer thread.
	 */

	PipeThreadInfo *pipeTI = ckalloc(sizeof(PipeThreadInfo));
	pipeTI->evControl = CreateEvent(NULL, FALSE, FALSE, NULL);
	pipeTI->state = PTI_STATE_IDLE;
	pipeTI->clientData = infoPtr;
	infoPtr->writeTI = pipeTI;
	infoPtr->writable = CreateEvent(NULL, TRUE, TRUE, NULL);
	infoPtr->writeThread = CreateThread(NULL, 256, PipeWriterThread,
		pipeTI, 0, &id);
		PipeThreadCreateTI(&infoPtr->writeTI, infoPtr), 0, &id);
	SetThreadPriority(infoPtr->writeThread, THREAD_PRIORITY_HIGHEST);
	infoPtr->validMask |= TCL_WRITABLE;
    } else {
    	infoPtr->writeTI = NULL;
    	infoPtr->writeThread = 0;
    }

	pipePtr->validMask &= ~TCL_READABLE;
	pipePtr->readFile = NULL;
    }
    if ((!flags || flags & TCL_CLOSE_WRITE)
	    && (pipePtr->writeFile != NULL)) {
	if (pipePtr->writeThread) {

	    /* Notify thread we will stop work and check it still seems to work */
	    if (!PipeThreadStopSignal(&pipePtr->writeTI)) {
		/*
		 * Wait for the  writer thread to finish the  current buffer, then
		 * terminate the thread  and close the handles. If  the channel is
		 * nonblocking or may block during exit, bail out since the worker
		 * thread is not interruptible and we want TIP#398-fast-exit.
		 */
		if ((pipePtr->flags & PIPE_ASYNC) || TclInExit()) {
	    /*
	     * Wait for the  writer thread to finish the  current buffer, then
	     * terminate the thread  and close the handles. If  the channel is
	     * nonblocking or may block during exit, bail out since the worker
	     * thread is not interruptible and we want TIP#398-fast-exit.
	     */
	    if ((pipePtr->flags & PIPE_ASYNC) && TclInExit()) {

		    /* give it a chance to leave honorably */
		    if (WaitForSingleObject(pipePtr->writable, 0) == WAIT_TIMEOUT) {
			return EWOULDBLOCK;
		    }
		/* give it a chance to leave honorably */
		PipeThreadStopSignal(&pipePtr->writeTI);

		if (WaitForSingleObject(pipePtr->writable, 20) == WAIT_TIMEOUT) {
		    return EWOULDBLOCK;
		}

		} else {
	    } else {

		    WaitForSingleObject(pipePtr->writable, INFINITE);
		WaitForSingleObject(pipePtr->writable, INFINITE);

		}
	    }
	    }

	    PipeThreadStop(&pipePtr->writeTI, pipePtr->writeThread);

	    CloseHandle(pipePtr->writable);
	    CloseHandle(pipePtr->writeThread);
	    pipePtr->writeThread = NULL;
	}
	if (TclpCloseFile(pipePtr->writeFile) != 0) {

static DWORD WINAPI
PipeWriterThread(
    LPVOID arg)
{
    PipeThreadInfo *pipeTI = (PipeThreadInfo *)arg;
    PipeInfo *infoPtr = NULL; /* access info only after success init/wait */
    HANDLE handle = NULL;
    HANDLE handle = NULL, writable = NULL;
    DWORD count, toWrite;
    char *buf;
    int done = 0;

    while (!done) {
	/*
	 * Wait for the main thread to signal before attempting to write.
	 */
	if (!PipeThreadWaitForSignal(&pipeTI)) {
	    /* exit */
	    if (writable) {
		SetEvent(writable);
	    }
	    break;
	}

	if (!infoPtr) {
	    infoPtr = (PipeInfo *)pipeTI->clientData;
	    handle = ((WinFile *) infoPtr->writeFile)->handle;
	    writable = infoPtr->writable;
	}

	buf = infoPtr->writeBuf;
	toWrite = infoPtr->toWrite;

	/*
	 * Loop until all of the bytes are written or an error occurs.

	}

	/*
	 * Signal the main thread by signalling the writable event and then
	 * waking up the notifier thread.
	 */

	SetEvent(infoPtr->writable);
	SetEvent(writable);

	/*
	 * Alert the foreground thread. Note that we need to treat this like a
	 * critical section so the foreground thread does not terminate this
	 * thread while we are holding a mutex in the notifier code.
	 */