/// Gets the fret number on a given string
/// @param string String to get the fret number for
/// @return The fret number on the string
wxByte ChordDiagram::GetFretNumber(wxUint32 string) const
{
//------Last Checked------//
// - Jan 15, 2005
wxCHECK(IsValidString(string), 0);
return (m_fretNumberArray[string]);
}
/// Sets the fret number for an existing string in the chordDiagram
/// @param string String to set the fret number for
/// @param fretNumber Fret number to set
/// @return True if the fret number was set, false if not
bool ChordDiagram::SetFretNumber(uint32_t string, uint8_t fretNumber)
{
PTB_CHECK_THAT(IsValidString(string), false);
PTB_CHECK_THAT(IsValidFretNumber(fretNumber), false);
m_fretNumberArray[string] = fretNumber;
return (true);
}
void CUnicodeString::TrimRight(LPCWSTR lpszTargets)
{
ASSERT(IsValidString(lpszTargets));
LPWSTR lpsz = m_Buffer;
LPWSTR lpszLast = NULL;
while(*lpsz != '\0')
{
if(wcschr(lpszTargets, *lpsz) != NULL)
{
if(lpszLast == NULL)
lpszLast = lpsz;
}
else
lpszLast = NULL;
lpsz = _wcsinc(lpsz);
}
if(lpszLast != NULL)
{
// truncate at left-most matching character
*lpszLast = '\0';
m_Length = lpszLast - m_Buffer;
}
}
TBool CX509DomainName::AddSubdomainL(TInt& aPos)
{
TBool res = EFalse;
TInt end = iName->Length();
if (aPos >= end)
{
return res;
}
TPtrC whatsLeft(&(iName->operator[] (aPos)), end - aPos);
TInt subdomainEnd = whatsLeft.FindF(KX509SubdomainSeparator);
if (subdomainEnd == 0)
{
return res;
}
if (subdomainEnd == KErrNotFound)
{
subdomainEnd = end - aPos;
}
TPtrC subdomain(&whatsLeft[0], subdomainEnd);
if (IsValidString(subdomain))
{
REP_APPEND_L(subdomain);
res = ETrue;
}
aPos = aPos + subdomainEnd;
return res;
}
CUnicodeString operator+(const CUnicodeString& s, LPCSTR pstrString)
{
ASSERT(IsValidString(pstrString));
CUnicodeString cus;
cus = s;
cus += pstrString;
return cus;
}
CUnicodeString operator+(LPCWSTR pstrString, const CUnicodeString& s)
{
ASSERT(IsValidString(pstrString));
CUnicodeString cus;
cus = pstrString;
cus += s;
return cus;
}
BOOL operator !=(LPCWSTR s1, const CUnicodeString& s2)
{
ASSERT(IsValidString(s1));
if(wcslen(s1) != wcslen(s2))
return TRUE;
if(!wcscmp(s1, s2))
return FALSE;
return TRUE;
}
// Fret Number Functions
/// Sets the fret number for an existing string in the chordDiagram
/// @param string String to set the fret number for
/// @param fretNumber Fret number to set
/// @return True if the fret number was set, false if not
bool ChordDiagram::SetFretNumber(wxUint32 string, wxByte fretNumber)
{
//------Last Checked------//
// - Jan 15, 2005
wxCHECK(IsValidString(string), false);
wxCHECK(IsValidFretNumber(fretNumber), false);
m_fretNumberArray[string] = fretNumber;
return (true);
}
void CUnicodeString::TrimRight(LPCSTR lpszTargets)
{
ASSERT(IsValidString(lpszTargets));
DWORD dwszLen = strlen(lpszTargets);
LPWSTR lpwsz = (LPWSTR)malloc((dwszLen + 1) * sizeof(WCHAR));
lpwsz[dwszLen] = L'\0';
MultiByteToWideChar(CP_ACP, 0, lpszTargets, dwszLen, lpwsz, dwszLen);
TrimRight(lpwsz);
free(lpwsz);
}
void CUnicodeString::operator += (LPCWSTR pstrString)
{
ASSERT(IsValidString(pstrString));
m_Length += wcslen(pstrString);
LPWSTR pstrNewString = (LPWSTR)malloc((m_Length + 1) * sizeof(WCHAR));
wcscpy(pstrNewString, m_Buffer);
wcscat(pstrNewString, pstrString);
free(m_Buffer);
m_Buffer = pstrNewString;
m_MaximumLength = m_Length;
}
int CUnicodeString::Find(LPCSTR lpszSub, int nStart) const
{
ASSERT(IsValidString(lpszSub));
DWORD dwszLen = strlen(lpszSub);
LPWSTR lpwsz = (LPWSTR)malloc((dwszLen + 1) * sizeof(WCHAR));
lpwsz[dwszLen] = L'\0';
MultiByteToWideChar(CP_ACP, 0, lpszSub, dwszLen, lpwsz, dwszLen);
int iRet = Find(lpwsz, nStart);
free(lpwsz);
return iRet;
}
int CUnicodeString::CollateNoCase(LPCSTR lpsz)
{
ASSERT(IsValidString(lpsz));
DWORD dwszLen = strlen(lpsz);
LPWSTR lpwsz = (LPWSTR)malloc((dwszLen + 1) * sizeof(WCHAR));
lpwsz[dwszLen] = L'\0';
MultiByteToWideChar(CP_ACP, 0, lpsz, dwszLen, lpwsz, dwszLen);
int iRet = wcsicoll(m_Buffer, lpwsz);
free(lpwsz);
return iRet;
}
int CUnicodeString::Insert(int nIndex, LPCSTR pstr)
{
ASSERT(IsValidString(pstr));
DWORD dwszLen = strlen(pstr);
LPWSTR lpwsz = (LPWSTR)malloc((dwszLen + 1) * sizeof(WCHAR));
lpwsz[dwszLen] = L'\0';
MultiByteToWideChar(CP_ACP, 0, pstr, dwszLen, lpwsz, dwszLen);
int iRet = Insert(nIndex, lpwsz);
free(lpwsz);
return iRet;
}
CUnicodeString CUnicodeString::SpanExcluding(LPCSTR lpszCharSet)
{
ASSERT(IsValidString(lpszCharSet));
WCHAR wc[1024];
DWORD dwszLen = strlen(lpszCharSet);
ASSERT(dwszLen < 1024);
wc[dwszLen] = L'\0';
MultiByteToWideChar(CP_ACP, 0, lpszCharSet, dwszLen, wc, dwszLen);
return Left(wcscspn(m_Buffer, wc));
}
void CUnicodeString::operator += (LPCSTR pstrString)
{
ASSERT(IsValidString(pstrString));
USHORT usNewLength = m_Length + strlen(pstrString);
LPWSTR pstrNewString = (LPWSTR)malloc((usNewLength + 1) * sizeof(WCHAR));
wcscpy(pstrNewString, m_Buffer);
MultiByteToWideChar(CP_ACP, 0, pstrString, strlen(pstrString), &pstrNewString[m_Length], usNewLength - m_Length);
free(m_Buffer);
m_Buffer = pstrNewString;
m_Length = usNewLength;
m_MaximumLength = m_Length;
}
bool SizzlingProtect::IsChatExploit( const CCommand &args, int ClientCommandIndex )
{
const char *pChar = V_strstr( args.ArgS(), "%" );
while ( pChar )
{
if ( !IsValidString(&pChar) )
{
return true;
}
pChar = V_strstr( pChar, "%" );
}
return false;
}
const CUnicodeString& CUnicodeString::operator =(LPCSTR pstrString)
{
if(pstrString == NULL)
{
Empty();
return *this;
}
ASSERT(IsValidString(pstrString));
if(m_Buffer)
free(m_Buffer);
InitializeFromString(pstrString);
return *this;
}
int CUnicodeString::Find(LPCWSTR lpszSub, int nStart) const
{
ASSERT(IsValidString(lpszSub));
int nLength = m_Length;
if(nStart > nLength)
return -1;
// find first matching substring
LPWSTR lpsz = wcsstr(m_Buffer + nStart, lpszSub);
// return -1 for not found, distance from beginning otherwise
return(lpsz == NULL) ? -1 : (int)(lpsz - m_Buffer);
}
void CUnicodeString::FormatV(LPCWSTR lpszFormat, va_list argList)
{
ASSERT(IsValidString(lpszFormat));
int nBuf;
WCHAR szBuffer[1024];
nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer), lpszFormat, argList);
if(m_Buffer)
free(m_Buffer);
m_Buffer = (LPWSTR)malloc((nBuf + 1) * sizeof(WCHAR));
m_Length = m_MaximumLength = nBuf;
memcpy(m_Buffer, szBuffer, nBuf * sizeof(WCHAR));
m_Buffer[m_Length] = L'\0';
}
BOOL operator !=(LPCSTR s1, const CUnicodeString& s2)
{
ASSERT(IsValidString(s1));
USHORT usLen = strlen(s1);
if(usLen != wcslen(s2))
return TRUE;
BOOL bRet = TRUE;
LPWSTR ws1 = (LPWSTR)malloc((usLen + 1) * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, s1, usLen, ws1, usLen);
ws1[usLen] = L'\0';
if(!wcscmp(ws1, s2))
bRet = FALSE;
free(ws1);
return bRet;
}
void CUnicodeString::FormatV(LPCSTR lpszFormat, va_list argList)
{
ASSERT(IsValidString(lpszFormat));
int nBuf;
CHAR szBuffer[1024];
nBuf = _vsnprintf(szBuffer, sizeof(szBuffer), lpszFormat, argList);
if(m_Buffer)
free(m_Buffer);
m_Buffer = (LPWSTR)malloc((nBuf + 1) * sizeof(WCHAR));
m_Length = m_MaximumLength = nBuf;
MultiByteToWideChar(CP_ACP, 0, szBuffer, m_Length, m_Buffer, m_Length);
m_Buffer[m_Length] = L'\0';
}
int CUnicodeString::Insert(int nIndex, LPCWSTR pstr)
{
ASSERT(IsValidString(pstr));
ASSERT(nIndex < m_Length);
ASSERT(m_Buffer);
DWORD dwszLen = wcslen(pstr);
int iNewLength = (m_Length + dwszLen + 1) * sizeof(WCHAR);
LPWSTR pstrNew = (LPWSTR)malloc((iNewLength + 1) * sizeof(WCHAR));
ZeroMemory(pstrNew, iNewLength);
wcsncpy(pstrNew, m_Buffer, nIndex);
wcscat(pstrNew, pstr);
wcscat(pstrNew, &m_Buffer[nIndex]);
free(m_Buffer);
m_Buffer = pstrNew;
m_Length = m_MaximumLength = (iNewLength / 2) - 1;
return m_Length;
}
BOOL CUnicodeString::InitializeFromString(LPCSTR pstrString)
{
if(pstrString == NULL)
{
Empty();
return TRUE;
}
ASSERT(IsValidString(pstrString));
m_Length = strlen(pstrString);
m_MaximumLength = m_Length;
m_Buffer = (LPWSTR)malloc((m_Length + 1) * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, pstrString, m_Length, m_Buffer, m_Length);
m_Buffer[m_Length] = L'\0';
if(m_Buffer)
return TRUE;
return FALSE;
}
BOOL CUnicodeString::InitializeFromWideString(LPCWSTR pstrString)
{
if(pstrString == NULL)
{
Empty();
return TRUE;
}
ASSERT(IsValidString(pstrString));
m_Length = wcslen(pstrString);
m_MaximumLength = m_Length;
m_Buffer = (LPWSTR)malloc((m_Length + 1) * sizeof(WCHAR));
wcscpy(m_Buffer, pstrString);
m_Buffer[m_Length] = L'\0';
if(m_Buffer)
return TRUE;
return FALSE;
}
BOOL CSeException::GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext/* = NULL*/)
{
assert(lpszError != NULL && IsValidString(lpszError, nMaxError));
if (pnHelpContext != NULL)
*pnHelpContext = 0;
string strMessage;
GetErrorMessage(strMessage);
if ((UINT)strMessage.size() >= nMaxError) {
lpszError[0] = 0;
return FALSE;
} else {
lstrcpyn(lpszError, strMessage.c_str(), nMaxError);
return TRUE;
}
}
void CUnicodeString::Format(LPCSTR pstrFormat, ...)
{
ASSERT(IsValidString(pstrFormat));
va_list args;
va_start(args, pstrFormat);
int nBuf;
CHAR szBuffer[1024];
nBuf = _vsnprintf(szBuffer, sizeof(szBuffer), pstrFormat, args);
if(m_Buffer)
free(m_Buffer);
m_Buffer = (LPWSTR)malloc((nBuf + 1) * sizeof(WCHAR));
m_Length = m_MaximumLength = nBuf;
MultiByteToWideChar(CP_ACP, 0, szBuffer, nBuf, m_Buffer, m_Length);
m_Buffer[m_Length] = L'\0';
va_end(args);
}
void CUnicodeString::Format(LPCWSTR pstrFormat, ...)
{
ASSERT(IsValidString(pstrFormat));
va_list args;
va_start(args, pstrFormat);
int nBuf;
WCHAR szBuffer[1024];
nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer), pstrFormat, args);
if(m_Buffer)
free(m_Buffer);
m_Buffer = (LPWSTR)malloc((nBuf + 1) * sizeof(WCHAR));
m_Length = m_MaximumLength = nBuf;
memcpy(m_Buffer, szBuffer, nBuf * sizeof(WCHAR));
m_Buffer[m_Length] = L'\0';
va_end(args);
}
void CUnicodeString::TrimLeft(LPCWSTR lpszTargets)
{
ASSERT(IsValidString(lpszTargets));
LPCWSTR lpsz = m_Buffer;
while(*lpsz != '\0')
{
if(wcschr(lpszTargets, *lpsz) == NULL)
break;
lpsz = _wcsinc(lpsz);
}
if(lpsz != m_Buffer)
{
// fix up data and length
int nDataLength = m_Length - (lpsz - m_Buffer);
memmove(m_Buffer, lpsz, (nDataLength+1)*sizeof(WCHAR));
m_Length = nDataLength;
}
}
CUnicodeString CUnicodeString::SpanExcluding(LPCWSTR lpszCharSet)
{
ASSERT(IsValidString(lpszCharSet));
return Left(wcscspn(m_Buffer, lpszCharSet));
}
int CUnicodeString::CollateNoCase(LPCWSTR lpsz)
{
ASSERT(IsValidString(lpsz));
return wcsicoll(m_Buffer, lpsz);
}
