You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

757 lines
25 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
/*****************************************************************************
*
* $/Plasma20/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtStr.cpp
*
***/
#include "../Pch.h"
#pragma hdrstop
/*****************************************************************************
*
* Private data
*
***/
// These random values were generated by the radioactive decay based
// random number generator at www.fourmilab.ch
static dword s_hashValue[] = {
0xc30d2a72, 0x15efaec1, 0xd250c7d9, 0xaf3c60a8,
0x9608ae8f, 0x452c0e11, 0xb6840ffd, 0x3e36c913,
0x2864eace, 0x9b0a17d6, 0x108da74b, 0xf2c479c1,
0x8b4dd597, 0x97199bc0, 0x621f0cce, 0x1658553e,
};
/****************************************************************************
*
* Internal functions
*
***/
//===========================================================================
template<class chartype>
static chartype * IStrDup (const chartype str[]) {
unsigned chars = IStrLen(str) + 1;
chartype * buffer = (chartype *)ALLOC(chars * sizeof(chartype));
IStrCopy(buffer, str, chars);
return buffer;
}
//===========================================================================
template<class chartype>
static chartype * IStrDupLen (const chartype str[], unsigned chars) {
unsigned len = IStrLen(str) + 1;
if (len > chars)
len = chars;
chartype * buffer = (chartype *)ALLOC(len * sizeof(chartype));
IStrCopy(buffer, str, len);
return buffer;
}
//===========================================================================
template<class chartype, class findchartype>
static chartype * IStrChr (chartype * str, findchartype ch, unsigned chars) {
for (; chars--; ++str)
if (*str == ch)
return str;
else if (!*str)
break;
return nil;
}
//===========================================================================
template<class chartype, class findchartype>
static chartype * IStrChrR (chartype * str, findchartype ch) {
chartype * start = str;
for (; *str; ++str)
NULL_STMT;
while (str-- > start)
if (*str == ch)
return str;
return NULL;
}
//===========================================================================
static inline bool ICharUnicodeToUtf8 (char ** dest, const wchar * source[], unsigned destChars) {
unsigned ch = *(*source)++;
bool result = false;
if (ch < 0x80) {
if (destChars >= 1) {
*(*dest)++ = (char)ch;
result = true;
}
}
else if (ch < 0x800) {
if (destChars >= 2) {
*(*dest)++ = (char)(0xc0 | (ch >> 6));
*(*dest)++ = (char)(0x80 | (ch & 0x3f));
result = true;
}
}
else {
if (destChars >= 3) {
*(*dest)++ = (char)(0xe0 | (ch >> 12));
*(*dest)++ = (char)(0x80 | ((ch >> 6) & 0x3f));
*(*dest)++ = (char)(0x80 | (ch & 0x3f));
result = true;
}
}
return result;
}
//===========================================================================
static inline void ICharUtf8ToUnicode (wchar ** dest, const char * source[]) {
unsigned result, remaining;
if ((**source & 0xf0) == 0xe0) {
result = *(*source)++ & 0x0f;
remaining = 2;
}
else if ((**source & 0xe0) == 0xc0) {
result = *(*source)++ & 0x1f;
remaining = 1;
}
else if ((**source & 0x80) == 0x00) {
result = *(*source)++;
remaining = 0;
}
else {
// unsupported code sequence (>0xffff)
++(*source);
return;
}
for (; remaining-- && *source; ++*source)
if ((**source & 0xc0) == 0x80)
result = (result << 6) | (**source & 0x3f);
*(*dest)++ = (wchar)result;
}
//===========================================================================
template<typename chartype>
static unsigned IStrPrintfValidate (chartype * dest, unsigned count, int result) {
if (!count)
return 0;
ASSERT(result <= (int)count);
if ((result < 0) || (result == (int)count)) {
dest[count - 1] = 0;
return count - 1;
}
else
return (unsigned)result;
}
//===========================================================================
template<class chartype>
static int IStrCmp (const chartype str1[], const chartype str2[], unsigned chars) {
for (; chars--; ++str1, ++str2) {
if (*str1 != *str2)
return (*str1 > *str2) ? 1 : -1;
if (!*str1)
return 0;
}
return 0;
}
//===========================================================================
template<class chartype>
static int IStrCmpI (const chartype str1[], const chartype str2[], unsigned chars) {
while (chars--) {
chartype ch1 = CharLowerFast(*str1++);
chartype ch2 = CharLowerFast(*str2++);
if (ch1 != ch2)
return (ch1 > ch2) ? 1 : -1;
if (!ch1)
return 0;
}
return 0;
}
//===========================================================================
template<class chartype>
static void IStrCopy (chartype * dest, const chartype source[], unsigned chars) {
while ((chars > 1) && ((*dest = *source++) != 0)) {
--chars;
++dest;
}
if (chars)
*dest = 0;
}
//===========================================================================
// returns StrLen(dest)
template<class chartype>
static unsigned IStrCopyLen (chartype * dest, const chartype source[], unsigned chars) {
chartype * const start = dest;
while ((chars > 1) && ((*dest = *source++) != 0)) {
--chars;
++dest;
}
if (chars)
*dest = 0;
return dest - start;
}
//===========================================================================
template<class chartype>
static void IStrPack (chartype * dest, const chartype source[], unsigned chars) {
while ((chars > 1) && *dest) {
--chars;
++dest;
}
while ((chars > 1) && ((*dest = *source++) != 0)) {
--chars;
++dest;
}
if (chars)
*dest = 0;
}
//===========================================================================
template<class chartype>
static chartype * IStrStr (chartype source[], const chartype match[]) {
if (!*match)
return source;
for (chartype * curr = source; *curr; ++curr) {
chartype * s1 = curr;
const chartype * s2 = match;
while (*s1 && *s2 && *s1 == *s2)
s1++, s2++;
if (!*s2)
return curr;
}
return nil;
}
//===========================================================================
template<class chartype>
static chartype * IStrStrI (chartype source[], const chartype match[]) {
if (!*match)
return source;
for (chartype * curr = source; *curr; ++curr) {
chartype * s1 = curr;
const chartype * s2 = match;
while (*s1 && *s2 && (CharLowerFast(*s1) == CharLowerFast(*s2)))
s1++, s2++;
if (!*s2)
return curr;
}
return nil;
}
//===========================================================================
template<class chartype>
static unsigned IStrLen (const chartype str[]) {
unsigned chars = 0;
for (; *str++; ++chars)
NULL_STMT;
return chars;
}
//===========================================================================
template<class chartype>
static void IStrLower (chartype * dest, unsigned chars) {
while ((chars > 1) && ((*dest = CharLowerFast(*dest)) != 0)) {
--chars;
++dest;
}
}
//===========================================================================
template<class chartype>
static void IStrLower (chartype * dest, const chartype source[], unsigned chars) {
while ((chars > 1) && ((*dest = CharLowerFast(*source)) != 0)) {
--chars;
++dest;
++source;
}
if (chars)
*dest = 0;
}
//===========================================================================
template<class chartype>
static dword IStrHash (const chartype str[], unsigned chars) {
dword temp0 = 0xE2C15C9D;
dword temp1 = 0x2170A28A;
dword result = 0x325D1EAE;
for (unsigned ch; chars-- && ((ch = (unsigned)*str) != 0); ++str) {
temp0 = (temp0 << 3) ^ ch;
temp1 += s_hashValue[temp0 & 0x0F];
result ^= temp0 + temp1;
}
return result;
}
//===========================================================================
template<class chartype>
static dword IStrHashI (const chartype str[], unsigned chars) {
dword temp0 = 0xE2C15C9D;
dword temp1 = 0x2170A28A;
dword result = 0x325D1EAE;
for (unsigned ch; chars-- && ((ch = (unsigned)*str) != 0); ++str) {
if ((ch >= 'a') && (ch <= 'z'))
ch = ch + 'A' - 'a';
temp0 = (temp0 << 3) ^ ch;
temp1 += s_hashValue[temp0 & 0x0F];
result ^= temp0 + temp1;
}
return result;
}
//===========================================================================
template<class chartype>
static bool IStrTokenize (const chartype * source[], chartype * dest, unsigned chars, const chartype whitespace[], unsigned maxWhitespaceSkipCount) {
// Skip past leading whitespace
bool inQuotes = false;
unsigned whitespaceSkipped = 0;
while (**source && IStrChr(whitespace, **source, (unsigned)-1) && whitespaceSkipped < maxWhitespaceSkipCount) {
inQuotes = (**source == '\"');
++*source;
++whitespaceSkipped;
if (inQuotes)
break;
}
// Copy the token
unsigned offset = 0;
while (**source &&
((inQuotes && (**source != '\"')) || !IStrChr(whitespace, **source, (unsigned)-1))) {
if (offset + 1 < chars)
dest[offset++] = **source;
++*source;
}
// Skip past the terminating quote
if (inQuotes && (**source == '\"'))
++*source;
// Null terminate the destination buffer
if (chars) {
ASSERT(offset < chars);
dest[offset] = 0;
}
// Upon return, 'source' is guaranteed to point to the first character
// following the returned token (and following any closing quotes)
return (offset || inQuotes);
}
//===========================================================================
template<class chartype>
static bool IStrTokenize (const chartype * source[], ARRAY(chartype) * destArray, const chartype whitespace[], unsigned maxWhitespaceSkipCount) {
// Verify that the destination array is empty
ASSERT(!destArray->Count());
// Skip past leading whitespace
bool inQuotes = false;
unsigned whitespaceSkipped = 0;
while (**source && IStrChr(whitespace, **source, (unsigned)-1) && whitespaceSkipped < maxWhitespaceSkipCount) {
inQuotes = (**source == '\"');
++*source;
++whitespaceSkipped;
if (inQuotes)
break;
}
// Copy the token
bool added = false;
while (**source &&
((inQuotes && (**source != '\"')) || !IStrChr(whitespace, **source, (unsigned)-1))) {
destArray->Add(**source);
added = true;
++*source;
}
// Skip past the terminating quote
if (inQuotes && (**source == '\"'))
++*source;
// Null terminate the destination array
destArray->Add(0);
// Upon return, 'source' is guaranteed to point to the first character
// following the returned token (and following any closing quotes)
return (added || inQuotes);
}
/****************************************************************************
*
* Exported functions
*
***/
//===========================================================================
char * StrDup (const char str[]) {
return IStrDup(str);
}
//===========================================================================
wchar * StrDup (const wchar str[]) {
return IStrDup(str);
}
//===========================================================================
char * StrDupLen (const char str[], unsigned chars) {
return IStrDupLen(str, chars);
}
//===========================================================================
wchar * StrDupLen (const wchar str[], unsigned chars) {
return IStrDupLen(str, chars);
}
//============================================================================
wchar * StrDupToUnicode (const char str[]) {
unsigned bytes = StrBytes(str) * sizeof(wchar);
wchar * dst = (wchar*)ALLOC(bytes);
StrToUnicode(dst, str, bytes / sizeof(wchar));
return dst;
}
//============================================================================
char * StrDupToAnsi (const wchar str[]) {
unsigned bytes = StrBytes(str) / sizeof(wchar);
char * dst = (char*)ALLOC(bytes);
StrToAnsi(dst, str, bytes);
return dst;
}
//===========================================================================
unsigned StrBytes (const char str[]) { // includes space for terminator
return (IStrLen(str) + 1) * sizeof(str[0]);
}
//===========================================================================
unsigned StrBytes (const wchar str[]) { // includes space for terminator
return (IStrLen(str) + 1) * sizeof(str[0]);
}
//===========================================================================
char * StrChr (char * str, char ch, unsigned chars) {
return IStrChr(str, ch, chars);
}
//===========================================================================
wchar * StrChr (wchar * str, wchar ch, unsigned chars) {
return IStrChr(str, ch, chars);
}
//===========================================================================
const char * StrChr (const char str[], char ch, unsigned chars) {
return IStrChr(str, ch, chars);
}
//===========================================================================
const wchar * StrChr (const wchar str[], wchar ch, unsigned chars) {
return IStrChr(str, ch, chars);
}
//===========================================================================
char * StrChrR (char * str, char ch) {
return IStrChrR(str, ch);
}
//===========================================================================
wchar * StrChrR (wchar * str, wchar ch) {
return IStrChrR(str, ch);
}
//===========================================================================
const char * StrChrR (const char str[], char ch) {
return IStrChrR(str, ch);
}
//===========================================================================
const wchar * StrChrR (const wchar str[], wchar ch) {
return IStrChrR(str, ch);
}
//===========================================================================
unsigned StrPrintf (char * dest, unsigned count, const char format[], ...) {
va_list argList;
va_start(argList, format);
int result = _vsnprintf((char *)dest, count, (const char *)format, argList);
va_end(argList);
return IStrPrintfValidate(dest, count, result);
}
//===========================================================================
unsigned StrPrintf (wchar * dest, unsigned count, const wchar format[], ...) {
va_list argList;
va_start(argList, format);
int result = _vsnwprintf(dest, count, format, argList);
va_end(argList);
return IStrPrintfValidate(dest, count, result);
}
//===========================================================================
unsigned StrPrintfV (char * dest, unsigned count, const char format[], va_list args) {
int result = _vsnprintf(dest, count, format, args);
return IStrPrintfValidate(dest, count, result);
}
//===========================================================================
unsigned StrPrintfV (wchar * dest, unsigned count, const wchar format[], va_list args) {
int result = _vsnwprintf(dest, count, format, args);
return IStrPrintfValidate(dest, count, result);
}
//===========================================================================
int StrCmp (const char str1[], const char str2[], unsigned chars) {
return IStrCmp(str1, str2, chars);
}
//===========================================================================
int StrCmp (const wchar str1[], const wchar str2[], unsigned chars) {
return IStrCmp(str1, str2, chars);
}
//===========================================================================
int StrCmpI (const char str1[], const char str2[], unsigned chars) {
return IStrCmpI(str1, str2, chars);
}
//===========================================================================
int StrCmpI (const wchar str1[], const wchar str2[], unsigned chars) {
return IStrCmpI(str1, str2, chars);
}
//===========================================================================
void StrCopy (char * dest, const char source[], unsigned chars) {
IStrCopy(dest, source, chars);
}
//===========================================================================
void StrCopy (wchar * dest, const wchar source[], unsigned chars) {
IStrCopy(dest, source, chars);
}
//===========================================================================
unsigned StrCopyLen (char * dest, const char source[], unsigned chars) {
return IStrCopyLen(dest, source, chars);
}
//===========================================================================
unsigned StrCopyLen (wchar * dest, const wchar source[], unsigned chars) {
return IStrCopyLen(dest, source, chars);
}
//===========================================================================
void StrPack (char * dest, const char source[], unsigned chars) {
IStrPack(dest, source, chars);
}
//===========================================================================
void StrPack (wchar * dest, const wchar source[], unsigned chars) {
IStrPack(dest, source, chars);
}
//===========================================================================
char * StrStr (char * source, const char match[]) {
return IStrStr(source, match);
}
//===========================================================================
const char * StrStr (const char source[], const char match[]) {
return IStrStr<const char>(source, match);
}
//===========================================================================
wchar * StrStr (wchar * source, const wchar match[]) {
return IStrStr(source, match);
}
//===========================================================================
const wchar * StrStr (const wchar source[], const wchar match[]) {
return IStrStr<const wchar>(source, match);
}
//===========================================================================
char * StrStrI (char * source, const char match[]) {
return IStrStrI(source, match);
}
//===========================================================================
const char * StrStrI (const char source[], const char match[]) {
return IStrStrI<const char>(source, match);
}
//===========================================================================
wchar * StrStrI (wchar * source, const wchar match[]) {
return IStrStrI(source, match);
}
//===========================================================================
const wchar * StrStrI (const wchar source[], const wchar match[]) {
return IStrStrI<const wchar>(source, match);
}
//===========================================================================
unsigned StrLen (const char str[]) {
return IStrLen(str);
}
//===========================================================================
unsigned StrLen (const wchar str[]) {
return IStrLen(str);
}
//===========================================================================
unsigned StrUnicodeToUtf8 (char * dest, const wchar source[], unsigned destChars) {
char * destCurr = dest;
char * destTerm = dest + destChars;
while (*source && (destCurr + 1 < destTerm))
if (!ICharUnicodeToUtf8(&destCurr, &source, destTerm - destCurr - 1))
break;
if (destCurr < destTerm)
*destCurr = 0;
return destCurr - dest; // dest chars not including null terminator
}
//===========================================================================
unsigned StrUtf8ToUnicode (wchar * dest, const char source[], unsigned destChars) {
wchar * destCurr = dest;
wchar * destTerm = dest + destChars;
while (*source && (destCurr + 1 < destTerm))
ICharUtf8ToUnicode(&destCurr, &source);
if (destCurr < destTerm)
*destCurr = 0;
return destCurr - dest; // dest chars not including null terminator
}
//============================================================================
float StrToFloat (const char source[], const char ** endptr) {
return (float) strtod(source, const_cast<char **>(endptr));
}
//===========================================================================
float StrToFloat (const wchar source[], const wchar ** endptr) {
return (float) wcstod(source, const_cast<wchar **>(endptr));
}
//===========================================================================
int StrToInt (const char source[], const char ** endptr) {
return strtol(source, const_cast<char **>(endptr), 0);
}
//===========================================================================
int StrToInt (const wchar source[], const wchar ** endptr) {
return wcstol(source, const_cast<wchar **>(endptr), 0);
}
//===========================================================================
unsigned StrToUnsigned (char source[], char ** endptr, int radix) {
return strtoul(source, const_cast<char **>(endptr), radix);
}
//===========================================================================
unsigned StrToUnsigned (wchar source[], wchar ** endptr, int radix) {
return wcstoul(source, const_cast<wchar **>(endptr), radix);
}
//===========================================================================
unsigned StrToUnsigned (const char source[], const char ** endptr, int radix) {
return strtoul(source, const_cast<char **>(endptr), radix);
}
//===========================================================================
unsigned StrToUnsigned (const wchar source[], const wchar ** endptr, int radix) {
return wcstoul(source, const_cast<wchar **>(endptr), radix);
}
//===========================================================================
void StrLower (char * dest, unsigned chars) {
IStrLower(dest, chars);
}
//===========================================================================
void StrLower (wchar * dest, unsigned chars) {
IStrLower(dest, chars);
}
//===========================================================================
void StrLower (char * dest, const char source[], unsigned chars) {
IStrLower(dest, source, chars);
}
//===========================================================================
void StrLower (wchar * dest, const wchar source[], unsigned chars) {
IStrLower(dest, source, chars);
}
//============================================================================
dword StrHash (const char str[], unsigned chars) {
return IStrHash(str, chars);
}
//===========================================================================
dword StrHash (const wchar str[], unsigned chars) {
return IStrHash(str, chars);
}
//===========================================================================
dword StrHashI (const char str[], unsigned chars) {
return IStrHashI(str, chars);
}
//===========================================================================
dword StrHashI (const wchar str[], unsigned chars) {
return IStrHashI(str, chars);
}
//===========================================================================
bool StrTokenize (const char * source[], char * dest, unsigned chars, const char whitespace[], unsigned maxWhitespaceSkipCount) {
return IStrTokenize(source, dest, chars, whitespace, maxWhitespaceSkipCount);
}
//===========================================================================
bool StrTokenize (const wchar * source[], wchar * dest, unsigned chars, const wchar whitespace[], unsigned maxWhitespaceSkipCount) {
return IStrTokenize(source, dest, chars, whitespace, maxWhitespaceSkipCount);
}
//===========================================================================
bool StrTokenize (const char * source[], ARRAY(char) * destArray, const char whitespace[], unsigned maxWhitespaceSkipCount) {
return IStrTokenize(source, destArray, whitespace, maxWhitespaceSkipCount);
}
//===========================================================================
bool StrTokenize (const wchar * source[], ARRAY(wchar) * destArray, const wchar whitespace[], unsigned maxWhitespaceSkipCount) {
return IStrTokenize(source, destArray, whitespace, maxWhitespaceSkipCount);
}