void FLMAPI f_mutexLock(
	F_MUTEX			hMutex)
{
	F_INTERLOCK *		pInterlock = (F_INTERLOCK *)hMutex;

#ifdef FLM_DEBUG
	if( pInterlock->locked)
	{
		f_assert( pInterlock->uiThreadId != _threadid);
	}
#endif

	while( f_atomicExchange( &pInterlock->locked, 1) != 0)
	{
#ifdef FLM_DEBUG
		f_atomicInc( &pInterlock->waitCount);
#endif
		Sleep( 0);
	}

#ifdef FLM_DEBUG
	f_assert( pInterlock->uiThreadId == 0);
	pInterlock->uiThreadId = _threadid;
	f_atomicInc( &pInterlock->lockedCount);
#endif
}
void FLMAPI f_semSignal(
	F_SEM			hSem)
{
	f_atomicInc( &((sema_t *)hSem)->uiSignalCount);
	(void)ReleaseSemaphore( ((sema_t *)hSem)->hWinSem, 1, NULL);
}
extern "C" LONG f_nlmEntryPoint(
	struct LoadDefinitionStructure *		moduleHandle,
	struct ScreenStruct *					initScreen,
	char *										commandLine,
	char *										loadDirectoryPath,
	LONG											uninitializedDataLength,
	LONG											fileHandle,
	LONG											(*ReadRoutine)
														(LONG		handle,
														 LONG		offset,
														 char *	buffer,
														 LONG		length),
	LONG											customDataOffset,
	LONG											customDataSize)
{
	char *		pszTmp;
	char *		pszArgStart;
	int			iArgC;
	int			iTotalArgChars;
	int			iArgSize;
	char **		ppszArgV = NULL;
	char *		pszArgs = NULL;
	char *		pszDestArg;
	bool			bFirstPass = true;
	char			cEnd;
	ARG_DATA *	pArgData = NULL;
	LONG			sdRet = 0;
	char *		pszThreadName;
	char *		pszModuleName;
	int			iModuleNameLen;
	int			iThreadNameLen;
	int			iLoadDirPathSize;
	void *		hThread = NULL;
	
	(void)initScreen;
	(void)uninitializedDataLength;
	(void)fileHandle;
	(void)ReadRoutine;
	(void)customDataOffset;
	(void)customDataSize;

	if( f_atomicInc( &gv_NetWareStartupCount) != 1)
	{
		goto Exit;
	}
	
	gv_MyModuleHandle = moduleHandle;
	gv_bUnloadCalled = FALSE;

	// Allocate the needed resource tags
	
	if( (gv_lAllocRTag = AllocateResourceTag( gv_MyModuleHandle,
		"FLAIM Memory", AllocSignature)) == NULL)
	{
		sdRet = 1;
		goto Exit;
	}

	// Syncronized start

	if (moduleHandle->LDFlags & 4)
	{
		gv_lFlmSyncSem = kSemaphoreAlloc( (BYTE *)"FLAIM_SYNC", 0);
	}

	// Initialize NSS
	
	if( RC_BAD( f_nssInitialize()))
	{
		sdRet = 1;
		goto Exit;
	}
	
	pszModuleName = (char *)(&moduleHandle->LDFileName[ 1]);
	iModuleNameLen = (int)(moduleHandle->LDFileName[ 0]);
	
	// First pass: Count the arguments in the command line
	// and determine how big of a buffer we will need.
	// Second pass: Put argments into allocated buffer.

Parse_Args:

	iTotalArgChars = 0;
	iArgC = 0;
	
	iLoadDirPathSize = f_strlen( (const char *)loadDirectoryPath); 
	iArgSize =  iLoadDirPathSize + iModuleNameLen;
	
	if( !bFirstPass)
	{
		ppszArgV[ iArgC] = pszDestArg;
		f_memcpy( pszDestArg, loadDirectoryPath, iLoadDirPathSize);
		f_memcpy( &pszDestArg[ iLoadDirPathSize], pszModuleName, iModuleNameLen);
		pszDestArg[ iArgSize] = 0;
		pszDestArg += (iArgSize + 1);
	}

	iArgC++;
	iTotalArgChars += iArgSize;
	pszTmp = commandLine;

	for (;;)
	{
		// Skip leading blanks.

		while( *pszTmp && *pszTmp == ' ')
		{
			pszTmp++;
		}

		if( *pszTmp == 0)
		{
			break;
		}

		if( *pszTmp == '"' || *pszTmp == '\'')
		{
			cEnd = *pszTmp;
			pszTmp++;
		}
		else
		{
			cEnd = ' ';
		}
		
		pszArgStart = pszTmp;
		iArgSize = 0;

		// Count the characters in the parameter.

		while( *pszTmp && *pszTmp != cEnd)
		{
			iArgSize++;
			pszTmp++;
		}

		if( !iArgSize && cEnd == ' ')
		{
			break;
		}

		// If 2nd pass, save the argument.

		if( !bFirstPass)
		{
			ppszArgV[ iArgC] = pszDestArg;
			
			if( iArgSize)
			{
				f_memcpy( pszDestArg, pszArgStart, iArgSize);
			}
			
			pszDestArg[ iArgSize] = 0;
			pszDestArg += (iArgSize + 1);
		}

		iArgC++;
		iTotalArgChars += iArgSize;

		// Skip trailing quote or blank.

		if( *pszTmp)
		{
			pszTmp++;
		}
	}

	if( bFirstPass)
	{
		if ((ppszArgV = (char **)Alloc(  sizeof( char *) * iArgC, 
			gv_lAllocRTag)) == NULL)
		{
			sdRet = 1;
			goto Exit;
		}

		if( (pszArgs = (char *)Alloc( iTotalArgChars + iArgC, 
			gv_lAllocRTag)) == NULL)
		{
			sdRet = 1;
			goto Exit;
		}
		
		pszDestArg = pszArgs;
		bFirstPass = false;
		goto Parse_Args;
	}

	iThreadNameLen = (int)(moduleHandle->LDName[ 0]);

	if( (pszThreadName = (char *)Alloc( iThreadNameLen + 1, gv_lAllocRTag)) == NULL)
	{
		sdRet = 1;
		goto Exit;
	}
	
	f_memcpy( pszThreadName, (char *)(&moduleHandle->LDName[ 1]), iThreadNameLen);
	pszThreadName[ iThreadNameLen] = 0;

	if( (pArgData = (ARG_DATA *)Alloc( sizeof( ARG_DATA), 
		gv_lAllocRTag)) == NULL)
	{
		sdRet = 1;
		goto Exit;
	}
	
	pArgData->ppszArgV = ppszArgV;
	pArgData->pszArgs = pszArgs;
	pArgData->iArgC = iArgC;
	pArgData->moduleHandle = moduleHandle;
	pArgData->pszThreadName = pszThreadName;

	gv_bMainRunning = TRUE;

	if( (hThread = kCreateThread( (BYTE *)"FTK main",
			f_nlmMainStub, NULL, 32768, (void *)pArgData)) == NULL)
	{
		gv_bMainRunning = FALSE;
		sdRet = 2;
		goto Exit;
	}

	if( kSetThreadLoadHandle( hThread, (LONG)moduleHandle) != 0)
	{
		(void)kDestroyThread( hThread);
		gv_bMainRunning = FALSE;
		sdRet = 2;
		goto Exit;
	}
			
	if( kScheduleThread( hThread) != 0)
	{
		(void)kDestroyThread( hThread);
		gv_bMainRunning = FALSE;
		sdRet = 2;
		goto Exit;
	}
	
	// Synchronized start

	if( moduleHandle->LDFlags & 4)
	{
		(void)kSemaphoreWait( gv_lFlmSyncSem);
	}

Exit:

	if( sdRet != 0)
	{
		f_atomicDec( &gv_NetWareStartupCount);
		
		if( ppszArgV)
		{
			Free( ppszArgV);
		}

		if( pszArgs)
		{
			Free( pszArgs);
		}

		if( pszThreadName)
		{
			Free( pszThreadName);
		}

		if( pArgData)
		{
			Free( pArgData);
		}

		if( gv_lFlmSyncSem)
		{
			kSemaphoreFree( gv_lFlmSyncSem);
			gv_lFlmSyncSem = 0;
		}
		
		if( !gv_bUnloadCalled)
		{
			KillMe( moduleHandle);
		}
	}

	return( sdRet);
}
/******************************************************************************
Desc:
******************************************************************************/
void LockModule(void)
{
	f_atomicInc( &gv_lockCount);
}
	FLMINT FTKAPI AddRef( void)
	{
		return( f_atomicInc( &m_refCnt));
	}