// STRUTIL.CPP
//
// Assorted string utility functions for use in NetMeeting components.
// Derived from STRCORE.CPP.

#include "precomp.h"
#include <cstring.hpp>

// global helper functions for Unicode support in a DBCS environment

int  UnicodeCompare(PCWSTR s, PCWSTR t)
{ 
	// Treat NULL pointers like empty strings
	// at the bottom of the collating order.

	if (IsEmptyStringW(t)) {
		if (IsEmptyStringW(s)) {
			return 0;
		}
		else {
			return 1;
		}
	}

	// Done with empty string cases, 
	// so now do real compare.

	for ( ; *s == *t; s++, t++) {
		if (!*s) {
			return 0;
		}
	}
	return (*s > *t) ? 1 : -1;
}

PWSTR  NewUnicodeString(PCWSTR _wszText)
{
	PWSTR wszText = NULL;
	UINT nChar;

	if (_wszText) {
		nChar = lstrlenW(_wszText) + 1;
		wszText = new WCHAR[nChar];
		if (wszText) {
			CopyMemory((void *)wszText, 
						_wszText, 
						nChar * sizeof(WCHAR));
		}
	}
	return wszText;
}

PWSTR  DBCSToUnicode(UINT uCodePage, PCSTR szText)
{
	int		nChar;
	PWSTR	wszText = NULL;

	if (szText) {
		nChar = MultiByteToWideChar(uCodePage,
									0,		// character-type options
									szText,
									-1,		// NULL terminated string
									NULL,	// return buffer (not used)
									0);		// getting length of Unicode string
		if (nChar) {
			wszText = new WCHAR[nChar];
			if (wszText) {
				nChar = MultiByteToWideChar(uCodePage,
											0,			// character-type options
											szText,
											-1,			// NULL terminated string
											wszText,	// return buffer
											nChar);		// length of return buffer
				if (!nChar) {
					delete wszText;
					wszText = NULL;
				}
			}
		}
	}
	return wszText;
}

PSTR  UnicodeToDBCS(UINT uCodePage, PCWSTR wszText)
{
	int		nChar;
	PSTR	szText = NULL;

	if (wszText) {
		nChar = WideCharToMultiByte(uCodePage,
									0,		// character-type options
									wszText,
									-1,		// NULL terminated string
									NULL,	// return buffer (not used)
									0,		// getting length of DBCS string
									NULL,
									NULL);
		if (nChar) {
			szText = new CHAR[nChar];
			if (szText) {
				nChar = WideCharToMultiByte(uCodePage,
											0,			// character-type options
											wszText,
											-1,			// NULL terminated string
											szText,		// return buffer
											nChar,		// length of return buffer
											NULL,
											NULL);
				if (!nChar) {
					delete szText;
					szText = NULL;
				}
			}
		}
	}
	return szText;
}


BOOL  UnicodeIsNumber(PCWSTR wszText)
{
	// If there are no characters, then treat it as not being a number.

	if (!wszText || !*wszText) {
		return FALSE;
	}

	// If any characters are not digits, then return FALSE.

	do {
		if ((*wszText < L'0') || (*wszText > L'9')) {
			return FALSE;
		}
	} while(*++wszText);

	// Got here so all characters are digits.

	return TRUE;
}


/*  G U I D  T O  S Z */
/*----------------------------------------------------------------------------
    %%Function: GuidToSz

	Convert the guid to a special hex string.
	Assumes lpchDest has space for at least sizeof(GUID)*2 +6 chars.
	LENGTH_SZGUID_FORMATTED is 30 and includes space for the null terminator.

	Note the difference between this and UuidToString (or StringFromGUID2)

	GUID Format: {12345678-1234-1234-1234567890123456}
----------------------------------------------------------------------------*/
VOID  GuidToSz(GUID * pguid, LPTSTR lpchDest)
{
	ASSERT(NULL != pguid);
	ASSERT(NULL != lpchDest);

	wsprintf(lpchDest, TEXT("{%08X-%04X-%04X-%02X%02X-"),
		pguid->Data1, pguid->Data2, pguid->Data3, pguid->Data4[0], pguid->Data4[1]);
	lpchDest += 1+8+1+4+1+4+1+2+2+1;

	for (int i = 2; i < 8; i++)
	{
		wsprintf(lpchDest, TEXT("%02X"), pguid->Data4[i]);
		lpchDest += 2;
	}
	lstrcpy(lpchDest, TEXT("}") );
}


