MODULE_SCOPE void	TclpDeleteFileHandler(int fd);
MODULE_SCOPE void	TclpFinalizeCondition(Tcl_Condition *condPtr);
MODULE_SCOPE void	TclpFinalizeMutex(Tcl_Mutex *mutexPtr);
MODULE_SCOPE void	TclpFinalizeNotifier(void *clientData);
MODULE_SCOPE void	TclpFinalizePipes(void);
MODULE_SCOPE void	TclpFinalizeSockets(void);
#ifdef _WIN32
MODULE_SCOPE void	TclpFinalizeLoad(void);
MODULE_SCOPE void	TclInitSockets(void);
#else
#define TclpFinalizeLoad() /* do nothing */
#define TclInitSockets() /* do nothing */
#endif
struct addrinfo; /* forward declaration, needed for TclCreateSocketAddress */
MODULE_SCOPE int	TclCreateSocketAddress(Tcl_Interp *interp,
			    struct addrinfo **addrlist,
			    const char *host, int port, int willBind,
			    const char **errorMsgPtr);

	}
#endif

	Tcl_Free(libraryPtr->fileName);
	Tcl_Free(libraryPtr->prefix);
	Tcl_Free(libraryPtr);
    }
    TclpFinalizeLoad();
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78

	zip.$(HOST_OBJEXT) \
	zutil.$(HOST_OBJEXT) \
	minizip.$(HOST_OBJEXT)

ZIP_INSTALL_OBJS =  @ZIP_INSTALL_OBJS@

CC_SWITCHES = -I"${BUILD_DIR}" -I"${GENERIC_DIR_NATIVE}" -I"${TOMMATH_DIR_NATIVE}" \
-I"${ZLIB_DIR_NATIVE}" -I"${WIN_DIR_NATIVE}" \
${CFLAGS} ${CFLAGS_WARNING} ${SHLIB_CFLAGS} -DMP_PREC=4 \
${AC_FLAGS} ${COMPILE_DEBUG_FLAGS} ${NO_DEPRECATED_FLAGS}

CC_OBJNAME = @CC_OBJNAME@
CC_EXENAME = @CC_EXENAME@

STUB_CC_SWITCHES = -I"${GENERIC_DIR_NATIVE}" -I"${TOMMATH_DIR_NATIVE}" \

LIBTCLVFSSUBDIR = libtcl.vfs
LIBTCLVFS = $(OUT_DIR)\$(LIBTCLVFSSUBDIR)

# Additional include and C macro definitions for the implicit rules
# defined in rules.vc
PRJ_INCLUDES	= -I"$(TOMMATHDIR)"
PRJ_DEFINES	= /DMP_PREC=4 /Dinline=__inline /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /DMP_FIXED_CUTOFFS

!if $(STATIC_BUILD)
PRJ_DEFINES = $(PRJ_DEFINES) /DTCL_WITH_INTERNAL_ZLIB
!endif

# Additional Link libraries needed beyond those in rules.vc
PRJ_LIBS   = netapi32.lib user32.lib userenv.lib ws2_32.lib

 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

#include "tclWinInt.h"
#ifdef TCL_LOAD_FROM_MEMORY
#undef  UNICODE
#undef  _UNICODE
#define UNICODE
#define _UNICODE
#include "MemoryModule.h"
#endif

/*
 * Native name of the directory in the native filesystem where DLLs used in
 * this process are copied prior to loading, and mutex used to protect its
 * allocation.
 */

static WCHAR *dllDirectoryName = NULL;
#if TCL_THREADS
static Tcl_Mutex dllDirectoryNameMutex;
#endif
static Tcl_HashTable tempDllTable;

/*
 * Static functions defined within this file.
 */

static void *		FindSymbol(Tcl_Interp *interp,
			    Tcl_LoadHandle loadHandle, const char *symbol);

    handlePtr = (Tcl_LoadHandle)Tcl_Alloc(sizeof(struct Tcl_LoadHandle_));
    handlePtr->clientData = hInstance;
    handlePtr->findSymbolProcPtr = &FindSymbol;
    handlePtr->unloadFileProcPtr = &UnloadFile;
    *loadHandle = handlePtr;
    *unloadProcPtr = &UnloadFile;

    /*
     * Remember handle for process termination cleanup handler
     * if the DLL is a copy in temporary directory.
     */

    Tcl_MutexLock(&dllDirectoryNameMutex);
    if (dllDirectoryName != NULL) {
	int dummy, len = wcslen(dllDirectoryName);

	if ((len > 0) && (_wcsnicmp(nativeName, dllDirectoryName, len) == 0)) {
	    Tcl_CreateHashEntry(&tempDllTable, (ClientData) handlePtr, &dummy);
	}
    }
    Tcl_MutexUnlock(&dllDirectoryNameMutex);

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

