* type. Passed to conversion functions. */
    LengthProc *lengthProc;	/* Function to compute length of
				 * null-terminated strings in this encoding.
				 * If nullSize is 1, this is strlen; if
				 * nullSize is 2, this is a function that
				 * returns the number of bytes in a 0x0000
				 * terminated string. */
    TclAtomicInt refCount;	/* Number of uses of this structure. */
    Tcl_HashEntry *hPtr;	/* Hash table entry that owns this encoding. */
} Encoding;

/*
 * The following structure is the clientData for a dynamically-loaded,
 * table-driven encoding created by LoadTableEncoding(). It maps between
 * Unicode and a single-byte, double-byte, or multibyte (1 or 2 bytes only)

 * to each directory in this "libraryPath".
 */

static ProcessGlobalValue libraryPath = {
    0, 0, NULL, NULL, TclpInitLibraryPath, NULL, NULL
};

static TclAtomicInt encodingsInitialized = 0;

/*
 * Hash table that keeps track of all loaded Encodings. Keys are the string
 * names that represent the encoding, values are (Encoding *).
 */

static Tcl_HashTable encodingTable;
TCL_DECLARE_MUTEX(encodingMutex);

static volatile unsigned long encodingsEpoch = 0;

/*
 * The following are used to hold the default and current system encodings.
 * If NULL is passed to one of the conversion routines, the current setting of
 * the system encoding will be used to perform the conversion.
 */

#define defaultEncoding tclIdentityEncoding
static volatile Tcl_Encoding systemEncoding = NULL;
Tcl_Encoding tclIdentityEncoding = NULL;

/*
 * The following variable is used in the sparse matrix code for a
 * TableEncoding to represent a page in the table that has no entries.
 */

static unsigned short emptyPage[256];

			    int *dstCharsPtr);
static int		EscapeToUtfProc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
static void		FillEncodingFileMap(void);
static void		FreeEncoding(Encoding *encodingPtr, int lock);
static void		FreeEncodingIntRep(Tcl_Obj *objPtr);
static Encoding *	GetTableEncoding(EscapeEncodingData *dataPtr,
			    int state);
static Tcl_Encoding	LoadEncodingFile(Tcl_Interp *interp, const char *name);
static Tcl_Encoding	LoadTableEncoding(const char *name, int type,
			    Tcl_Channel chan);
static Tcl_Encoding	LoadEscapeEncoding(const char *name, Tcl_Channel chan);

			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
static int		Iso88591ToUtfProc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst,
			    int dstLen, int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);

static inline
Encoding *
GetSystemEncodingRef()
{
    Encoding *encodingPtr;
    /* 
     * refCount of systemEncoding gets decremented after it gets switched,
     * see Tcl_SetSystemEncoding,  so it is hardly possible to obtain an encoding
     * with refCount of 0 (which will be freed), so simply increase it here and 
     * check (the improbable case) is was 1.
     */
    do {
	encodingPtr = (Encoding *)systemEncoding;
	if (TclpAtomicIncrFetch(&encodingPtr->refCount) > 1) {
	    return encodingPtr;
	}
	/* refCount was 0 (now 1) - it going to free, so we incremented later
	 * than systemEncoding got switched, retry (systemEncoding already points
	 * to other value).
	 */
    } while (1);
}


/*
 * A Tcl_ObjType for holding a cached Tcl_Encoding in the ptrAndLongRep.ptr field
 * of the intrep. This should help the lifetime of encodings be more useful.
 * See concerns raised in [Bug 1077262].
 */

static Tcl_ObjType encodingType = {
    "encoding", FreeEncodingIntRep, DupEncodingIntRep, NULL, NULL
};