/*  S Z  F I N D  L A S T  C H */
/*----------------------------------------------------------------------------
    %%Function: SzFindLastCh

	Returns a pointer to the ch within the lpsz or NULL if not found
----------------------------------------------------------------------------*/
LPTSTR  SzFindLastCh(LPTSTR lpsz, TCHAR ch)
{
	LPTSTR lpchRet;

	for (lpchRet = NULL; *lpsz; lpsz = CharNext(lpsz))
	{
		if (ch == *lpsz)
			lpchRet = lpsz;
	}

	return lpchRet;
}



/*  T R I M  S Z  */
/*-------------------------------------------------------------------------
    %%Function: TrimSz

    Trim the whitespace around string.
    Returns the number of characters in the string.
    (chars/bytes in ANSI and DBCS, WCHARs/words in UNICODE)
-------------------------------------------------------------------------*/
UINT  TrimSz(PTCHAR psz)
{
    UINT   ich;        // character index into rgwCharType
    PTCHAR pchFirst;
    PTCHAR pchLast;
    PTCHAR pchCurr;
    WORD   rgwCharType[MAX_PATH];

	if ((NULL == psz) || (0 == lstrlen(psz)))
	{
		return 0;
	}

	if (!GetStringTypeEx(LOCALE_SYSTEM_DEFAULT, CT_CTYPE1, psz, -1, rgwCharType))
	{
		WARNING_OUT(("TrimSz: Problem with GetStringTypeEx"));
		return 0;
	}

	// search for first non-space
	pchFirst = psz;
	ich = 0;
	while (_T('\0') != *pchFirst)
	{
		if (!(C1_SPACE & rgwCharType[ich]))
			break;
		pchFirst = CharNext(pchFirst);
		ich++;
	}

	if (_T('\0') == *pchFirst)
	{
		// The entire string is empty!
		*psz = _T('\0');
		return 0;
	}
	
	// search for last non-space
	pchCurr = pchFirst;
	pchLast = pchCurr;
	while (_T('\0') != *pchCurr)
	{
		if (!(C1_SPACE & rgwCharType[ich]))
		{
			pchLast = pchCurr;
		}
		pchCurr = CharNext(pchCurr);
		ich++;
	}

	ASSERT(_T('\0') != *pchLast);
	// Null terminate the string
	pchLast = CharNext(pchLast);
	*pchLast = _T('\0');

	// Update the original string
	lstrcpy(psz, pchFirst);

	// Return the new length
	return lstrlen(psz);
}


// Implement lstrcpyW when not on a Unicode platform

#if !defined(UNICODE)
/*  L  S T R  C P Y  W  */
/*-------------------------------------------------------------------------
    %%Function: LStrCpyW
    
-------------------------------------------------------------------------*/
LPWSTR  LStrCpyW(LPWSTR pszDest, LPWSTR pszSrc)
{
	ASSERT(NULL != pszDest);
	ASSERT(NULL != pszSrc);

	if ((NULL != pszDest) && (NULL != pszSrc))
	{
		LPWSTR pszT = pszDest;
		while (0 != (*pszT++ = *pszSrc++))
			;

	}
	return pszDest;
}


/*  L  S T R  C P Y N W  */
/*-------------------------------------------------------------------------
    %%Function: LStrCpyNW
    
-------------------------------------------------------------------------*/
LPWSTR  LStrCpyNW(LPWSTR pszDest, LPCWSTR pszSrc, INT iMaxLength)
{
	ASSERT(NULL != pszDest);
	ASSERT(NULL != pszSrc);

	if ((NULL != pszDest) && (NULL != pszSrc))
	{
		LPWSTR pszT = pszDest;
		while ((--iMaxLength > 0) && 
				(0 != (*pszT++ = *pszSrc++)))
		{
			/*EXPLICIT */ ;
		}

		if (0 == iMaxLength)
		{
			*pszT = L'\0';
		}
	}
	return pszDest;
}

