/* File: D:\WACKER\tdll\tchar.c (Created: 08-Dec-1993) * * Copyright 1994 by Hilgraeve Inc. -- Monroe, MI * All rights reserved * * $Revision: 19 $ * $Date: 7/08/02 6:49p $ */ #include #pragma hdrstop #include #include "stdtyp.h" #include "tdll.h" #include "assert.h" #include "htchar.h" #include "mc.h" /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * TCHAR_Fill * * DESCRIPTION: * Fills a TCHAR string with the specified TCHAR. * * ARGUMENTS: * dest - string to fill. * c - character to fill string with. * size_t - number of TCHAR units to copy. * * RETURNS: * pointer to string. * */ TCHAR *TCHAR_Fill(TCHAR *dest, TCHAR c, size_t count) { #if defined(UNICODE) int i; for (i = 0 ; i < count ; ++i) dest[i] = c; return dest; #else return (TCHAR *)memset(dest, c, count); #endif } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * TCHAR_Trim * * DESCRIPTION: * This function is called to clean up user input. It strips all white * space from the front and rear of a string. Sometimes nothing is left. * * NOTE: This won't work on strings > 512 bytes * * ARGUEMENTS: * pszStr -- the string to trim * * RETURNS: * pointer to the string */ TCHAR *TCHAR_Trim(TCHAR *pszStr) { int nExit; TCHAR *pszPtr; TCHAR *pszLast; TCHAR acBuf[512]; /* Skip the leading white space */ for (nExit = FALSE, pszPtr = pszStr; nExit == FALSE; ) { switch (*pszPtr) { /* Anything here is considered white space */ case 0x20: case 0x9: case 0xA: case 0xB: case 0xC: case 0xD: pszPtr += 1; /* Skip the white space */ break; default: nExit = TRUE; break; } } if ((unsigned int)lstrlen(pszPtr) > sizeof(acBuf)) { return NULL; } lstrcpy(acBuf, pszPtr); /* Find the last non white space character */ pszPtr = pszLast = acBuf; while (*pszPtr != TEXT('\0')) { switch (*pszPtr) { /* Anything here is considered white space */ case 0x20: case 0x9: case 0xA: case 0xB: case 0xC: case 0xD: break; default: pszLast = pszPtr; break; } pszPtr += 1; } pszLast += 1; *pszLast = TEXT('\0'); lstrcpy(pszStr, acBuf); return pszStr; } #if 0 // Thought I needed this but I didn't. May be useful someday however. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * TCHAR_Trunc * * DESCRIPTION: * Removes trailing space from a character array. Does not assume * * ARGUMENTS: * psz - string of characters (null terminated). * * RETURNS: * Length of truncated string * */ int TCHAR_Trunc(const LPTSTR psz) { int i; for (i = lstrlen(psz) - 1 ; i > 0 ; --i) { switch (psz[i]) { /* Whitespace characters */ case TEXT(' '): case TEXT('\t'): case TEXT('\n'): case TEXT('\v'): case TEXT('\f'): case TEXT('\r'): break; default: psz[i+1] = TEXT('\0'); return i; } } return i; } #endif /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharNext * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharNext(LPCTSTR pszStr) { LPTSTR pszRet = (LPTSTR)NULL; if (pszStr != (LPTSTR)NULL) { #if defined(CHAR_MIXED) /* Could be done with 'IsDBCSLeadByte' etc. */ pszRet = CharNextExA(0, pszStr, 0); #else pszRet = (LPTSTR)pszStr + 1; #endif } return pszRet; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharPrev * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharPrev(LPCTSTR pszStart, LPCTSTR pszStr) { LPTSTR pszRet = (LPTSTR)NULL; if ((pszStart != (LPTSTR)NULL) && (pszStr != (LPTSTR)NULL)) { #if defined(CHAR_MIXED) pszRet = CharPrev(pszStart, pszStr); #else if (pszStr > pszStart) pszRet = (LPTSTR)pszStr - 1; else pszRet = (LPTSTR)pszStart; #endif } return pszRet; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharLast * * DESCRIPTION: * Returns a pointer to the last character in a string * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharLast(LPCTSTR pszStr) { LPTSTR pszRet = (LPTSTR)NULL; if (pszStr != (LPTSTR)NULL) { #if defined(CHAR_MIXED) while (*pszStr != TEXT('\0')) { pszRet = (LPTSTR)pszStr; pszStr = CharNextExA(0, pszStr, 0); } #else /* It might be possible to use 'strlen' here. Then again... */ // pszRet = pszStr + StrCharGetByteCount(pszStr) - 1; pszRet = (LPTSTR)pszStr + lstrlen(pszStr) - 1; #endif } return pszRet; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharEnd * * DESCRIPTION: * Returns a pointer to the NULL terminating a string * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharEnd(LPCTSTR pszStr) { if (pszStr != (LPTSTR)NULL) { #if defined(CHAR_MIXED) while (*pszStr != TEXT('\0')) { pszStr = StrCharNext(pszStr); pszStr += 1; } #else pszStr = pszStr + lstrlen(pszStr); #endif } return (LPTSTR)pszStr; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharFindFirst * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharFindFirst(LPCTSTR pszStr, int nChar) { #if defined(CHAR_MIXED) WORD *pszW; #endif if (pszStr != (LPTSTR)NULL) { #if defined(CHAR_MIXED) while (*pszStr != TEXT('\0')) { /* * NOTE: this may not work for UNICODE */ if (nChar > 0xFF) { /* Two byte character */ if (IsDBCSLeadByte(*pszStr)) { pszW = (WORD *)pszStr; if (*pszW == (WORD)nChar) return (LPTSTR)pszStr; } } else { /* Single byte character */ if (*pszStr == (TCHAR)nChar) return (LPTSTR)pszStr; } pszStr = CharNextExA(0, pszStr, 0); } #else while (pszStr && (*pszStr != TEXT('\0')) ) { if (*pszStr == (TCHAR)nChar) return (LPTSTR)pszStr; pszStr = StrCharNext(pszStr); } #endif } return (LPTSTR)NULL; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharFindLast * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharFindLast(LPCTSTR pszStr, int nChar) { LPTSTR pszRet = (LPTSTR)NULL; #if defined(CHAR_MIXED) WORD *pszW; #else LPTSTR pszEnd; #endif if (pszStr != (LPTSTR)NULL) { #if defined(CHAR_MIXED) while (*pszStr != TEXT('\0')) { /* * NOTE: this may not work for UNICODE */ if (nChar > 0xFF) { /* Two byte character */ if (IsDBCSLeadByte(*pszStr)) { pszW = (WORD *)pszStr; if (*pszW == (WORD)nChar) pszRet = (LPTSTR)pszStr; } } else { /* Single byte character */ if (*pszStr == (TCHAR)nChar) pszRet = (LPTSTR)pszStr; } pszStr = CharNextExA(0, pszStr, 0); } #else pszEnd = StrCharLast(pszStr); while (pszEnd && (pszEnd > pszStr) ) { if (*pszEnd == (TCHAR)nChar) { pszRet = (LPTSTR)pszEnd; break; } pszEnd = StrCharPrev(pszStr, pszEnd); } #endif } return pszRet; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharGetStrLength * * DESCRIPTION: * This function returns the number of characters in a string. A two byte * character counts as one. * * PARAMETERS: * * RETURNS: */ int StrCharGetStrLength(LPCTSTR pszStr) { int nRet = 0; #if DEADWOOD #if defined(CHAR_MIXED) if (pszStr != (LPTSTR)NULL) { while (*pszStr != TEXT('\0')) { nRet++; pszStr = CharNextExA(0, pszStr, 0); } } #else if (pszStr != (LPTSTR)NULL) { nRet = lstrlen(pszStr); } #endif #else // DEADWOOD if (pszStr != (LPTSTR)NULL) { nRet = lstrlen(pszStr); } #endif // DEADWOOD return nRet; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharGetByteCount * * DESCRIPTION: * This function returns the number of bytes in a string. A two byte char * counts as two. * * PARAMETERS: * * RETURNS: */ int StrCharGetByteCount(LPCTSTR pszStr) { int nRet = 0; #if defined(CHAR_MIXED) LPCTSTR pszFoo; if (pszStr != (LPTSTR)NULL) { pszFoo = pszStr; while (*pszFoo != TEXT('\0')) { pszFoo = CharNextExA(0, pszFoo, 0); } nRet = (int)(pszFoo - pszStr); } #else if (pszStr != (LPTSTR)NULL) { nRet = lstrlen(pszStr); } #endif return nRet; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharCopy * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharCopy(LPTSTR pszDst, LPCTSTR pszSrc) { return lstrcpy(pszDst, pszSrc); } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharCat * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharCat(LPTSTR pszDst, LPCTSTR pszSrc) { return lstrcat(pszDst, pszSrc); } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharCmp * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ int StrCharCmp(LPCTSTR pszA, LPCTSTR pszB) { return lstrcmp(pszA, pszB); } int StrCharCmpi(LPCTSTR pszA, LPCTSTR pszB) { return lstrcmpi(pszA, pszB); } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharCmpN * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ int StrCharCmpN(LPCTSTR pszA, LPCTSTR pszB, size_t iLen) { return _tcsncmp(pszA, pszB, iLen); } int StrCharCmpiN(LPCTSTR pszA, LPCTSTR pszB, size_t iLen) { return _tcsnicmp(pszA, pszB, iLen); } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharStrStr * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ LPTSTR StrCharStrStr(LPCTSTR pszA, LPCTSTR pszB) { LPTSTR pszRet = (LPTSTR)NULL; int nSize; int nRemaining; LPTSTR pszPtr; /* * We need to write a version of 'strstr' that will work. * Do we really know what the problems are ? */ nSize = StrCharGetByteCount(pszB); pszPtr = (LPTSTR)pszA; while ((nRemaining = StrCharGetByteCount(pszPtr)) >= nSize) { if (memcmp(pszPtr, pszB, (size_t)nSize) == 0) return pszPtr; pszPtr = StrCharNext(pszPtr); } return pszRet; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * StrCharCopyN * * DESCRIPTION: * Basically do a lstrcpy of n bytes, with one exception, we make sure that * the copied string does not end in a lead-byte of a double-byte character. * * ARGUMENTS: * pszDst - pointer to the copy target string. * pszSrc - pointer to the copy source string. * iLen - the maximum number of TCHARs to copy. Like strcpyn, the string may not be null terminated if the buffer is exceeded. * * RETURNS: * 0=error, else pszDst * */ LPTSTR StrCharCopyN(LPTSTR pszDst, LPCTSTR pszSrc, int iLen) { int i = 0; int iCounter = iLen * sizeof(TCHAR); // Use a temporary character counter. LPCTSTR psz = pszSrc; if (pszDst == 0 || pszSrc == 0 || iLen == 0 || iCounter == 0) return 0; while (1) { i = (int)(StrCharNext(psz) - psz); iCounter -= i; if (iCounter <= 0) break; if (*psz == TEXT('\0')) { // // Since StrCharNext() will return the pointer to the // terminating null character if at the end of the string, // so just increment to the next address location so we // have the correct number of bytes to copy (excluding // the terminating NULL character). We NULL terminate // the string at the end of this function, so we don't // have to copy the NULL character. REV: 12/28/2000. // psz += 1; // still need to increment break; } psz += i; } // // Make sure we don't overwrite memory. REV: 12/28/2000. // i = min((LONG)((psz - pszSrc) + sizeof(TCHAR)), iLen * (int)sizeof(TCHAR)); MemCopy(pszDst, pszSrc, i); // // Make sure the string is null terminated. REV: 12/28/2000. // pszDst[(i / sizeof(TCHAR)) - 1] = TEXT('\0'); return pszDst; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharPBrk * * DESCRIPTION: * Searches a string for the first occurrence of a character contained in a * specified buffer. This search does not include the null terminator. * * PARAMETERS: * pszStr - Address of the string to be searched. * pszSet - Address of a null-terminated character buffer that contains the * characters for which to search. * * RETURNS: * Returns the address in psz of the first occurrence of a character * contained in the buffer at pszSet, or NULL if no match is found. */ LPTSTR StrCharPBrk(LPCTSTR pszStr, LPCTSTR pszSet) { LPCTSTR psz = pszSet; LPTSTR pszRetVal = NULL; while (*psz != TEXT('\0')) { if ((pszRetVal = StrCharFindFirst(pszStr, (int)(*psz))) != NULL) break; psz++; } return pszRetVal; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * CnvrtMBCStoECHAR * * DESCRIPTION: * Converts a DBCS (mixed byte) string into an ECHAR (double byte) string. * * PARAMETERS: * tchrSource - Source String * ulDestSize - Length of Destination String in Bytes * echrDest - Destination String * ulSourceSize - Length of Destination String in Bytes * * RETURNS: * 0 - Success * 1 - Error */ int CnvrtMBCStoECHAR(ECHAR * echrDest, const unsigned long ulDestSize, const TCHAR * const tchrSource, const unsigned long ulSourceSize) { ULONG ulLoop = 0; ULONG ulDestCount = 0; ULONG ulDestEChars = ulDestSize / sizeof(ECHAR); BOOL fLeadByteFound = FALSE; if ((echrDest == NULL) || (tchrSource == NULL)) { assert(FALSE); return TRUE; } // Make sure that the destination string is big enough to handle to source string if (ulDestEChars < ulSourceSize) { assert(FALSE); return 1; } #if defined(CHAR_MIXED) // because we do a strcpy in the NARROW version of this function, // and we want the behavior to be the save between the two. We // clear out the string, just like strcpy does memset(echrDest, 0, ulDestSize); for (ulLoop = 0; ulLoop < ulSourceSize; ulLoop++) { if ((IsDBCSLeadByte(tchrSource[ulLoop])) && (!fLeadByteFound)) // If we found a lead byte, and the last one was not a lead // byte. We load the byte into the top half of the ECHAR { echrDest[ulDestCount] = (tchrSource[ulLoop] & 0x00FF); echrDest[ulDestCount] = (ECHAR)(echrDest[ulDestCount] << 8); fLeadByteFound = TRUE; } else if (fLeadByteFound) { // If the last byte was a lead byte, we or it into the // bottom half of the ECHAR echrDest[ulDestCount] |= (tchrSource[ulLoop] & 0x00FF); fLeadByteFound = FALSE; ulDestCount++; } else { // Otherwise we load the byte into the bottom half of the // ECHAR and clear the top half. echrDest[ulDestCount] = (tchrSource[ulLoop] & 0x00FF); ulDestCount++; } } #else // ECHAR is only a byte, so do a straight string copy. if (ulSourceSize) MemCopy(echrDest, tchrSource, ulSourceSize); #endif return 0; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * CnvrtECHARtoMBCS * * DESCRIPTION: * Converts an ECHAR (double byte) string into a DBCS (mixed byte) string. * * PARAMETERS: * echrSource - Source String * ulDestSize - Length of Destination String in Bytes * tchrDest - Destination String * * RETURNS: * Number of bytes in the converted string * 1 - Error */ int CnvrtECHARtoMBCS(TCHAR * tchrDest, const unsigned long ulDestSize, const ECHAR * const echrSource, const unsigned long ulSourceSize) { ULONG ulLoop = 0; ULONG ulDestCount = 0; ULONG ulSourceEChars = ulSourceSize / sizeof(ECHAR); #if defined(INCL_VTUTF8) extern BOOL DoUTF8; #endif if ((tchrDest == NULL) || (echrSource == NULL)) { assert(FALSE); return TRUE; } #if defined(CHAR_MIXED) // because we do a strcpy in the NARROW version of this function, // and we want the behavior to be the save between the two. We // clear out the string, just like strcpy does memset(tchrDest, 0, ulDestSize); // We can't do a strlen of an ECHAR string, so we loop // until we hit NULL or we are over the size of the destination. while ((ulLoop < ulSourceEChars) && (ulDestCount <= ulDestSize)) { if (echrSource[ulLoop] & 0xFF00) // Lead byte in this character, load the lead byte into one // TCHAR and the lower byte into a second TCHAR. { tchrDest[ulDestCount] = (TCHAR)((echrSource[ulLoop] & 0xFF00) >> 8); ulDestCount++; tchrDest[ulDestCount] = (TCHAR)(echrSource[ulLoop] & 0x00FF); } else // No lead byte in this ECHAR, just load the lower half into // the TCHAR. { tchrDest[ulDestCount] = (TCHAR)(echrSource[ulLoop] & 0x00FF); } ulDestCount++; ulLoop++; if(ulDestCount > ulDestSize) assert(FALSE); } return ulDestCount; #else // ECHAR is only a byte, so do a straight string copy. if (ulSourceSize) MemCopy(tchrDest, echrSource, ulSourceSize); return ulSourceSize; #endif } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharGetEcharLen * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ int StrCharGetEcharLen(const ECHAR * const pszA) { int nReturn = 0; if (pszA == NULL) { assert(FALSE); return nReturn; } #if defined(CHAR_MIXED) while (pszA[nReturn] != ETEXT('\0')) { nReturn++; } #else nReturn = strlen(pszA); #endif return nReturn; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharGetEcharByteCount * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ int StrCharGetEcharByteCount(const ECHAR * const pszA) { #if defined(CHAR_MIXED) int nLoop = 0; #endif if (pszA == NULL) { assert(FALSE); return 0; } #if defined(CHAR_MIXED) while (pszA[nLoop] != 0) { nLoop++; } nLoop *= (int)sizeof(ECHAR); return nLoop; #else return (int)strlen(pszA); #endif } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= * FUNCTION: * StrCharCmpEtoT * * DESCRIPTION: * * PARAMETERS: * * RETURNS: */ int StrCharCmpEtoT(const ECHAR * const pszA, const TCHAR * const pszB) { #if defined(CHAR_MIXED) TCHAR *tpszA = NULL; int nLenA = StrCharGetEcharLen(pszA); tpszA = (TCHAR *)malloc((unsigned int)nLenA * sizeof(ECHAR)); if (tpszA == NULL) { assert(FALSE); return 0; } CnvrtECHARtoMBCS(tpszA, (unsigned long)(nLenA * (int)sizeof(ECHAR)), pszA, StrCharGetEcharByteCount(pszA)); return StrCharCmp(tpszA, pszB); #else return strcmp(pszA, pszB); #endif } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * ECHAR_Fill * * DESCRIPTION: * Fills a ECHAR string with the specified ECHAR. * * ARGUMENTS: * dest - string to fill. * c - character to fill string with. * size_t - number of ECHAR units to copy. * * RETURNS: * pointer to string. * */ ECHAR *ECHAR_Fill(ECHAR *dest, ECHAR c, size_t count) { #if defined(CHAR_NARROW) return (TCHAR *)memset(dest, c, count); #else unsigned int i; if (dest == NULL) { assert(FALSE); return 0; } for (i = 0 ; i < count ; ++i) dest[i] = c; return dest; #endif } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * ECHAR_Fill * * DESCRIPTION: * * * ARGUMENTS: * pszDest - string to fill. * cchDest - number of TCHAR units to copy. * eChar - character to fill string with. * * RETURNS: * pointer to string. * */ int CnvrtECHARtoTCHAR(LPTSTR pszDest, int cchDest, ECHAR eChar) { #if defined(CHAR_NARROW) pszDest[0] = eChar; pszDest[1] = ETEXT('\0'); #else memset(pszDest, 0, cchDest*sizeof(*pszDest)); // This is the only place where we convert a single ECHAR to TCHAR's // so as of right now we will not make this into a function. if (eChar & 0xFF00) // Lead byte in this character, load the lead byte into one // TCHAR and the lower byte into a second TCHAR. { if (cchDest >= 2) { pszDest[0] = (TCHAR)((eChar & 0xFF00) >> 8); pszDest[1] = (TCHAR)(eChar & 0x00FF); } else { return 1; } } else // No lead byte in this ECHAR, just load the lower half into // the TCHAR. { pszDest[0] = (TCHAR)(eChar & 0x00FF); } #endif return 0; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * isDBCSChar * * DESCRIPTION: * Determines if the Character is Double Byte or not * * * ARGUMENTS: * c - character to test. * * RETURNS: * int TRUE - if DBCS * FALSE - if SBCS * */ int isDBCSChar(unsigned int Char) { int rtn = 0; #if defined(CHAR_NARROW) rtn = 0; #else ECHAR ech = 0; char ch; if (Char == 0) { // assert(FALSE); return FALSE; } ech = ETEXT(Char); if (ech & 0xFF00) { ch = (char)(ech >> 8); if (IsDBCSLeadByte(ch)) { rtn = 1; } } #endif return rtn; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- * FUNCTION: * StrCharStripDBCSString * * DESCRIPTION: * Strips out Left/Right pairs of wide characters and leaves a single wide character * in it's place * * * ARGUMENTS: * aech - String to be stripped * * RETURNS: * int - number of characters striped out of string * */ int StrCharStripDBCSString(ECHAR *aechDest, const long lDestSize, ECHAR *aechSource) { int nCount = 0; #if !defined(CHAR_NARROW) ECHAR *pechTmpS; ECHAR *pechTmpD; long j; long lDLen = lDestSize / sizeof(ECHAR);; if ((aechSource == NULL) || (aechDest == NULL)) { assert(FALSE); return nCount; } pechTmpS = aechSource; pechTmpD = aechDest; for (j = 0; (*pechTmpS != '\0') && (j < lDLen); j++) { *pechTmpD = *pechTmpS; if ((isDBCSChar(*pechTmpS)) && (*(pechTmpS + 1) != '\0')) { if (*pechTmpS == *(pechTmpS + 1)) { pechTmpS++; nCount++; } } pechTmpS++; pechTmpD++; } *pechTmpD = ETEXT('\0'); #endif return nCount; } #if defined(DEADWOOD) #if defined(INCL_VTUTF8) //****************************************************************************** // Function: TranslateUTF8ToDBCS // // Description: // This function will convert a UTF-8 character to a DBCS character. If the // character passed is not a full description of a UTF-8 character, then the // character is appended to the UNICODE buffer. // Arguments: // IncomingByte // pUTF8Buffer // iUTF8BufferLength // pUNICODEBuffer // iUNICODEBufferLength // pDBCSBuffer // iDBCSBufferLength // // Returns: // // Throws: // // Author: Ron E. Vorndam, 03/06/2001 // BOOLEAN TranslateUTF8ToDBCS(UCHAR IncomingByte, UCHAR *pUTF8Buffer, int iUTF8BufferLength, WCHAR *pUNICODEBuffer, int iUNICODEBufferLength, TCHAR *pDBCSBuffer, int iDBCSBufferLength) { BOOLEAN bReturn = FALSE; int iLength = 0; if (pUTF8Buffer != NULL && iUTF8BufferLength > 0 && pUNICODEBuffer != NULL && iUNICODEBufferLength > 0 && pDBCSBuffer != NULL && iDBCSBufferLength > 0) { // // Translate from UTF8 to UNICODE. // if (TranslateUtf8ToUnicode(IncomingByte, pUTF8Buffer, pUNICODEBuffer) == TRUE) { // // Now Translate the UNICODE to DBCS characters. // iLength = WideCharToMultiByte(CP_OEMCP, //iLength = WideCharToMultiByte(CP_ACP, 0, //WC_COMPOSITECHECK | WC_SEPCHARS, pUNICODEBuffer, -1, NULL, 0, NULL, NULL ); if (iLength > 0 && iDBCSBufferLength >= iLength) { WideCharToMultiByte(CP_OEMCP, //WideCharToMultiByte(CP_ACP, 0, //WC_COMPOSITECHECK | WC_SEPCHARS, pUNICODEBuffer, -1, pDBCSBuffer, iLength, NULL, NULL); if (iLength > 0) { bReturn = TRUE; } } else { // // Return an error and report the number of bytes required to // make the data conversion. // iDBCSBufferLength = iLength * -1; } } } return bReturn; } BOOLEAN TranslateDBCSToUTF8(const TCHAR *pDBCSBuffer, int iDBCSBufferLength, WCHAR *pUNICODEBuffer, int iUNICODEBufferLength, UCHAR *pUTF8Buffer, int iUTF8BufferLength) { BOOLEAN bReturn = FALSE; int iLength = 0; //iLength = WideCharToMultiByte(CP_OEMCP, iLength = MultiByteToWideChar(CP_ACP, 0, //WC_COMPOSITECHECK | WC_SEPCHARS, pDBCSBuffer, -1, pUNICODEBuffer, iLength); if (iLength > 0 && iDBCSBufferLength > 0) { if (pUNICODEBuffer != NULL && iUNICODEBufferLength >= iLength) { // // Translate the DBCS to UNICODE characters. // //WideCharToMultiByte(CP_OEMCP, MultiByteToWideChar(CP_ACP, 0, //MB_COMPOSITE, pDBCSBuffer, -1, pUNICODEBuffer, iLength); if (iLength > 0 && iLength <= iUTF8BufferLength) { // // Translate from UNICODE to UTF8. // bReturn = TranslateUnicodeToUtf8(pUNICODEBuffer, pUTF8Buffer); } } } return bReturn; } // // The following functions are from code obtained directly from // Microsoft for converting Unicode to UTF-8 and UTF-8 to unicode // buffers. REV: 03/02/2001 // BOOLEAN TranslateUnicodeToUtf8(PCWSTR SourceBuffer, UCHAR *DestinationBuffer) /*++ Routine Description: translates a unicode buffer into a UTF8 version. Arguments: SourceBuffer - unicode buffer to be translated. DestinationBuffer - receives UTF8 version of same buffer. Return Value: TRUE - We successfully translated the Unicode value into its corresponding UTF8 encoding. FALSE - The translation failed. --*/ { ULONG Count = 0; // // convert into UTF8 for actual transmission // // UTF-8 encodes 2-byte Unicode characters as follows: // If the first nine bits are zero (00000000 0xxxxxxx), encode it as one byte 0xxxxxxx // If the first five bits are zero (00000yyy yyxxxxxx), encode it as two bytes 110yyyyy 10xxxxxx // Otherwise (zzzzyyyy yyxxxxxx), encode it as three bytes 1110zzzz 10yyyyyy 10xxxxxx // DestinationBuffer[Count] = (UCHAR)'\0'; while (*SourceBuffer) { if( (*SourceBuffer & 0xFF80) == 0 ) { // // if the top 9 bits are zero, then just // encode as 1 byte. (ASCII passes through unchanged). // DestinationBuffer[Count++] = (UCHAR)(*SourceBuffer & 0x7F); } else if( (*SourceBuffer & 0xF800) == 0 ) { // // if the top 5 bits are zero, then encode as 2 bytes // DestinationBuffer[Count++] = (UCHAR)((*SourceBuffer >> 6) & 0x1F) | 0xC0; DestinationBuffer[Count++] = (UCHAR)(*SourceBuffer & 0xBF) | 0x80; } else { // // encode as 3 bytes // DestinationBuffer[Count++] = (UCHAR)((*SourceBuffer >> 12) & 0xF) | 0xE0; DestinationBuffer[Count++] = (UCHAR)((*SourceBuffer >> 6) & 0x3F) | 0x80; DestinationBuffer[Count++] = (UCHAR)(*SourceBuffer & 0xBF) | 0x80; } SourceBuffer += 1; } DestinationBuffer[Count] = (UCHAR)'\0'; return(TRUE); } BOOLEAN TranslateUtf8ToUnicode(UCHAR IncomingByte, UCHAR *ExistingUtf8Buffer, WCHAR *DestinationUnicodeVal) /*++ Routine Description: Takes IncomingByte and concatenates it onto ExistingUtf8Buffer. Then attempts to decode the new contents of ExistingUtf8Buffer. Arguments: IncomingByte - New character to be appended onto ExistingUtf8Buffer. ExistingUtf8Buffer - running buffer containing incomplete UTF8 encoded unicode value. When it gets full, we'll decode the value and return the corresponding Unicode value. Note that if we *do* detect a completed UTF8 buffer and actually do a decode and return a Unicode value, then we will zero-fill the contents of ExistingUtf8Buffer. DestinationUnicodeVal - receives Unicode version of the UTF8 buffer. Note that if we do *not* detect a completed UTF8 buffer and thus can not return any data in DestinationUnicodeValue, then we will zero-fill the contents of DestinationUnicodeVal. Return Value: TRUE - We received a terminating character for our UTF8 buffer and will return a decoded Unicode value in DestinationUnicode. FALSE - We haven't yet received a terminating character for our UTF8 buffer. --*/ { // ULONG Count = 0; ULONG i = 0; BOOLEAN ReturnValue = FALSE; // // Insert our byte into ExistingUtf8Buffer. // i = 0; do { if( ExistingUtf8Buffer[i] == 0 ) { ExistingUtf8Buffer[i] = IncomingByte; break; } i++; } while( i < 3 ); // // If we didn't get to actually insert our IncomingByte, // then someone sent us a fully-qualified UTF8 buffer. // This means we're about to drop IncomingByte. // // Drop the zero-th byte, shift everything over by one // and insert our new character. // // This implies that we should *never* need to zero out // the contents of ExistingUtf8Buffer unless we detect // a completed UTF8 packet. Otherwise, assume one of // these cases: // 1. We started listening mid-stream, so we caught the // last half of a UTF8 packet. In this case, we'll // end up shifting the contents of ExistingUtf8Buffer // until we detect a proper UTF8 start byte in the zero-th // position. // 2. We got some garbage character, which would invalidate // a UTF8 packet. By using the logic below, we would // end up disregarding that packet and waiting for // the next UTF8 packet to come in. if( i >= 3 ) { ExistingUtf8Buffer[0] = ExistingUtf8Buffer[1]; ExistingUtf8Buffer[1] = ExistingUtf8Buffer[2]; ExistingUtf8Buffer[2] = IncomingByte; } // // Attempt to convert the UTF8 buffer // // UTF8 decodes to Unicode in the following fashion: // If the high-order bit is 0 in the first byte: // 0xxxxxxx yyyyyyyy zzzzzzzz decodes to a Unicode value of 00000000 0xxxxxxx // // If the high-order 3 bits in the first byte == 6: // 110xxxxx 10yyyyyy zzzzzzzz decodes to a Unicode value of 00000xxx xxyyyyyy // // If the high-order 3 bits in the first byte == 7: // 1110xxxx 10yyyyyy 10zzzzzz decodes to a Unicode value of xxxxyyyy yyzzzzzz // if( (ExistingUtf8Buffer[0] & 0x80) == 0 ) { // // First case described above. Just return the first byte // of our UTF8 buffer. // *DestinationUnicodeVal = (WCHAR)(ExistingUtf8Buffer[0]); // // We used 1 byte. Discard that byte and shift everything // in our buffer over by 1. // ExistingUtf8Buffer[0] = ExistingUtf8Buffer[1]; ExistingUtf8Buffer[1] = ExistingUtf8Buffer[2]; ExistingUtf8Buffer[2] = 0; ReturnValue = TRUE; } else if( (ExistingUtf8Buffer[0] & 0xE0) == 0xC0 ) { // // Second case described above. Decode the first 2 bytes of // of our UTF8 buffer. // if( (ExistingUtf8Buffer[1] & 0xC0) == 0x80 ) { // upper byte: 00000xxx *DestinationUnicodeVal = ((ExistingUtf8Buffer[0] >> 2) & 0x07); *DestinationUnicodeVal = *DestinationUnicodeVal << 8; // high bits of lower byte: xx000000 *DestinationUnicodeVal |= ((ExistingUtf8Buffer[0] & 0x03) << 6); // low bits of lower byte: 00yyyyyy *DestinationUnicodeVal |= (ExistingUtf8Buffer[1] & 0x3F); // // We used 2 bytes. Discard those bytes and shift everything // in our buffer over by 2. // ExistingUtf8Buffer[0] = ExistingUtf8Buffer[2]; ExistingUtf8Buffer[1] = 0; ExistingUtf8Buffer[2] = 0; ReturnValue = TRUE; } } else if( (ExistingUtf8Buffer[0] & 0xF0) == 0xE0 ) { // // Third case described above. Decode the all 3 bytes of // of our UTF8 buffer. // if( (ExistingUtf8Buffer[1] & 0xC0) == 0x80 ) { if( (ExistingUtf8Buffer[2] & 0xC0) == 0x80 ) { // upper byte: xxxx0000 *DestinationUnicodeVal = ((ExistingUtf8Buffer[0] << 4) & 0xF0); // upper byte: 0000yyyy *DestinationUnicodeVal |= ((ExistingUtf8Buffer[1] >> 2) & 0x0F); *DestinationUnicodeVal = *DestinationUnicodeVal << 8; // lower byte: yy000000 *DestinationUnicodeVal |= ((ExistingUtf8Buffer[1] << 6) & 0xC0); // lower byte: 00zzzzzz *DestinationUnicodeVal |= (ExistingUtf8Buffer[2] & 0x3F); // // We used all 3 bytes. Zero out the buffer. // ExistingUtf8Buffer[0] = 0; ExistingUtf8Buffer[1] = 0; ExistingUtf8Buffer[2] = 0; ReturnValue = TRUE; } } } return ReturnValue; } #endif //INCL_VTUTF8 #endif // defined(DEADWOOD)