return;
	    }

	    Tcl_Panic("Tcl_RegisterChannel: duplicate channel names");
	}
	Tcl_SetHashValue(hPtr, chanPtr);
    }

    /*
     * Increase ref-count of the state and channel (note the transfer-process to
     * other thread could temporary share the channel in two threads (especially 
     * if initiated from event-handler like TclChannelEventScriptInvoker,
     * see [815e246806]).
     */
    statePtr->refCount++;
    TclChannelPreserve(chan);
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UnregisterChannel --
 *

	 * shared between several interpreters, or if the channel has async
	 * flushing active.
	 */

	CleanupChannelHandlers(interp, chanPtr);
    }

    /* Opposite of TclChannelPreserve in Tcl_RegisterChannel */
    TclChannelRelease(chan);
    statePtr->refCount--;

    return TCL_OK;
}

/*
 *---------------------------------------------------------------------------

    return (Tcl_Channel) chanPtr;
}

void
TclChannelPreserve(
    Tcl_Channel chan)
{
    ((Channel *)chan)->refCount++;
    TclAtomicFetchInc(&((Channel *)chan)->refCount);
}

void
TclChannelRelease(
    Tcl_Channel chan)
{
    Channel *chanPtr = (Channel *) chan;

    if (chanPtr->refCount == 0) {
	Tcl_Panic("Channel released more than preserved");
    }
    if (--chanPtr->refCount) {
    if (TclAtomicFetchDec(&chanPtr->refCount)) {
	return;
    }
    if (chanPtr->typePtr == NULL) {
	ckfree(chanPtr);
    }
}

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    ChannelState *prevCSPtr;	/* Preceding channel state in list of all
				 * states - used to splice a channel out of
				 * the list on close. */
    ChannelState *statePtr = chanPtr->state;
				/* State of the channel stack. */

    /*
     * Firstly notify any - channel has no owner threads anymore.
     */

    statePtr->managingThread = NULL;

    /*
     * Remove this channel from of the list of all channels (in the current
     * thread).
     */

    if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
	tsdPtr->firstCSPtr = statePtr->nextCSPtr;

    for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
	statePtr->interestMask |= chPtr->mask;
    }

    UpdateInterest(statePtr->topChanPtr);
}

static void
SafeFreeScriptRecord(
    EventScriptRecord *esPtr)
{
    /* if not executed - remove it right now */
    if (esPtr->execDepth == 0) {
	TclDecrRefCount(esPtr->scriptPtr);
	ckfree(esPtr);
    } else if (esPtr->execDepth > 0) {
	/* inverse depth to notify event-handlers, they should remove it hereafter */
	esPtr->execDepth = -esPtr->execDepth;
    }
    /* execution in-between and already notified (negative). */
}
/*
 *----------------------------------------------------------------------
 *
 * DeleteScriptRecord --
 *
 *	Delete a script record for this combination of channel, interp and
 *	mask.

		CLANG_ASSERT(prevEsPtr);
		prevEsPtr->nextPtr = esPtr->nextPtr;
	    }

	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
		    TclChannelEventScriptInvoker, esPtr);

	    TclDecrRefCount(esPtr->scriptPtr);
	    ckfree(esPtr);
	    SafeFreeScriptRecord(esPtr);

	    break;
	}
    }
}

/*

    ChannelState *statePtr = chanPtr->state;
				/* State info for channel */
    EventScriptRecord *esPtr;
    int makeCH;

    for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) {
	if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
	    TclDecrRefCount(esPtr->scriptPtr);
	    SafeFreeScriptRecord(esPtr);
	    esPtr->scriptPtr = NULL;
	    break;
	}
    }

    makeCH = (esPtr == NULL);

    if (makeCH) {

     */

    esPtr->chanPtr = chanPtr;
    esPtr->interp = interp;
    esPtr->mask = mask;
    Tcl_IncrRefCount(scriptPtr);
    esPtr->scriptPtr = scriptPtr;
    esPtr->execDepth = 0;

    if (makeCH) {
	esPtr->nextPtr = statePtr->scriptRecordPtr;
	statePtr->scriptRecordPtr = esPtr;

	Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
		TclChannelEventScriptInvoker, esPtr);

				 * registered. */
    EventScriptRecord *esPtr;	/* The event script + interpreter to eval it
				 * in. */
    int result;			/* Result of call to eval script. */

    esPtr = clientData;
    chanPtr = esPtr->chanPtr;

    if ( esPtr->scriptPtr == NULL || esPtr->execDepth < 0 
      || Tcl_GetCurrentThread() != chanPtr->state->managingThread
    ) {
	return;
    }

    mask = esPtr->mask;
    interp = esPtr->interp;

    /*
     * We must preserve the interpreter so we can report errors on it later.
     * Note that we do not need to preserve the channel because that is done
     * by Tcl_NotifyChannel before calling channel handlers.
     */

    Tcl_Preserve(interp);
    TclChannelPreserve((Tcl_Channel)chanPtr);

    esPtr->execDepth++;
    result = Tcl_EvalObjEx(interp, esPtr->scriptPtr, TCL_EVAL_GLOBAL);

    if (esPtr->execDepth > 0) {
	--esPtr->execDepth;
    } else if (esPtr->execDepth < 0) {
	/* 
	 * Negative depth meants - the handler was removed, so we should increase,
	 * and remove esPtr record by the last handler (if it reached 0).
	 */
	if (++esPtr->execDepth == 0) {
	    SafeFreeScriptRecord(esPtr);
	    /* don't use esPtr at here. */
	}
    }

    /*
     * On error, cause a background error and remove the channel handler and
     * the script record.
     *
     * NOTE: Must delete channel handler before causing the background error
     * because the background error may want to reinstall the handler.

				 * delete the handler. */
    Tcl_Obj *scriptPtr;		/* Script to invoke. */
    Tcl_Interp *interp;		/* In what interpreter to invoke script? */
    int mask;			/* Events must overlap current mask for the
				 * stored script to be invoked. */
    struct EventScriptRecord *nextPtr;
				/* Next in chain of records. */
    int execDepth;		/* Execution depth inside the event-handlers,
				 * if negative it should be removed as 0 reached. */
} EventScriptRecord;