#endif // !defined(UNICODE)

/*  _ S T R C H R  */
/*-------------------------------------------------------------------------
    %%Function: _StrChr
    
-------------------------------------------------------------------------*/
LPCTSTR  _StrChr ( LPCTSTR pcsz, TCHAR c )
{
    LPCTSTR pcszFound = NULL;

    if (pcsz)
    {
        while (*pcsz)
        {
            if (*pcsz == c)
            {
                pcszFound = pcsz;
                break;
            }

            pcsz = CharNext(pcsz);
        }
    }

    return pcszFound;
}


/*  _ S T R C M P N  */
/*-------------------------------------------------------------------------
    %%Function: _StrCmpN
    This does a case-sensitive compare of two strings, pcsz1 and pcsz2, of
    at most cchMax characters.  If we reach the end of either string, we
    also stop, and the strings match if the other string is also at its end.

    This function is NOT DBCS safe.
    
-------------------------------------------------------------------------*/
int  _StrCmpN(LPCTSTR pcsz1, LPCTSTR pcsz2, UINT cchMax)
{
    UINT ich;

    for (ich = 0; ich < cchMax; ich++)
    {
        if (*pcsz1 != *pcsz2)
        {
            // No match.
            return((*pcsz1 > *pcsz2) ? 1 : -1);
        }

        //
        // Are we at the end (if we're here, both strings are at the
        // end.  If only one is, the above compare code kicks in.
        //
        if ('\0' == *pcsz1)
            return 0;

        pcsz1++;
        pcsz2++;
    }

    // If we get here, cchMax characters matched, so success.
    return 0;
}

/*  _ S T R S T R  */
/*-------------------------------------------------------------------------
    %%Function: _StrStr
    
-------------------------------------------------------------------------*/
// BUGBUG - This function is *not* DBCS-safe
LPCTSTR  _StrStr (LPCTSTR pcsz1, LPCTSTR pcsz2)
{
	PTSTR pszcp = (PTSTR) pcsz1;
	PTSTR pszs1, pszs2;

	if ( !*pcsz2 )
		return pcsz1;

	while (*pszcp)
	{
		pszs1 = pszcp;
		pszs2 = (PTSTR) pcsz2;

		while ( *pszs1 && *pszs2 && !(*pszs1-*pszs2) )
			pszs1++, pszs2++;

		if (!*pszs2)
			return pszcp;

		pszcp++;
	}

	return NULL;
}

/*  _ S T R S T R  */
/*-------------------------------------------------------------------------
    %%Function: _StrStr
    
-------------------------------------------------------------------------*/
// BUGBUG - This function is *not* DBCS-safe
LPCWSTR _StrStrW(LPCWSTR pcsz1, LPCWSTR pcsz2)
{
	PWSTR pszcp = (PWSTR) pcsz1;

	while (*pszcp)
	{
		PWSTR psz1 = pszcp;
		PWSTR psz2 = (PWSTR) pcsz2;

		while ( *psz1 && *psz2 && !(*psz1-*psz2) )
		{
			psz1++;
			psz2++;
		}

		if (!*psz2)
			return pszcp;

		pszcp++;
	}

	return NULL;
}