int
Tcl_GetEncodingFromObj(
    Tcl_Interp *interp,
    Tcl_Obj *objPtr,
    Tcl_Encoding *encodingPtr)
{
    const char *name = Tcl_GetString(objPtr);

    /* ensure encodings epoch is unchanged (see tests encoding-6.1, encoding-6.2) */
    if (objPtr->typePtr != &encodingType
	|| objPtr->internalRep.ptrAndLongRep.value != encodingsEpoch
    ) {
	Tcl_Encoding encoding = Tcl_GetEncoding(interp, name);

	if (encoding == NULL) {
	    return TCL_ERROR;
	}
	TclFreeIntRep(objPtr);
	objPtr->internalRep.ptrAndLongRep.ptr = (VOID *) encoding;
	objPtr->internalRep.ptrAndLongRep.value = encodingsEpoch;
	objPtr->typePtr = &encodingType;
    }
    *encodingPtr = objPtr->internalRep.ptrAndLongRep.ptr;
    /* despite the object hold the reference, related to docu, after every call 
     * "the caller should call Tcl_FreeEncoding on the resulting encoding token",
     * so we'd increase its reference count here also: */
    TclpAtomicIncrFetch(&((Encoding *)(*encodingPtr))->refCount);
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * FreeEncodingIntRep --
 *
 *	The Tcl_FreeInternalRepProc for the "encoding" Tcl_ObjType.
 *
 *----------------------------------------------------------------------
 */

static void
FreeEncodingIntRep(
    Tcl_Obj *objPtr)
{
    FreeEncoding((Encoding *)objPtr->internalRep.ptrAndLongRep.ptr, 1);
    objPtr->typePtr = NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * DupEncodingIntRep --
 *
 *	The Tcl_DupInternalRepProc for the "encoding" Tcl_ObjType.
 *
 *----------------------------------------------------------------------
 */

static void
DupEncodingIntRep(
    Tcl_Obj *srcPtr,
    Tcl_Obj *dupPtr)
{
    Encoding *encodingPtr = srcPtr->internalRep.ptrAndLongRep.ptr;

    TclpAtomicIncrFetch(&encodingPtr->refCount);
    dupPtr->internalRep.ptrAndLongRep.ptr = encodingPtr;
    dupPtr->internalRep.ptrAndLongRep.value = srcPtr->internalRep.ptrAndLongRep.value;
    
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEncodingSearchPath --
 *

 */

void
TclInitEncodingSubsystem(void)
{
    Tcl_EncodingType type;

    if (TclpAtomicIncrFetch(&encodingsInitialized) != 1) {
	return;
    }

    Tcl_MutexLock(&encodingMutex);
    Tcl_InitHashTable(&encodingTable, TCL_STRING_KEYS);
    Tcl_MutexUnlock(&encodingMutex);

    type.toUtfProc	= BinaryProc;
    type.fromUtfProc	= BinaryProc;
    type.freeProc	= NULL;
    type.nullSize	= 1;
    type.clientData	= NULL;

    defaultEncoding	= Tcl_CreateEncoding(&type);
    TclpAtomicIncrFetch(&((Encoding *)defaultEncoding)->refCount);
    systemEncoding	= defaultEncoding;

    type.encodingName	= "utf-8";
    type.toUtfProc	= UtfExtToUtfIntProc;
    type.fromUtfProc	= UtfIntToUtfExtProc;
    type.freeProc	= NULL;
    type.nullSize	= 1;
    type.clientData	= NULL;

	type.toUtfProc		= Iso88591ToUtfProc;
	type.fromUtfProc	= Iso88591FromUtfProc;
	type.freeProc		= TableFreeProc;
	type.nullSize		= 1;
	type.clientData		= dataPtr;
	Tcl_CreateEncoding(&type);
    }


}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeEncodingSubsystem --
 *

 */

void
TclFinalizeEncodingSubsystem(void)
{
    Tcl_HashSearch search;
    Tcl_HashEntry *hPtr;

    if (!encodingsInitialized) {
	return;
    }

    Tcl_MutexLock(&encodingMutex);
    encodingsInitialized = 0;
    FreeEncoding((Encoding *)systemEncoding, 0);
    systemEncoding = NULL;
    FreeEncoding((Encoding *)defaultEncoding, 0);
    defaultEncoding = NULL;

    hPtr = Tcl_FirstHashEntry(&encodingTable, &search);
    while (hPtr != NULL) {
	/*
	 * Call FreeEncoding instead of doing it directly to handle refcounts
	 * like escape encodings use. [Bug 524674] Make sure to call
	 * Tcl_FirstHashEntry repeatedly so that all encodings are eventually
	 * cleaned up.
	 */

	FreeEncoding((Encoding *)Tcl_GetHashValue(hPtr), 0);
	hPtr = Tcl_FirstHashEntry(&encodingTable, &search);
    }

    Tcl_DeleteHashTable(&encodingTable);
    Tcl_MutexUnlock(&encodingMutex);
}


Tcl_GetEncoding(
    Tcl_Interp *interp,		/* Interp for error reporting, if not NULL. */
    const char *name)		/* The name of the desired encoding. */
{
    Tcl_HashEntry *hPtr;
    Encoding *encodingPtr;


    if (name == NULL) {



	return (Tcl_Encoding)GetSystemEncodingRef();
    }

    Tcl_MutexLock(&encodingMutex);
    hPtr = Tcl_FindHashEntry(&encodingTable, name);
    if (hPtr != NULL) {
	encodingPtr = (Encoding *) Tcl_GetHashValue(hPtr);
	TclpAtomicIncrFetch(&encodingPtr->refCount);
	Tcl_MutexUnlock(&encodingMutex);
	return (Tcl_Encoding) encodingPtr;
    }
    Tcl_MutexUnlock(&encodingMutex);

    return LoadEncodingFile(interp, name);
}

 *---------------------------------------------------------------------------
 */

void
Tcl_FreeEncoding(
    Tcl_Encoding encoding)
{

    FreeEncoding((Encoding *)encoding, 1);

}

/*
 *----------------------------------------------------------------------
 *
 * FreeEncoding --
 *

 *	the encoding may be deleted if nothing is using it anymore.
 *
 *----------------------------------------------------------------------
 */

static void
FreeEncoding(


    Encoding *encodingPtr,
    int lock)
{

    if (encodingPtr == NULL) {
	return;
    }
    if (TclpAtomicDecrFetch(&encodingPtr->refCount) <= 0) {
	if (encodingPtr->refCount < 0) {
	    Tcl_Panic("FreeEncoding: refcount problem !!!");
	}


	if (encodingPtr->freeProc != NULL) {
	    (*encodingPtr->freeProc)(encodingPtr->clientData);
	}
	if (lock) {
	    Tcl_MutexLock(&encodingMutex);
	}
	if (encodingPtr->hPtr != NULL) {
	    Tcl_DeleteHashEntry(encodingPtr->hPtr);
	}
	if (lock) {
	    Tcl_MutexUnlock(&encodingMutex);
	}
	ckfree((char *) encodingPtr->name);
	ckfree((char *) encodingPtr);
    }
}

/*
 *-------------------------------------------------------------------------

 */

const char *
Tcl_GetEncodingName(
    Tcl_Encoding encoding)	/* The encoding whose name to fetch. */
{
    if (encoding == NULL) {
	/* TODO: this may be dangerous - see tcl ticket [f2ff05fc8411be80] */
	encoding = systemEncoding;
    }

    return ((Encoding *) encoding)->name;
}

/*

    const char *name)		/* The name of the desired encoding, or NULL/""
				 * to reset to default encoding. */
{
    Tcl_Encoding encoding;
    Encoding *encodingPtr;

    if (!name || !*name) {

	encoding = defaultEncoding;
	encodingPtr = (Encoding *) encoding;
	TclpAtomicIncrFetch(&encodingPtr->refCount);

    } else {
	encoding = Tcl_GetEncoding(interp, name);
	if (encoding == NULL) {
	    return TCL_ERROR;
	}
    }


    encodingPtr = (Encoding *)systemEncoding;
    systemEncoding = encoding;
    FreeEncoding(encodingPtr, 1);
    Tcl_FSMountsChanged(NULL);

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

	/*
	 * Remove old encoding from hash table, but don't delete it until last
	 * reference goes away.
	 */

	encodingPtr = (Encoding *) Tcl_GetHashValue(hPtr);
	encodingPtr->hPtr = NULL;

	/* increase epoch (to validate encoding stored in object repr.) */
	encodingsEpoch++;
    }

    name = ckalloc((unsigned) strlen(typePtr->encodingName) + 1);

    encodingPtr = (Encoding *) ckalloc(sizeof(Encoding));
    encodingPtr->name		= strcpy(name, typePtr->encodingName);
    encodingPtr->toUtfProc	= typePtr->toUtfProc;

    int srcLen,			/* Source string length in bytes, or < 0 for
				 * encoding-specific string length. */
    Tcl_DString *dstPtr)	/* Uninitialized or free DString in which the
				 * converted string is stored. */
{
    char *dst;
    Tcl_EncodingState state;
    Encoding *encodingPtr = (Encoding *) encoding;
    int flags, dstLen, result, soFar, srcRead, dstWrote, dstChars;

    Tcl_DStringInit(dstPtr);
    dst = Tcl_DStringValue(dstPtr);
    dstLen = dstPtr->spaceAvl - 1;

    if (encoding == NULL) {
	/* avoid [f2ff05fc8411be80], to be thread safe increase count here */
	encodingPtr = GetSystemEncodingRef();
    }


    if (src == NULL) {
	srcLen = 0;
    } else if (srcLen < 0) {
	srcLen = (*encodingPtr->lengthProc)(src);
    }

    flags = TCL_ENCODING_START | TCL_ENCODING_END;

    while (1) {
	result = (*encodingPtr->toUtfProc)(encodingPtr->clientData, src,
		srcLen, flags, &state, dst, dstLen, &srcRead, &dstWrote,
		&dstChars);
	soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);

	if (result != TCL_CONVERT_NOSPACE) {
	    Tcl_DStringSetLength(dstPtr, soFar);
	    break;
	}

	flags &= ~TCL_ENCODING_START;
	src += srcRead;
	srcLen -= srcRead;
	if (Tcl_DStringLength(dstPtr) == 0) {
	    Tcl_DStringSetLength(dstPtr, dstLen);
	}
	Tcl_DStringSetLength(dstPtr, 2 * Tcl_DStringLength(dstPtr) + 1);
	dst = Tcl_DStringValue(dstPtr) + soFar;
	dstLen = Tcl_DStringLength(dstPtr) - soFar - 1;
    }

    if (encoding == NULL) {
	/* decrease count of used system encoding */
	FreeEncoding(encodingPtr, 1);
    }

    return Tcl_DStringValue(dstPtr);
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_ExternalToUtf --
 *

    int *dstWrotePtr,		/* Filled with the number of bytes that were
				 * stored in the output buffer as a result of
				 * the conversion. */
    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    Encoding *encodingPtr = (Encoding *) encoding;
    int result, srcRead, dstWrote, dstChars;
    Tcl_EncodingState state;

    if (encoding == NULL) {
	/* avoid [f2ff05fc8411be80], to be thread safe increase count here */
	encodingPtr = GetSystemEncodingRef();
    }


    if (src == NULL) {
	srcLen = 0;
    } else if (srcLen < 0) {
	srcLen = (*encodingPtr->lengthProc)(src);
    }
    if (statePtr == NULL) {

    dstLen--;
    result = (*encodingPtr->toUtfProc)(encodingPtr->clientData, src, srcLen,
	    flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
	    dstCharsPtr);
    dst[*dstWrotePtr] = '\0';

    if (encoding == NULL) {
	/* decrease count of used system encoding */
	FreeEncoding(encodingPtr, 1);
    }
    return result;
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_UtfToExternalDString --

    int srcLen,			/* Source string length in bytes, or < 0 for
				 * strlen(). */
    Tcl_DString *dstPtr)	/* Uninitialized or free DString in which the
				 * converted string is stored. */
{
    char *dst;
    Tcl_EncodingState state;
    Encoding *encodingPtr = (Encoding *) encoding;
    int flags, dstLen, result, soFar, srcRead, dstWrote, dstChars;

    Tcl_DStringInit(dstPtr);
    dst = Tcl_DStringValue(dstPtr);
    dstLen = dstPtr->spaceAvl - 1;

    if (encoding == NULL) {
	/* avoid [f2ff05fc8411be80], to be thread safe increase count here */
	encodingPtr = GetSystemEncodingRef();
    }


    if (src == NULL) {
	srcLen = 0;
    } else if (srcLen < 0) {
	srcLen = strlen(src);
    }
    flags = TCL_ENCODING_START | TCL_ENCODING_END;
    while (1) {
	result = (*encodingPtr->fromUtfProc)(encodingPtr->clientData, src,
		srcLen, flags, &state, dst, dstLen, &srcRead, &dstWrote,
		&dstChars);
	soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);

	if (result != TCL_CONVERT_NOSPACE) {
	    if (encodingPtr->nullSize == 2) {
		Tcl_DStringSetLength(dstPtr, soFar + 1);
	    }
	    Tcl_DStringSetLength(dstPtr, soFar);
	    break;
	}

	flags &= ~TCL_ENCODING_START;
	src += srcRead;
	srcLen -= srcRead;
	if (Tcl_DStringLength(dstPtr) == 0) {
	    Tcl_DStringSetLength(dstPtr, dstLen);
	}
	Tcl_DStringSetLength(dstPtr, 2 * Tcl_DStringLength(dstPtr) + 1);
	dst = Tcl_DStringValue(dstPtr) + soFar;
	dstLen = Tcl_DStringLength(dstPtr) - soFar - 1;
    }

    if (encoding == NULL) {
	/* decrease count of used system encoding */
	FreeEncoding(encodingPtr, 1);
    }
    return Tcl_DStringValue(dstPtr);
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_UtfToExternal --
 *

    int *dstWrotePtr,		/* Filled with the number of bytes that were
				 * stored in the output buffer as a result of
				 * the conversion. */
    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    Encoding *encodingPtr = (Encoding *) encoding;
    int result, srcRead, dstWrote, dstChars;
    Tcl_EncodingState state;

    if (encoding == NULL) {
	/* avoid [f2ff05fc8411be80], to be thread safe increase count here */
	encodingPtr = GetSystemEncodingRef();
    }


    if (src == NULL) {
	srcLen = 0;
    } else if (srcLen < 0) {
	srcLen = strlen(src);
    }
    if (statePtr == NULL) {

	    flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
	    dstCharsPtr);
    if (encodingPtr->nullSize == 2) {
	dst[*dstWrotePtr + 1] = '\0';
    }
    dst[*dstWrotePtr] = '\0';

    if (encoding == NULL) {
	/* decrease count of used system encoding */
	FreeEncoding(encodingPtr, 1);
    }
    return result;
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FindExecutable --

     *  The encodingsInitialized flag, being reset on entry to TFES, can serve
     *  as a "not in finalization" test.
     */
    if (encodingsInitialized)
	{
	    subTablePtr = dataPtr->subTables;
	    for (i = 0; i < dataPtr->numSubTables; i++) {
		FreeEncoding(subTablePtr->encodingPtr, 1);
		subTablePtr++;
	    }
	}
    ckfree((char *) dataPtr);
}