/*
 * struct Channel:
 *
 * One of these structures is allocated for each open channel. It contains
 * data specific to the channel but which belongs to the generic part of the

     * Intermediate buffers to hold pre-read data for consumption by a newly
     * stacked transformation. See 'Tcl_StackChannel'.
     */

    ChannelBuffer *inQueueHead;	/* Points at first buffer in input queue. */
    ChannelBuffer *inQueueTail;	/* Points at last buffer in input queue. */

    int refCount;
    TclAtomicInt refCount;	/* Reference counter, volatile forces atomic
				 * direct incr/decr during transfer process,
				 * if temorary shared between threads (avoids
				 * unexpected compiler optimization) */
} Channel;

/*
 * struct ChannelState:
 *
 * One of these structures is allocated for each open channel. It contains
 * data specific to the channel but which belongs to the generic part of the

#   endif
#endif

#if defined(_WIN32) && defined(_MSC_VER)
#   define vsnprintf _vsnprintf
#endif

/*
 * Interlocked (atomic fetch) primitives.
 *
 * Note gcc > 4.1 (also for mingw) has native support for builtin atomic operations.
 * ToDo: extend with support for atomic_ops, Darwin atomic, Sun atomics if available.
 */
#if !defined(__WIN32__) || defined(__GNUC__) || defined(__MINGW32__) /* UNIX or GCC */
#  define TclAtomicInt			long volatile

#  define TclAtomicFetchAdd(p, add) \
		__sync_fetch_and_add((p), (add))
#  define TclAtomicFetchSub(p, sub) \
		__sync_fetch_and_sub((p), (sub))
#  define TclAtomicFetchInc(p)	\
		(__sync_add_and_fetch((p), 1))
#  define TclAtomicFetchDec(p)	\
		(__sync_sub_and_fetch((p), 1))
#else  /* defined(__WIN32__) */
#  define TclAtomicInt			LONG volatile
#  define TclAtomicFetchAdd(p, add) \
		InterlockedExchangeAdd((LONG volatile *)(p), (add))
#  define TclAtomicFetchSub(p, sub) \
		InterlockedExchangeSubtract((LONG volatile *)(p), (sub))
#  define TclAtomicFetchInc(p)	\
		InterlockedIncrement((LONG volatile *)(p))
#  define TclAtomicFetchDec(p)	\
		InterlockedDecrement((LONG volatile *)(p))
#endif /* defined(__WIN32__) */
/*
 * The following procedures allow namespaces to be customized to support
 * special name resolution rules for commands/variables.
 */

struct Tcl_ResolvedVarInfo;