/*  _ S T R P B R K  */
/*-------------------------------------------------------------------------
    %%Function: _StrPbrkA, _StrPbrkW

    Private, DBCS-safe version of CRT strpbrk function.  Like strchr but 
	accepts more than one character for which to search.  The ANSI version 
	does not support searching for DBCS chars.

	In the Unicode version, we do a nested search.  In the ANSI version,
	we build up a table of chars and use this to scan the string.
-------------------------------------------------------------------------*/
LPSTR  _StrPbrkA(LPCSTR pcszString, LPCSTR pcszSearch)
{
	ASSERT(NULL != pcszString && NULL != pcszSearch);

	BYTE rgbSearch[(UCHAR_MAX + 1) / CHAR_BIT];

	ZeroMemory(rgbSearch, sizeof(rgbSearch));

	// Scan the search string
	while ('\0' != *pcszSearch)
	{
		ASSERT(!IsDBCSLeadByte(*pcszSearch));

		// Set the appropriate bit in the appropriate byte
		rgbSearch[*pcszSearch / CHAR_BIT] |= (1 << (*pcszSearch % CHAR_BIT));

		pcszSearch++;
	}

	// Scan the source string, compare to the bits in the search array
	while ('\0' != *pcszString)
	{
		if (rgbSearch[*pcszString / CHAR_BIT] & (1 << (*pcszString % CHAR_BIT)))
		{
			// We have a match
			return (LPSTR) pcszString;
		}

		pcszString = CharNextA(pcszString);
	}

	// If we get here, there was no match
	return NULL;
}


LPWSTR  _StrPbrkW(LPCWSTR pcszString, LPCWSTR pcszSearch)
{
	ASSERT(NULL != pcszString && NULL != pcszSearch);

	// Scan the string, matching each character against those in the search string
	while (L'\0' != *pcszString)
	{
		LPCWSTR pcszCurrent = pcszSearch;

		while (L'\0' != *pcszCurrent)
		{
			if (*pcszString == *pcszCurrent)
			{
				// We have a match
				return (LPWSTR) pcszString;
			}

			// pcszCurrent = CharNextW(pcszCurrent);
			pcszCurrent++;
		}

		// pcszString = CharNextW(pcszString);
		pcszString++;
	}

	// If we get here, there was no match
	return NULL;
}


// BUGBUG - Are DecimalStringToUINT and StrToInt the same?

/*  D E C I M A L  S T R I N G  T O  U  I  N  T  */
/*-------------------------------------------------------------------------
    %%Function: DecimalStringToUINT
    
-------------------------------------------------------------------------*/
UINT  DecimalStringToUINT(LPCTSTR pcszString)
{
	ASSERT(pcszString);
	UINT uRet = 0;
	LPTSTR pszStr = (LPTSTR) pcszString;
	while (_T('\0') != pszStr[0])
	{
		ASSERT((pszStr[0] >= _T('0')) &&
				(pszStr[0] <= _T('9')));
		uRet = (10 * uRet) + (BYTE) (pszStr[0] - _T('0'));
		pszStr++; // NOTE: DBCS characters are not allowed!
	}
	return uRet;
}


/****************************************************************************
    
	FUNCTION:	StrToInt

    PURPOSE:	The atoi equivalent, to avoid using the C runtime lib

	PARAMETERS: lpSrc - pointer to a source string to convert to integer

	RETURNS:	0 for failure, the integer otherwise
				(what if the string was converted to 0 ?)

****************************************************************************/
int WINAPI RtStrToInt(LPCTSTR lpSrc)       // atoi()
{
    int n = 0;
    BOOL bNeg = FALSE;

    if (*lpSrc == _T('-')) {
        bNeg = TRUE;
        lpSrc++;
    }

    while (((*lpSrc) >= _T('0') && (*lpSrc) <= _T('9')))
    {
        n *= 10;
        n += *lpSrc - _T('0');
        lpSrc++;
    }
    return bNeg ? -n : n;
}

/*  _ S T R L W R W  */
/*-------------------------------------------------------------------------
    %%Function: _StrLwrW
    
-------------------------------------------------------------------------*/
// BUGBUG - This function does *not* handle all UNICODE character sets

LPWSTR  _StrLwrW(LPWSTR pwszSrc)
{
	for (PWSTR pwszCur = pwszSrc; (L'\0' != *pwszCur); pwszCur++)
	{
		if ( (*pwszCur >= L'A') && (*pwszCur <= L'Z') )
		{
			*pwszCur = *pwszCur - L'A' + L'a';
		}
	}
	return pwszSrc;
}