static void
UnloadFile(
    Tcl_LoadHandle loadHandle)	/* loadHandle returned by a previous call to
				 * TclpDlopen(). The loadHandle is a token
				 * that represents the loaded file. */
{
    HINSTANCE hInstance = (HINSTANCE)loadHandle->clientData;
    BOOL success, keep = 0;

    success = FreeLibrary(hInstance);
    Tcl_MutexLock(&dllDirectoryNameMutex);
    if (dllDirectoryName != NULL) {
	Tcl_HashEntry *hPtr =
	    Tcl_FindHashEntry(&tempDllTable, (ClientData) loadHandle);

	if (hPtr != NULL) {
	    if (success) {
		Tcl_DeleteHashEntry(hPtr);
	    } else {
		/* FreeLibrary() will be retried in TclpFinalizeLoad() later */
		keep = 1;
	    }
	}
    }
    Tcl_MutexUnlock(&dllDirectoryNameMutex);
    if (!keep) {
	Tcl_Free(loadHandle);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TclpTempFileNameForLibrary --
 *

	Tcl_DecrRefCount(fileName);
	return NULL;
    }
    Tcl_AppendToObj(fileName, "/", 1);
    Tcl_AppendObjToObj(fileName, tail);
    return fileName;
}

/*
 *----------------------------------------------------------------------
 *
 * TclpFinalizeLoad --
 *
 *	On process termination, cleanup and finally remove the
 *	directory used for temporary copies of DLLs.
 *
 * Results:
 *	None.
 *
 * Side-effects:
 *	Delete files in temp directory.
 *	Remove temp directory.
 *
 *----------------------------------------------------------------------
 */

void
TclpFinalizeLoad(void)
{
    WCHAR *dllDir = NULL;
    int dllDirLen;
    Tcl_DString ds;
    Tcl_HashEntry *hPtr;
    Tcl_HashSearch search;
    HANDLE handle;
    WIN32_FIND_DATAW data;

    if (!TclFullFinalizationRequested()) {
	Tcl_MutexLock(&dllDirectoryNameMutex);
    }
    if (dllDirectoryName != NULL) {
	dllDir = dllDirectoryName;
	dllDirectoryName = NULL;
    }
    if (dllDir != NULL) {

	/*
	 * Try unloading left-over DLLs.
	 */

	hPtr = Tcl_FirstHashEntry(&tempDllTable, &search);
	while (hPtr != NULL) {
	    Tcl_LoadHandle loadHandle =
		(Tcl_LoadHandle) Tcl_GetHashKey(&tempDllTable, hPtr);

	    Tcl_DeleteHashEntry(hPtr);
	    hPtr = Tcl_NextHashEntry(&search);

	    /*
	     * Same cleanup steps as in UnloadFile(), but dangerous anyway.
	     */

	    FreeLibrary((HINSTANCE) loadHandle->clientData);
	    Tcl_Free(loadHandle);
	}
	Tcl_DeleteHashTable(&tempDllTable);

	/*
	 * Delete temporary copies of DLLs, then the temporary directory.
	 */

	Tcl_DStringInit(&ds);
	dllDirLen = wcslen(dllDir) * sizeof (WCHAR);
	Tcl_DStringAppend(&ds, (char *) dllDir, dllDirLen);
	Tcl_DStringAppend(&ds, (char *) L"\\*.dll\0",
		wcslen(L"\\*.dll\0") * sizeof (WCHAR));
	dllDirLen += sizeof (WCHAR);	/* include trailing backslash */
	handle = FindFirstFileW((WCHAR *) Tcl_DStringValue(&ds), &data);
	if (handle != INVALID_HANDLE_VALUE) {
	    do {
		Tcl_DStringSetLength(&ds, dllDirLen);
		Tcl_DStringAppend(&ds, (char *) data.cFileName,
			wcslen(data.cFileName) * sizeof (WCHAR));
		Tcl_DStringAppend(&ds, (char *) L"\0", sizeof (WCHAR));
		DeleteFileW((WCHAR *) Tcl_DStringValue(&ds));
	    } while (FindNextFileW(handle, &data) == TRUE);
	    FindClose(handle);
	}
	Tcl_DStringFree(&ds);
	RemoveDirectoryW(dllDir);
	Tcl_Free(dllDir);
    }
    if (!TclFullFinalizationRequested()) {
	Tcl_MutexUnlock(&dllDirectoryNameMutex);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * InitDLLDirectoryName --
 *
 *	Helper for TclpTempFileNameForLibrary; builds a temporary directory

    /*
     * Store our computed value in the global.
     */

  copyToGlobalBuffer:
    dllDirectoryName = (WCHAR *)Tcl_Alloc((nameLen+1) * sizeof(WCHAR));
    wcscpy(dllDirectoryName, name);
    Tcl_InitHashTable(&tempDllTable, TCL_ONE_WORD_KEYS);
    return TCL_OK;
}

#ifdef TCL_LOAD_FROM_MEMORY

MODULE_SCOPE void *
TclpLoadMemoryGetBuffer(