|
|
#include "precomp.h"
int StrPrepend(LPTSTR pszSource, UINT cchSource, LPCTSTR pszAdd, UINT cchAdd /*= 0*/) { int iLen;
if (pszSource == NULL) return -1;
iLen = StrLen(pszSource);
if (cchAdd == 0) cchAdd = StrLen(pszAdd); if (cchAdd == 0) return iLen;
if (iLen + cchAdd >= cchSource) return -1;
MoveMemory(pszSource + cchAdd, pszSource, StrCbFromCch(iLen + 1)); CopyMemory(pszSource, pszAdd, StrCbFromCch(cchAdd));
return iLen + cchAdd; }
void StrRemoveAllWhiteSpace(LPTSTR pszBuf) { LPTSTR pszSearch; TCHAR tchar; int i = 0;
for (i = 0, pszSearch = pszBuf; *pszSearch; i++, pszSearch++) { tchar = *pszSearch; while ((tchar == TEXT(' ')) || (tchar == TEXT('\t')) || (tchar == TEXT('\r')) || (tchar == TEXT('\n'))) { pszSearch++; tchar = *pszSearch; } pszBuf[i] = *pszSearch; if (!*pszSearch) break; } pszBuf[i] = TEXT('\0'); }
LPTSTR StrGetNextField(LPTSTR *ppszData, LPCTSTR pcszDeLims, DWORD dwFlags) // If (dwFlags & IGNORE_QUOTES) is TRUE, then look for any char in pcszDeLims in *ppszData. If found,
// replace it with the '\0' char and set *ppszData to point to the beginning of the next field and return
// pointer to current field.
//
// If (dwFlags & IGNORE_QUOTES) is FALSE, then look for any char in pcszDeLims outside of balanced quoted sub-strings
// in *ppszData. If found, replace it with the '\0' char and set *ppszData to point to the beginning of
// the next field and return pointer to current field.
//
// If (dwFlags & REMOVE_QUOTES) is TRUE, then remove the surrounding quotes and replace two consecutive quotes by one.
//
// NOTE: If IGNORE_QUOTES and REMOVE_QUOTES are both specified, then IGNORE_QUOTES takes precedence over REMOVE_QUOTES.
//
// If you just want to remove the quotes from a string, call this function as
// GetNextField(&pszData, "\"" or "'" or "", REMOVE_QUOTES).
//
// If you call this function as GetNextField(&pszData, "\"" or "'" or "", 0), you will get back the
// entire pszData as the field.
//
{ LPTSTR pszRetPtr, pszPtr; BOOL fWithinQuotes = FALSE, fRemoveQuote; TCHAR chQuote = TEXT('\0');
if (ppszData == NULL || *ppszData == NULL || **ppszData == TEXT('\0')) return NULL;
for (pszRetPtr = pszPtr = *ppszData; *pszPtr; pszPtr = CharNext(pszPtr)) { if (!(dwFlags & IGNORE_QUOTES) && (*pszPtr == TEXT('"') || *pszPtr == TEXT('\''))) { fRemoveQuote = FALSE;
if (*pszPtr == *(pszPtr + 1)) // two consecutive quotes become one
{ pszPtr++;
if (dwFlags & REMOVE_QUOTES) fRemoveQuote = TRUE; else { // if pcszDeLims is '"' or '\'', then *pszPtr == pcszDeLims would
// be TRUE and we would break out of the loop against the design specs;
// to prevent this just continue
continue; } } else if (!fWithinQuotes) { fWithinQuotes = TRUE; chQuote = *pszPtr; // save the quote char
fRemoveQuote = dwFlags & REMOVE_QUOTES; } else { if (*pszPtr == chQuote) // match the correct quote char
{ fWithinQuotes = FALSE; fRemoveQuote = dwFlags & REMOVE_QUOTES; } }
if (fRemoveQuote) { // shift the entire string one char to the left to get rid of the quote char
MoveMemory(pszPtr, pszPtr + 1, StrCbFromCch(StrLen(pszPtr))); } }
// BUGBUG: Is type casting pszPtr to UNALIGNED necessary? -- copied it from ANSIStrChr
// check if pszPtr is pointing to one of the chars in pcszDeLims
if (!fWithinQuotes && StrChr(pcszDeLims, *pszPtr) != NULL) break; }
// NOTE: if fWithinQuotes is TRUE here, then we have an unbalanced quoted string; but we don't care!
// the entire string after the beginning quote becomes the field
if (*pszPtr) // pszPtr is pointing to a char in pcszDeLims
{ *ppszData = CharNext(pszPtr); // save the pointer to the beginning of next field in *ppszData
*pszPtr = TEXT('\0'); // replace the DeLim char with the '\0' char
} else *ppszData = pszPtr; // we have reached the end of the string; next call to this function
// would return NULL
return pszRetPtr; }
// constructs a string using the format specified in pcszFormatString
LPTSTR WINAPIV FormatString(LPCTSTR pcszFormatString, ...) { va_list vaArgs; LPTSTR pszOutString = NULL;
va_start(vaArgs, pcszFormatString); FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_STRING, (LPCVOID) pcszFormatString, 0, 0, (LPTSTR) &pszOutString, 0, &vaArgs); va_end(vaArgs);
return pszOutString; }
/////////////////////////////////////////////////////////////////////////////
// String Conversion Routines
LPWSTR StrAnsiToUnicode(LPWSTR pszTarget, LPCSTR pszSource, UINT cchTarget /*= 0*/) { int cchResult;
cchResult = SHAnsiToUnicode(pszSource, pszTarget, int((cchTarget != 0) ? cchTarget : StrLenA(pszSource)+1)); if (0 == cchResult) return NULL;
return pszTarget; }
LPSTR StrUnicodeToAnsi(LPSTR pszTarget, LPCWSTR pszSource, UINT cchTarget /*= 0*/) { int cchResult;
// NOTE: pass in twice the size of the source for the target in case we have DBCS
// chars. We're assuming that the target buffer is sufficient here.
cchResult = SHUnicodeToAnsi(pszSource, pszTarget, (cchTarget != 0) ? cchTarget : (StrLenW(pszSource)+1) * 2);
if (0 == cchResult) return NULL;
return pszTarget; }
LPTSTR StrSameToSame(LPTSTR pszTarget, LPCTSTR pszSource, UINT cchTarget /*= 0*/) { CopyMemory(pszTarget, pszSource, StrCbFromCch((cchTarget != 0) ? cchTarget : StrLen(pszSource)+1)); return pszTarget; }
|