#ifndef _MCW_EM
#   define	_MCW_EM		0x0008001F	/* Error masks */
#   define	_MCW_RC		0x00000300	/* Rounding */
#   define	_MCW_PC		0x00030000	/* Precision */
_CRTIMP unsigned int __cdecl _controlfp (unsigned int unNew, unsigned int unMask);
#endif

/*
 * This is the number of milliseconds to wait between internal retries in
 * the Tcl_MutexLock function.  This value must be greater than or equal
 * to zero and should be a suitable value for the given platform.
 */

#ifndef TCL_MUTEX_LOCK_SLEEP_TIME
#  define TCL_MUTEX_LOCK_SLEEP_TIME	(0)
#endif

/*
 * This is the master lock used to serialize access to other serialization
 * data structures.
 */

static CRITICAL_SECTION masterLock;
static int init = 0;

    CRITICAL_SECTION crit;
} allocLock;
static Tcl_Mutex allocLockPtr = &allocLock;
static int allocOnce = 0;

#endif /* TCL_THREADS */

/*
 * The mutexLock serializes Tcl_MutexLock. This is necessary to prevent
 * races when finalizing a mutex that some other thread may want to lock.
 */

static CRITICAL_SECTION mutexLock;

/*
 * The joinLock serializes Create- and ExitThread. This is necessary to
 * prevent a race where a new joinable thread exits before the creating thread
 * had the time to create the necessary data structures in the emulation
 * layer.
 */

	 * There is a fundamental race here that is solved by creating the
	 * first Tcl interpreter in a single threaded environment. Once the
	 * interpreter has been created, it is safe to create more threads
	 * that create interpreters in parallel.
	 */

	init = 1;
	InitializeCriticalSection(&mutexLock);
	InitializeCriticalSection(&joinLock);
	InitializeCriticalSection(&initLock);
	InitializeCriticalSection(&masterLock);
    }
    EnterCriticalSection(&initLock);
}


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

void
TclFinalizeLock(void)
{
    MASTER_LOCK;
    DeleteCriticalSection(&mutexLock);
    DeleteCriticalSection(&joinLock);

    /*
     * Destroy the critical section that we are holding!
     */

    DeleteCriticalSection(&masterLock);

	    csPtr = ckalloc(sizeof(CRITICAL_SECTION));
	    InitializeCriticalSection(csPtr);
	    *mutexPtr = (Tcl_Mutex)csPtr;
	    TclRememberMutex(mutexPtr);
	}
	MASTER_UNLOCK;
    }
    while (1) {
	EnterCriticalSection(&mutexLock);
	csPtr = *((CRITICAL_SECTION **)mutexPtr);
	if (csPtr == NULL) {
	    LeaveCriticalSection(&mutexLock);
	    goto retry;
	}
	if (TryEnterCriticalSection(csPtr)) {
	    LeaveCriticalSection(&mutexLock);
	    return;
	}
	LeaveCriticalSection(&mutexLock);
	Tcl_Sleep(TCL_MUTEX_LOCK_SLEEP_TIME);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MutexUnlock --
 *