/*

	Tcl_DecrRefCount(path);
    }

    Tcl_DecrRefCount(libPath);
    Tcl_DecrRefCount(encodingObj);
    *encodingPtr = libraryPath.encoding;
    if (*encodingPtr) {
	TclpAtomicIncrFetch(&((Encoding *)(*encodingPtr))->refCount);
    }
    bytes = Tcl_GetStringFromObj(searchPath, &numBytes);

    *lengthPtr = numBytes;
    *valuePtr = ckalloc((unsigned int) numBytes + 1);
    memcpy(*valuePtr, bytes, (size_t) numBytes + 1);
    Tcl_DecrRefCount(searchPath);

#	define PTR2UINT(p) ((unsigned int)(uintptr_t)(p))
#   else
#	define UINT2PTR(p) ((void *)(p))
#	define PTR2UINT(p) ((unsigned int)(p))
#   endif
#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.
 *
 * TclAtomicFetchAdd -- 
 *	Performs an atomic addition and returns INITIAL value (before change);
 * TclAtomicFetchSub --
 *	Performs an atomic subtraction and returns INITIAL value (before change);
 * TclpAtomicIncrFetch -- 
 *	Increments (by one) the value as an atomic operation and returns new value (after change);
 * TclpAtomicDecrFetch --
 *	Decrements (by one) the value as an atomic operation and returns new value (after change);
 */
#if !defined(__WIN32__) || defined(__GNUC__) || defined(__MINGW32__) /* UNIX or GCC */
#  define TclAtomicInt			long volatile
#  define TclAtomicArg			long
#  define TclpAtomicFetchAdd(p, add) \
		__sync_fetch_and_add((p), (add))
#  define TclpAtomicFetchSub(p, sub) \
		__sync_fetch_and_sub((p), (sub))
#  define TclpAtomicIncrFetch(p)	\
		(__sync_add_and_fetch((p), 1))
#  define TclpAtomicDecrFetch(p)	\
		(__sync_sub_and_fetch((p), 1))
#else  /* defined(__WIN32__) */
#  define TclAtomicInt			LONG volatile
#  define TclAtomicArg			LONG
#  define TclpAtomicFetchAdd(p, add) \
		InterlockedExchangeAdd((p), (add))
#  define TclpAtomicFetchSub(p, sub) \
		InterlockedExchangeSubtract((p), (sub))
#  define TclpAtomicIncrFetch(p)	\
		InterlockedIncrement((p))
#  define TclpAtomicDecrFetch(p)	\
		InterlockedDecrement((p))
#endif /* defined(__WIN32__) */

#ifdef TCL_THREADS
/* use atomic primitives */
#  define TclAtomicFetchAdd(p, add) \
		TclpAtomicFetchAdd((p), (add))
#  define TclAtomicFetchSub(p, sub) \
		TclpAtomicFetchSub((p), (sub))
#  define TclAtomicIncrFetch(p)	\
		TclpAtomicIncrFetch((p))
#  define TclAtomicDecrFetch(p)	\
		TclpAtomicDecrFetch((p))
#else
/* don't use atomic primitives (unsupported or unneeded) */
static inline TclAtomicInt
	  TclAtomicFetchAdd(TclAtomicInt *p, TclAtomicArg add) {
		TclAtomicInt prev = *p; *p += add; return prev;
	  }
static inline TclAtomicInt
	  TclAtomicFetchSub(TclAtomicInt *p, TclAtomicArg sub) {
		TclAtomicInt prev = *p; *p -= sub; return prev;
	  }
#  define TclAtomicIncrFetch(p)	\
		(++*(p))
#  define TclAtomicDecrFetch(p)	\
		(--*(p))
#endif

/*
 * The following procedures allow namespaces to be customized to support
 * special name resolution rules for commands/variables.
 */

struct Tcl_ResolvedVarInfo;