aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-15 14:08:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/misc/sstring.cpp
kervala 8d27acc654 Changed: Minor changes
2013-09-06 15:00:35 +02:00

1808 lines
45 KiB
C++
Raw Blame History

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdmisc.h"
#include "nel/misc/sstring.h"
namespace NLMISC
{
CSString CSString::strtok( const char *separators,
bool useSmartExtensions, // if true then match brackets etc (and refine with following args)
bool useAngleBrace, // - treat '<' and '>' as brackets
bool useSlashStringEscape, // - treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape) // - treat """" as '"')
{
if (useSmartExtensions)
{
CSString token;
// split to the first non empty token, or until the this string is empty
while (!empty() && token.empty())
token = splitToOneOfSeparators(separators,true,useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape,true);
return token;
}
uint i, j;
CSString result;
// skip leading junk
for (i=0;i<size();++i)
{
// look for the next character in the 'separator' character list supplied
for (j=0;separators[j] && (*this)[i]!=separators[j];++j)
{}
// if not found then we're at end of leading junk
if (!separators[j])
break;
}
// copy out everything up to the next separator character
for (;i<size();++i)
{
// look for the next character in the 'separator' character list supplied
for (j=0;separators[j] && (*this)[i]!=separators[j];++j)
{}
// if not found then we're at end of text chunk
if (separators[j])
break;
result+=(*this)[i];
}
// skip trailing junk
for (;i<size();++i)
{
// look for the next character in the 'separator' character list supplied
for (j=0;separators[j] && (*this)[i]!=separators[j];++j)
{}
// if not found then we're at end of leading junk
if (!separators[j])
break;
}
// delete the treated bit from this string
(*this)=substr(i);
return result;
}
CSString CSString::splitToOneOfSeparators( const CSString& separators,
bool truncateThis,
bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape, // treat """" as '"'
bool truncateSeparatorCharacter, // if true tail begins after separator char
bool splitStringAtBrackets)
{
// iterate over our string
uint32 i;
for (i=0;i<size();++i)
{
char thisChar=(*this)[i];
// if we've found the separator character then all's cool so break out of the loop
if (separators.contains(thisChar))
break;
// if we have a bracket or quote of any type then match to it's matching bracket, quote or whatever
if (isOpeningDelimiter(thisChar,useAngleBrace) || isStringDelimiter(thisChar))
{
if (i != 0)
{
// we are not at beginning of the string, delimiter is considered as separator
if (splitStringAtBrackets)
break;
}
uint32 j=i;
i=findMatchingDelimiterPos(useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape,i);
// if there was a problem then break here
if (j==i)
break;
continue;
}
}
// build the return string
CSString result=left(i);
// if need be truncate '*this' before returning
if (truncateThis)
{
if (truncateSeparatorCharacter && separators.contains((*this)[i]))
++i;
*this=leftCrop(i);
}
return result;
}
CSString CSString::splitToLineComment(bool truncateThis, bool useSlashStringEscape)
{
bool quoteOpen= false;
bool escape= false;
for (uint32 i=0;i<size();++i)
{
// if we're escaped then accept the next character blindly
if (escape)
{
escape= false;
continue;
}
// do we have an escape?
if (useSlashStringEscape && operator[](i)=='\\')
{
escape= true;
}
// do we have a quote (it is not escaped by definition here)
else if (operator[](i)=='\"')
{
quoteOpen= !quoteOpen;
}
// do we have a comment (not in quotes)
else if (!quoteOpen && i<size()-1 && operator[](i)=='/' && operator[](i+1)=='/')
{
// we found a comment so strip string down here
if (truncateThis)
{
CSString result= left(i);
*this= leftCrop(i);
return result;
}
else
{
return left(i);
}
}
}
if (truncateThis)
{
CSString result= *this;
clear();
return result;
}
else
{
return *this;
}
}
bool CSString::isValidText()
{
// setup a handy static lookup table for differentiating valid and invalid text characters
static bool* tbl=NULL;
if (tbl==NULL)
{
tbl= new bool[256];
for (uint32 i=0;i<256;++i)
{
tbl[i]= ((i>32) || isWhiteSpace((char)i));
}
}
// scan the string for binary characters
uint32 i=(uint32)size();
// while (i && !tbl[i-1])
// {
// i--;
// }
while (i--)
{
if (!tbl[(uint8)operator[](i)])
{
nldebug("string is not valid text due to character: %u at index: %u",(uint8)operator[](i),i);
return false;
}
}
// no binary characters found so return true
return true;
}
bool CSString::isValidFileName() const
{
if (empty())
return false;
if ((*this)[0]=='"')
{
if (!isDelimitedMonoBlock(false,false,false))
return false;
// iterate from size-2 to 1
for (uint32 i=(uint32)size()-1; --i;)
if (!isValidFileNameChar((*this)[i]) && (*this)[i]!=' ')
return false;
}
else
{
// iterate from size-1 to 0
for (uint32 i=(uint32)size(); i--;)
if (!isValidFileNameChar((*this)[i]))
return false;
}
return true;
}
bool CSString::isValidUnquotedFileName() const
{
return (CSString('\"'+*this+'\"')).isValidFileName();
}
bool CSString::isValidKeyword() const
{
if (empty())
return false;
if (!isValidKeywordFirstChar((*this)[0]))
return false;
// iterate from size-1 to 1
for (uint32 i=(uint32)size(); --i;)
if (!isValidKeywordChar((*this)[i]))
return false;
return true;
}
uint32 CSString::findMatchingDelimiterPos( bool useAngleBrace,
bool useSlashStringEscape,
bool useRepeatQuoteStringEscape,
uint32 startPos ) const
{
uint32 i=startPos;
char openingDelimiter= (*this)[i];
if (isOpeningDelimiter(openingDelimiter,useAngleBrace))
{
// deal with (), [], {} or <> type delimiters
while (i<size())
{
++i;
if(isMatchingDelimiter(openingDelimiter,(*this)[i]))
{
// this is it! we've found the matching quote so we're done
break;
}
if (isOpeningDelimiter((*this)[i],useAngleBrace) || isStringDelimiter((*this)[i]))
{
uint32 j=i;
i=findMatchingDelimiterPos(useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape,i);
if (j==i)
return startPos;
continue;
}
if (isClosingDelimiter((*this)[i],useAngleBrace))
{
// we've found a closing delimiter that doesn't match our opening delimiter so give up
return startPos;
}
}
}
else if (isStringDelimiter(openingDelimiter))
{
// deal with "..." or '...' type delimiters
while (i<size())
{
++i;
if ((*this)[i]==openingDelimiter)
{
if (useRepeatQuoteStringEscape && (*this)[i+1]==openingDelimiter)
{
// we've found a "" pair and we're treating it as \" equivalent so skip an extra character
++i;
continue;
}
else
{
// this is it! we've found the matching quote so we're done
break;
}
}
if (useSlashStringEscape && (*this)[i]=='\\')
{
// we've found a '\' character so skip the next character, whatever it is
++i;
continue;
}
}
}
return i;
}
CSString CSString::matchDelimiters( bool truncateThis,
bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape) // treat """" as '"'
{
// skip white space
uint32 startPos;
for (startPos=0;startPos<size() && isWhiteSpace((*this)[startPos]);++startPos) {}
// locate the matching brace
uint32 matchPos=findMatchingDelimiterPos(useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape,startPos);
// if not found give up
if (matchPos>=size())
{
return CSString();
}
// build the return string
CSString result=left(matchPos+1);
// if need be truncate '*this' before returning
if (truncateThis)
{
*this=leftCrop(matchPos+1);
}
return result;
}
CSString CSString::splitToStringSeparator(
char separator,
bool truncateThis,
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape, // treat """" as '"'
bool truncateSeparatorCharacter) // if true tail begins after separator char
{
// iterate over our string
uint32 i;
for (i=0;i<size();++i)
{
char thisChar=(*this)[i];
// if we've found the separator character then all's cool so break out of the loop
if (thisChar==separator)
break;
// if we have a bracket or quote of any type then match to it's matching bracket, quote or whatever
if (isStringDelimiter(thisChar))
{
uint32 j=i;
i=findMatchingDelimiterPos(false,useSlashStringEscape,useRepeatQuoteStringEscape,i);
// if there was a problem then break here
if (j==i)
break;
continue;
}
}
// build the return string
CSString result=left(i);
// if need be truncate '*this' before returning
if (truncateThis)
{
if (truncateSeparatorCharacter && separator==(*this)[i])
++i;
*this=leftCrop(i);
}
return result;
}
CSString CSString::splitToSeparator( char separator,
bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape) const // treat """" as '"'
{
return const_cast<CSString*>(this)->splitToSeparator(separator,false,useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape,false);
}
CSString CSString::splitToSeparator( char separator,
bool truncateThis,
bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape, // treat """" as '"'
bool truncateSeparatorCharacter) // if true tail begins after separator char
{
// iterate over our string
uint32 i;
for (i=0;i<size();++i)
{
char thisChar=(*this)[i];
// if we've found the separator character then all's cool so break out of the loop
if (thisChar==separator)
break;
// if we have a bracket or quote of any type then match to it's matching bracket, quote or whatever
if (isOpeningDelimiter(thisChar,useAngleBrace) || isStringDelimiter(thisChar))
{
uint32 j=i;
i=findMatchingDelimiterPos(useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape,i);
// if there was a problem then break here
if (j==i)
break;
continue;
}
}
// build the return string
CSString result=left(i);
// if need be truncate '*this' before returning
if (truncateThis)
{
if (truncateSeparatorCharacter && separator==(*this)[i])
++i;
*this=leftCrop(i);
}
return result;
}
CSString CSString::splitToOneOfSeparators( const CSString& separators,
bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape) const // treat """" as '"'
{
return const_cast<CSString*>(this)->splitToOneOfSeparators(separators,false,useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape,false);
}
bool CSString::isDelimitedMonoBlock( bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape // treat """" as '"'
) const
{
if (empty())
return false;
uint32 matchPos=findMatchingDelimiterPos(useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape);
return (matchPos==size()-1 && isMatchingDelimiter((*this)[0],(*this)[matchPos]));
}
CSString CSString::stripBlockDelimiters( bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape // treat """" as '"'
) const
{
if (isDelimitedMonoBlock(useAngleBrace,useSlashStringEscape,useRepeatQuoteStringEscape))
{
return substr(1,size()-2);
}
else
{
return *this;
}
}
bool CSString::splitWords(CVectorSString& result) const
{
CSString s=strip();
while(!s.empty())
{
uint32 pre=(uint32)s.size();
result.push_back(s.firstWord(true));
uint32 post=(uint32)s.size();
if (post>=pre)
return false;
}
return true;
}
bool CSString::splitWordOrWords(CVectorSString& result,bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
CSString s=*this;
while(!s.empty())
{
uint32 pre=(uint32)s.size();
result.push_back(s.firstWordOrWords(true,useSlashStringEscape,useRepeatQuoteStringEscape));
uint32 post=(uint32)s.size();
if (post>=pre)
return false;
}
return true;
}
bool CSString::splitLines(CVectorSString& result) const
{
CSString s=*this;
// make sure we deal with '\n\r' style carriage returns cleanly
if (s.contains('\r'))
s=s.replace("\r","");
uint32 it=0;
uint32 len= (uint32)s.size();
while(it<len)
{
// extract the text up to the next '\n'character
result.push_back(s.splitToWithIterator('\n',it));
// skip the '\n' character
++it;
}
return true;
}
bool CSString::splitBySeparator( char separator, CVectorSString& result,
bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape, // treat """" as '"'
bool skipBlankEntries // dont add blank entries to the result vector
) const
{
CSString s=*this;
while(!s.empty())
{
uint32 pre=(uint32)s.size();
result.push_back(s.splitToSeparator(separator,true,useAngleBrace,useSlashStringEscape,
useRepeatQuoteStringEscape,true));
if (skipBlankEntries && result.back().empty())
result.pop_back();
uint32 post=(uint32)s.size();
if (post>=pre)
return false;
}
return true;
}
bool CSString::splitByOneOfSeparators( const CSString& separators, CVectorSString& result,
bool useAngleBrace, // treat '<' and '>' as brackets
bool useSlashStringEscape, // treat '\' as escape char so "\"" == '"'
bool useRepeatQuoteStringEscape,// treat """" as '"'
bool retainSeparators, // have the separators turn up in the result vector
bool skipBlankEntries // dont add blank entries to the result vector
) const
{
CSString s=*this;
while (!s.empty() && skipBlankEntries && !retainSeparators && separators.contains(s[0]))
s= s.leftCrop(1);
while(!s.empty())
{
uint32 pre=(uint32)s.size();
result.push_back(s.splitToOneOfSeparators( separators,true,useAngleBrace,useSlashStringEscape,
useRepeatQuoteStringEscape,!retainSeparators ));
// if we failed to extract a string segment then we must be looking at a separator
if (result.back().empty())
{
if (skipBlankEntries && result.back().empty())
result.pop_back();
if (!s.empty())
{
if (retainSeparators)
result.back()=s[0];
s=s.leftCrop(1);
}
}
uint32 post=(uint32)s.size();
if (post>=pre)
return false;
}
return true;
}
const CSString& CSString::join(const std::vector<CSString>& strings, const CSString& separator)
{
for (uint32 i=0;i<strings.size();++i)
{
// add in separators before all but the first string
if (!empty())
operator+=(separator);
// append next string
operator+=(strings[i]);
}
// return a ref to ourselves
return *this;
}
const CSString& CSString::join(const std::vector<CSString>& strings, char separator)
{
for (uint32 i=0;i<strings.size();++i)
{
// add in separators before all but the first string
if (!empty())
operator+=(separator);
// append next string
operator+=(strings[i]);
}
// return a ref to ourselves
return *this;
}
CSString CSString::strip() const
{
CSString result;
int i,j;
for (j=(int)size()-1; j>=0 && isWhiteSpace((*this)[j]); --j) {}
for (i=0; i<j && isWhiteSpace((*this)[i]); ++i) {}
result=substr(i,j-i+1);
return result;
}
CSString CSString::leftStrip() const
{
CSString result;
int i,j=(int)size()-1;
for (i=0; i<j && isWhiteSpace((*this)[i]); ++i) {}
result=substr(i,j-i+1);
return result;
}
CSString CSString::rightStrip() const
{
CSString result;
int i=0,j;
for (j=(int)size()-1; j>=0 && isWhiteSpace((*this)[j]); --j) {}
result=substr(i,j-i+1);
return result;
}
CSString CSString::toUpper() const
{
CSString result;
std::string::const_iterator it;
for (it=begin();it!=end();++it)
{
char c=(*it);
if (c>='a' && c<='z')
c^=('a'^'A');
result+=c;
}
return result;
}
CSString CSString::toLower() const
{
CSString result;
std::string::const_iterator it;
for (it=begin();it!=end();++it)
{
char c=(*it);
if (c>='A' && c<='Z')
c^=('a'^'A');
result+=c;
}
return result;
}
CSString CSString::splitTo(char c) const
{
uint i;
CSString result;
for (i=0;i<size() && (*this)[i]!=c;++i)
result+=(*this)[i];
return result;
}
CSString CSString::splitTo(char c,bool truncateThis,bool absorbSeparator)
{
uint i;
CSString result;
for (i=0;i<size() && (*this)[i]!=c;++i)
result+=(*this)[i];
// remove the result string from the input string if so desired
if (truncateThis)
{
if (absorbSeparator)
++i;
if (i<size())
(*this)=substr(i);
else
clear();
}
return result;
}
CSString CSString::splitTo(const char *s,bool truncateThis)
{
uint i;
CSString result;
for (i=0;i<size();++i)
{
// perform a quick string compare
int j;
for (j=0;s[j]!=0 && s[j]==(&((*this)[i]))[j];++j)
{
}
// if string compare matched then return result so far
if (s[j]==0)
{
// remove the result string from the input string if so desired
if (truncateThis)
{
if (i+1<size())
(*this)=substr(i+1); // +1 to skip the separator character
else
clear();
}
return result;
}
result+=(*this)[i];
}
// we didn't find the separator string so we're returning a copy of the whole string
if (truncateThis)
clear();
return result;
}
CSString CSString::splitFrom(char c) const
{
CSString result;
std::string::const_iterator it;
for (it=begin();it!=end() && *it!=c;++it)
{}
if (it!=end())
{
++it;
for (;it!=end();++it)
result+=*it;
}
return result;
}
CSString CSString::splitFrom(const char *s) const
{
uint i;
CSString result;
for (i=0;i<size();++i)
{
// perform a quick string compare
uint j;
for (j=0;i+j<size() && s[j]!=0 && s[j]==(*this)[i+j];++j)
{
}
// if string compare matched then build and return a result
if (s[j]==0)
{
result=substr(i+j);
return result;
}
}
return result;
}
CSString CSString::firstWord(bool truncateThis)
{
// idiot test to avoid accessing index 0 in empty strings
if (empty())
return CSString();
CSString result;
uint i=0;
// skip white space
for (i=0;i<size() && isWhiteSpace((*this)[i]);++i)
{}
if ( ((*this)[i]>='A' && (*this)[i]<='Z') || ((*this)[i]>='a' && (*this)[i]<='z') ||
((*this)[i]>='0' && (*this)[i]<='9') || (*this)[i]=='_')
{
// copy out an alpha-numeric string
for (;i<(*this).size() &&
( ((*this)[i]>='A' && (*this)[i]<='Z') || ((*this)[i]>='a' && (*this)[i]<='z') ||
((*this)[i]>='0' && (*this)[i]<='9') || (*this)[i]=='_')
;++i)
result+=(*this)[i];
}
else
{
// just take the first character of the input
result=(*this)[i];
++i;
}
// remove the result string from the input string if so desired
if (truncateThis)
{
if (i<size())
(*this)=substr(i);
else
clear();
}
return result;
}
CSString CSString::firstWordConst() const
{
return const_cast<CSString *>(this)->firstWord();
}
CSString CSString::tailFromFirstWord() const
{
CSString hold=*this;
hold.firstWord(true);
return hold;
}
unsigned CSString::countWords() const
{
unsigned count=0;
CSString hold=strip();
while (!hold.empty())
{
hold=hold.tailFromFirstWord().strip();
++count;
}
return count;
}
CSString CSString::word(uint32 idx) const
{
CSString hold=strip();
for (unsigned count=0;count<idx;++count)
hold=hold.tailFromFirstWord().strip();
return hold.firstWord();
}
CSString CSString::firstWordOrWords(bool truncateThis,bool useSlashStringEscape,bool useRepeatQuoteStringEscape)
{
uint32 startPos;
for (startPos=0;startPos<size();++startPos)
if (!isWhiteSpace((*this)[startPos]))
break;
if (isStringDelimiter((*this)[startPos]))
{
uint32 endPos= findMatchingDelimiterPos(false,useSlashStringEscape,useRepeatQuoteStringEscape,startPos);
CSString result=substr(startPos,endPos-startPos+1);
result=result.unquote(useSlashStringEscape,useRepeatQuoteStringEscape);
if (truncateThis)
*this=leftCrop(endPos+1);
return result;
}
else
return firstWord(truncateThis);
}
CSString CSString::firstWordOrWordsConst(bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
return const_cast<CSString *>(this)->firstWordOrWords(useSlashStringEscape,useRepeatQuoteStringEscape);
}
CSString CSString::tailFromFirstWordOrWords(bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
CSString hold=*this;
hold.firstWordOrWords(true,useSlashStringEscape,useRepeatQuoteStringEscape);
return hold;
}
unsigned CSString::countWordOrWords(bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
unsigned count=0;
CSString hold=strip();
while (!hold.empty())
{
hold=hold.tailFromFirstWordOrWords(useSlashStringEscape,useRepeatQuoteStringEscape).strip();
++count;
}
return count;
}
CSString CSString::wordOrWords(uint32 idx,bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
CSString hold=strip();
for (unsigned count=0;count<idx;++count)
hold=hold.tailFromFirstWordOrWords(useSlashStringEscape,useRepeatQuoteStringEscape).strip();
return hold.firstWordOrWords(useSlashStringEscape,useRepeatQuoteStringEscape);
}
CSString CSString::firstLine(bool truncateThis)
{
return splitTo('\n',truncateThis);
}
CSString CSString::firstLineConst() const
{
return const_cast<CSString *>(this)->firstLine();
}
CSString CSString::tailFromFirstLine() const
{
CSString hold=*this;
hold.firstLine(true);
return hold;
}
unsigned CSString::countLines() const
{
unsigned count=0;
CSString hold=strip();
while (!hold.empty())
{
hold=hold.tailFromFirstLine().strip();
++count;
}
return count;
}
CSString CSString::line(uint32 idx) const
{
CSString hold=strip();
for (unsigned count=0;count<idx;++count)
hold= hold.tailFromFirstLine().strip();
return hold.firstLine();
}
CSString CSString::quote(bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
CSString result;
result+='\"';
for (uint32 i=0;i<size();++i)
{
switch ((*this)[i])
{
case '\"':
if (useSlashStringEscape)
{
result+="\\\"";
continue;
}
else if (useRepeatQuoteStringEscape)
{
result+="\"\"";
continue;
}
break;
case '\\': if (useSlashStringEscape) { result+="\\\\"; continue; } break;
case '\a': if (useSlashStringEscape) { result+="\\a"; continue; } break;
case '\b': if (useSlashStringEscape) { result+="\\b"; continue; } break;
case '\f': if (useSlashStringEscape) { result+="\\f"; continue; } break;
case '\n': if (useSlashStringEscape) { result+="\\n"; continue; } break;
case '\r': if (useSlashStringEscape) { result+="\\r"; continue; } break;
case '\t': if (useSlashStringEscape) { result+="\\t"; continue; } break;
case '\v': if (useSlashStringEscape) { result+="\\v"; continue; } break;
break;
default:
if ((signed char)(*this)[i]<32 && useSlashStringEscape)
{
result+=NLMISC::toString("\\x%02x",(unsigned char)(*this)[i]);
continue;
}
break;
}
result+=(*this)[i];
}
result+='\"';
return result;
}
CSString CSString::quoteIfNotQuoted( bool useSlashStringEscape, bool useRepeatQuoteStringEscape ) const
{
if (empty()||(*this)[0]!='\"'||!isDelimitedMonoBlock(false,useSlashStringEscape,useRepeatQuoteStringEscape))
return quote(useSlashStringEscape,useRepeatQuoteStringEscape);
return *this;
}
CSString CSString::quoteIfNotAtomic( bool useSlashStringEscape, bool useRepeatQuoteStringEscape ) const
{
if (empty())
return "\"\"";
uint32 i=1;
if (((*this)[0]>='0' && (*this)[0]<='9')||(*this)[0]=='-')
{
for (i=1;i<size();++i)
if ((*this)[i]<'0' || (*this)[i]>'9')
break;
}
else if ( CSString::isValidKeywordFirstChar((*this)[0]) )
{
for (i=1;i<size();++i)
if (!CSString::isValidFileNameChar((*this)[i]))
break;
}
else if ((*this)[0]=='\"' && isDelimitedMonoBlock(false,useSlashStringEscape,useRepeatQuoteStringEscape))
{
i=(uint32)size();
}
if (i!=size())
return quote(useSlashStringEscape,useRepeatQuoteStringEscape);
return *this;
}
CSString CSString::unquote(bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
CSString result=stripBlockDelimiters(false,useSlashStringEscape,useRepeatQuoteStringEscape);
uint32 i,j;
for (i=0,j=0;i<result.size();++i,++j)
{
if (useSlashStringEscape && result[i]=='\\')
{
++i;
if (i<result.size())
{
switch(result[i])
{
case 'a': result[i]='\a'; break;
case 'b': result[i]='\b'; break;
case 'f': result[i]='\f'; break;
case 'n': result[i]='\n'; break;
case 'r': result[i]='\r'; break;
case 't': result[i]='\t'; break;
case 'v': result[i]='\v'; break;
case '0':
case '1':
case '2':
case '3':
{
char hold=result[i]-'0';
++i;
if (i<result.size() && result[i]>='0' && result[i]<='7')
{
hold=8*hold+(result[i]-'0');
++i;
if (i<result.size() && result[i]>='0' && result[i]<='7')
{
hold=8*hold+(result[i]-'0');
++i;
}
}
result[j]=hold;
continue;
}
break;
case '4':
case '5':
case '6':
case '7':
{
char hold=result[i]-'0';
++i;
if (i<result.size() && result[i]>='0' && result[i]<='7')
{
hold=8*hold+(result[i]-'0');
++i;
}
result[j]=hold;
continue;
}
break;
case 'x':
if (i+1<result.size() && isHexDigit(result[i+1]))
{
char hold=convertHexDigit(result[i+1]);
i+=2;
if (i<result.size() && isHexDigit(result[i]))
{
hold=16*hold+convertHexDigit(result[i]);
++i;
}
result[j]=hold;
continue;
}
break;
}
}
}
else if (useRepeatQuoteStringEscape && (i+1<result.size()) && result[i]=='\"' && result[i+1]=='\"')
++i;
if (i<result.size())
result[j]=result[i];
}
if (i!=j)
result.resize(j);
return result;
}
CSString CSString::unquoteIfQuoted(bool useSlashStringEscape,bool useRepeatQuoteStringEscape) const
{
if (isQuoted())
return unquote(useSlashStringEscape,useRepeatQuoteStringEscape);
else
return *this;
}
CSString CSString::encodeXML(bool isParameter) const
{
CSString result;
for (uint32 i=0;i<size();++i)
{
unsigned char c= (*this)[i];
switch(c)
{
// special xml characters
case '\"': result+="&quot;"; continue;
case '&': result+="&amp;"; continue;
case '<': result+="&lt;"; continue;
case '>': result+="&gt;"; continue;
// characters that are not allowed inside a parameter block
case '\n':
case '\r':
case '\t':
if (!isParameter) { result+=c; continue; }
}
// hex coding for extended characters
if (c<32 || c>127)
{
result+="&#x";
result+= ((c>>4)>=10? 'A'+(c>>4)-10: '0'+(c>>4));
result+= ((c&15)>=10? 'A'+(c&15)-10: '0'+(c&15));
result+=";";
continue;
}
// all the special cases are catered for... treat this as a normal character
result+=c;
}
return result;
}
CSString CSString::decodeXML() const
{
CSString result;
for (uint32 i=0;i<size();++i)
{
breakable
{
if((*this)[i]=='&')
{
// special xml characters
if (substr(i+1,5)=="quot;") { i+=5; result+='\"'; continue; }
if (substr(i+1,4)=="amp;") { i+=4; result+='&'; continue; }
if (substr(i+1,3)=="lt;") { i+=3; result+='<'; continue; }
if (substr(i+1,3)=="gt;") { i+=3; result+='>'; continue; }
// hex coding for extended characters
if ((size()-i)>=5)
{
if ((*this)[i+1]!='#') break;
if (((*this)[i+2]|('a'-'A'))!='x') break;
// setup j to point at the first character following "&#x"[0-9|a-f]*
uint32 j; for (j=i+3;j<size();++j) if (!isHexDigit((*this)[j])) break;
// make sure that at least 1 hex character was found
if (j==i+3) break;
// make sure have the terminating ';' to complete the token: "&#x"[0-9|a-f]*";"
if (j>=size() || (*this)[j]!=';') break;
// make sure that the value we have is only one or 2 hex digits
if (j>=i+6) nlwarning("Truncating extended char code '%s",(substr(i,j-i+1)+"' => using "+substr(j-2,2)).c_str());
// convert the 1 or 2 last hex digits to a char value
char c=0;
if (j>=i+5)
{
// if we have 2 or more digits then grab the high digit
c+= convertHexDigit( (*this)[j-2] )*16;
}
c+= convertHexDigit( (*this)[j-1] );
// append our new character to the result string
result+=c;
// move 'i' forward to point at the ';' .. the for(...) will increment i to point to next char
i=j;
continue;
}
}
}
// all the special cases are catered for... treat this as a normal character
result+=(*this)[i];
}
return result;
}
bool CSString::isEncodedXML() const
{
bool foundToken= false;
for (uint32 i=(uint32)size();i--;)
{
switch((*this)[i])
{
// decoded special xml characters
case '\"':
case '<':
case '>':
case '&':
return false;
case ';':
// encoded special xml characters
if (i>=5 && substr(i-5,5)=="&quot") { foundToken= true; i-=5; break; }
if (i>=4 && substr(i-4,4)=="&amp") { foundToken= true; i-=4; break; }
if (i>=3 && substr(i-3,3)=="&lt") { foundToken= true; i-=3; break; }
if (i>=3 && substr(i-3,3)=="&gt") { foundToken= true; i-=3; break; }
// hex coding for extended characters
if (i>=3 && isHexDigit((*this)[i-1]))
{
uint32 j,k;
// locate the start of a potential hex string
for (j=i;j--;)
if ((*this)[j]=='&')
break;
// make sure that at least 5 chars were found for: &#x0;
if (i-j<4) continue;
// make sure we have '&#x' at the start
if ((*this)[j]!='&') continue;
if ((*this)[j+1]!='#') continue;
if ((*this)[j+2]!='x') continue;
// ensure that the remainder between the leading '&#x' and trailing ';' are hex digits
for (k=j+3;k<i;++k)
if (!isHexDigit((*this)[k]))
break;
if (k!=i) continue;
// skip the characters that were matched - i now refs the opening '&'
i=j;
foundToken= true;
break;
}
}
}
return foundToken;
}
bool CSString::isXMLCompatible(bool isParameter) const
{
for (uint32 i=(uint32)size();i--;)
{
switch((*this)[i])
{
// decoded special xml characters
case '\"':
case '<':
case '>':
case '&':
return false;
case ';':
// encoded special xml characters
if (i>=5 && substr(i-5,5)=="&quot") { i-=5; continue; }
if (i>=4 && substr(i-4,4)=="&amp") { i-=4; continue; }
if (i>=3 && substr(i-3,3)=="&lt") { i-=3; continue; }
if (i>=3 && substr(i-3,3)=="&gt") { i-=3; continue; }
// hex coding for extended characters
if (i>=3 && isHexDigit((*this)[i-1]))
{
uint32 j,k;
// locate the start of a potential hex string
for (j=i;j--;)
if ((*this)[j]=='&')
break;
// make sure that at least 5 chars were found for: &#x0;
if (i-j<4) continue;
// make sure we have '&#x' at the start
if ((*this)[j]!='&') continue;
if ((*this)[j+1]!='#') continue;
if ((*this)[j+2]!='x') continue;
// ensure that the remainder between the leading '&#x' and trailing ';' are hex digits
for (k=j+3;k<i;++k)
if (!isHexDigit((*this)[k]))
break;
if (k!=i) continue;
// skip the characters that were matched - i now refs the opening '&'
i=j;
continue;
}
// characters that are not allowed inside a parameter block
case '\n':
case '\r':
case '\t':
if (!isParameter) continue;
}
if ((uint8)((*this)[i])>127 || (uint8)((*this))[i]<32)
return false;
}
return true;
}
CSString CSString::replace(const char *toFind,const char *replacement) const
{
// just bypass the problems that can cause a crash...
if (toFind==NULL || *toFind==0)
return *this;
std::string::size_type i,j;
CSString result;
for (i=0;i<size();)
{
// string compare toFind against (*this)+i ...
for (j=0;toFind[j];++j)
if ((*this)[i+j]!=toFind[j])
break;
// if strings were identical then j reffers to ASCIIZ terminator at end of 'toFind'
if (toFind[j]==0)
{
if (replacement!=NULL)
result+=replacement;
i+=j;
}
else
{
result+=(*this)[i];
++i;
}
}
return result;
}
std::string::size_type CSString::find(const char *toFind, std::string::size_type startLocation) const
{
// const char *constStr = c_str();
// just bypass the problems that can cause a crash...
if (toFind==NULL || *toFind==0 || startLocation>=size())
return std::string::npos;
std::string::size_type i,j;
for (i=startLocation;i<size();++i)
{
// string compare toFind against (*this)+i ...
for (j=0;toFind[j];++j)
if ((i+j>=size()) || (*this)[i+j]!=toFind[j])
break;
// if strings were identical then we're done
if (toFind[j]==0)
return i;
}
return std::string::npos;
}
/// Find index at which a sub-string starts (case NOT sensitive) - if sub-string not found then returns string::npos
std::string::size_type CSString::findNS(const char *toFind, std::string::size_type startLocation) const
{
const char *constStr = c_str();
// just bypass the problems that can cause a crash...
if (toFind==NULL || *toFind==0 || startLocation>=size())
return std::string::npos;
std::string::size_type i,j;
for (i=startLocation;i<size();++i)
{
// string compare toFind against (*this)+i ...
for (j=0;toFind[j];++j)
if ((i+j>=size()) || tolower(constStr[i+j])!=tolower(toFind[j]))
break;
// if strings were identical then we're done
if (toFind[j]==0)
return i;
}
return std::string::npos;
}
bool CSString::contains(const char *toFind) const
{
return find(toFind)!=std::string::npos;
}
bool CSString::contains(int character) const
{
for (const_iterator it=begin();it!=end();++it)
if ((*it)==character)
return true;
return false;
}
static const uint32 MaxUint32= ~0u;
static const uint32 MaxUint32LastDigit= MaxUint32-(MaxUint32/10)*10;
static const uint32 MaxUint32PreLastDigit= (MaxUint32/10);
static const uint32 MaxNegSint32= ~0u/2+1;
static const uint32 MaxNegSint32LastDigit= MaxNegSint32-(MaxNegSint32/10)*10;
static const uint32 MaxNegSint32PreLastDigit= (MaxNegSint32/10);
static const uint32 MaxPosSint32= ~0u/2;
static const uint32 MaxPosSint32LastDigit= MaxPosSint32-(MaxPosSint32/10)*10;
static const uint32 MaxPosSint32PreLastDigit= (MaxPosSint32/10);
int CSString::atoi() const
{
if (empty())
return 0;
bool neg= false;
uint32 result;
switch (*begin())
{
case '+': result=0; break;
case '-': result=0; neg=true; break;
case '0': result=0; break;
case '1': result=1; break;
case '2': result=2; break;
case '3': result=3; break;
case '4': result=4; break;
case '5': result=5; break;
case '6': result=6; break;
case '7': result=7; break;
case '8': result=8; break;
case '9': result=9; break;
default: return 0;
}
for (const_iterator it=begin()+1;it!=end();++it)
{
uint32 offset;
switch (*it)
{
case '0': offset=0; break;
case '1': offset=1; break;
case '2': offset=2; break;
case '3': offset=3; break;
case '4': offset=4; break;
case '5': offset=5; break;
case '6': offset=6; break;
case '7': offset=7; break;
case '8': offset=8; break;
case '9': offset=9; break;
default: return 0;
}
if (!neg)
{
if (result>=MaxUint32PreLastDigit/*~0u/10*/)
{
if (result>MaxUint32PreLastDigit || offset>MaxUint32LastDigit)
return 0;
}
}
else
{
if (result>=MaxNegSint32PreLastDigit /*~0u/20+1*/)
{
if (result>MaxNegSint32PreLastDigit || offset>MaxNegSint32LastDigit)
return 0;
}
}
result=10*result+offset;
}
return neg? -(sint32)result: (sint32)result;
}
sint32 CSString::atosi() const
{
if (empty())
return 0;
bool neg= false;
uint32 result;
switch (*begin())
{
case '+': result=0; break;
case '-': result=0; neg=true; break;
case '0': result=0; break;
case '1': result=1; break;
case '2': result=2; break;
case '3': result=3; break;
case '4': result=4; break;
case '5': result=5; break;
case '6': result=6; break;
case '7': result=7; break;
case '8': result=8; break;
case '9': result=9; break;
default: return 0;
}
for (const_iterator it=begin()+1;it!=end();++it)
{
uint32 offset;
switch (*it)
{
case '0': offset=0; break;
case '1': offset=1; break;
case '2': offset=2; break;
case '3': offset=3; break;
case '4': offset=4; break;
case '5': offset=5; break;
case '6': offset=6; break;
case '7': offset=7; break;
case '8': offset=8; break;
case '9': offset=9; break;
default: return 0;
}
if (result>=MaxPosSint32PreLastDigit /*~0u/20*/)
{
if (result>MaxPosSint32PreLastDigit || offset>(neg?MaxNegSint32LastDigit:MaxPosSint32LastDigit))
return 0;
}
result=10*result+offset;
}
return neg? -(sint32)result: (sint32)result;
}
uint32 CSString::atoui() const
{
uint32 result=0;
for (const_iterator it=begin();it!=end();++it)
{
uint32 offset;
switch (*it)
{
case '0': offset=0; break;
case '1': offset=1; break;
case '2': offset=2; break;
case '3': offset=3; break;
case '4': offset=4; break;
case '5': offset=5; break;
case '6': offset=6; break;
case '7': offset=7; break;
case '8': offset=8; break;
case '9': offset=9; break;
default: return 0;
}
if (result>=MaxUint32PreLastDigit/*~0u/10*/)
{
if (result>MaxUint32PreLastDigit || offset>MaxUint32LastDigit)
return 0;
}
result=10*result+offset;
}
return result;
}
static const uint64 MaxUint64= (uint64)0-(uint64)1;
static const uint64 MaxUint64LastDigit= MaxUint64-(MaxUint64/10)*10;
static const uint64 MaxUint64PreLastDigit= (MaxUint64/10);
static const uint64 MaxNegSint64= ((uint64)0-(uint64)1)/2+1;
static const uint64 MaxNegSint64LastDigit= MaxNegSint64-(MaxNegSint64/10)*10;
static const uint64 MaxNegSint64PreLastDigit= (MaxNegSint64/10);
static const uint64 MaxPosSint64= ((uint64)0-(uint64)1)/2;
static const uint64 MaxPosSint64LastDigit= MaxPosSint64-(MaxPosSint64/10)*10;
static const uint64 MaxPosSint64PreLastDigit= (MaxPosSint64/10);
sint64 CSString::atoi64() const
{
if (empty())
return 0;
bool neg= false;
uint64 result;
switch (*begin())
{
case '+': result=0; break;
case '-': result=0; neg=true; break;
case '0': result=0; break;
case '1': result=1; break;
case '2': result=2; break;
case '3': result=3; break;
case '4': result=4; break;
case '5': result=5; break;
case '6': result=6; break;
case '7': result=7; break;
case '8': result=8; break;
case '9': result=9; break;
default: return 0;
}
for (const_iterator it=begin()+1;it!=end();++it)
{
uint64 offset;
switch (*it)
{
case '0': offset=0; break;
case '1': offset=1; break;
case '2': offset=2; break;
case '3': offset=3; break;
case '4': offset=4; break;
case '5': offset=5; break;
case '6': offset=6; break;
case '7': offset=7; break;
case '8': offset=8; break;
case '9': offset=9; break;
default: return 0;
}
if (!neg)
{
if (result>=MaxUint64PreLastDigit/*~0u/10*/)
{
if (result>MaxUint64PreLastDigit || offset>MaxUint64LastDigit)
return 0;
}
}
else
{
if (result>=MaxNegSint64PreLastDigit /*~0u/20+1*/)
{
if (result>MaxNegSint64PreLastDigit || offset>MaxNegSint64LastDigit)
return 0;
}
}
result=10*result+offset;
}
return neg? -(sint64)result: (sint64)result;
}
sint64 CSString::atosi64() const
{
if (empty())
return 0;
bool neg= false;
uint64 result;
switch (*begin())
{
case '+': result=0; break;
case '-': result=0; neg=true; break;
case '0': result=0; break;
case '1': result=1; break;
case '2': result=2; break;
case '3': result=3; break;
case '4': result=4; break;
case '5': result=5; break;
case '6': result=6; break;
case '7': result=7; break;
case '8': result=8; break;
case '9': result=9; break;
default: return 0;
}
for (const_iterator it=begin()+1;it!=end();++it)
{
uint64 offset;
switch (*it)
{
case '0': offset=0; break;
case '1': offset=1; break;
case '2': offset=2; break;
case '3': offset=3; break;
case '4': offset=4; break;
case '5': offset=5; break;
case '6': offset=6; break;
case '7': offset=7; break;
case '8': offset=8; break;
case '9': offset=9; break;
default: return 0;
}
if (result>=MaxPosSint64PreLastDigit /*~0u/20*/)
{
if (result>MaxPosSint64PreLastDigit || offset>(neg?MaxNegSint64LastDigit:MaxPosSint64LastDigit))
return 0;
}
result=10*result+offset;
}
return neg? -(sint64)result: (sint64)result;
}
uint64 CSString::atoui64() const
{
uint64 result=0;
for (const_iterator it=begin();it!=end();++it)
{
uint64 offset;
switch (*it)
{
case '0': offset=0; break;
case '1': offset=1; break;
case '2': offset=2; break;
case '3': offset=3; break;
case '4': offset=4; break;
case '5': offset=5; break;
case '6': offset=6; break;
case '7': offset=7; break;
case '8': offset=8; break;
case '9': offset=9; break;
default: return 0;
}
if (result>=MaxUint64PreLastDigit/*~0u/10*/)
{
if (result>MaxUint64PreLastDigit || offset>MaxUint64LastDigit)
return 0;
}
result=10*result+offset;
}
return result;
}
double CSString::atof() const
{
return ::atof(c_str());
}
bool CSString::readFromFile(const CSString& fileName)
{
FILE* file;
file=fopen(fileName.c_str(),"rb");
if (file==NULL)
{
clear();
// There was previously a warning displayed here but that was incorrect as it is defined that refaFromFile returns an empty result if the file is not found
// nlwarning("Failed to open file for reading: %s",fileName.c_str());
return false;
}
resize(NLMISC::CFile::getFileSize(file));
uint32 bytesRead=(uint32)fread(const_cast<char*>(data()),1,size(),file);
fclose(file);
if (bytesRead!=size())
{
resize(bytesRead);
nlwarning("Failed to read file contents (requested %u bytes but fread returned %u) for file:%s",size(),bytesRead,fileName.c_str());
return false;
}
return true;
}
bool CSString::writeToFile(const CSString& fileName) const
{
FILE* file;
file=fopen(fileName.c_str(),"wb");
if (file==NULL)
{
nlwarning("Failed to open file for writing: %s",fileName.c_str());
return false;
}
uint32 recordsWritten=(uint32)fwrite(const_cast<char*>(data()),size(),1,file);
fclose(file);
if (recordsWritten!=1)
{
nlwarning("Failed to write file contents (requested %u bytes but fwrite returned %u) for file:%s",size(),recordsWritten,fileName.c_str());
return false;
}
nldebug("CSSWTF Wrote %u bytes to file %s",size(),fileName.c_str());
return true;
}
bool CSString::writeToFileIfDifferent(const CSString& fileName) const
{
// if the file exists...
if (NLMISC::CFile::fileExists(fileName))
{
// the file exists so check it's the right size
if (NLMISC::CFile::getFileSize(fileName)==size())
{
// the file is the right size so read its data from disk...
CSString hold;
hold.readFromFile(fileName);
// check whether data read from file and our own data are identical
if (hold.size()==size() && memcmp(&hold[0],&(*this)[0],size())==0)
{
// data is identical so drop out
nldebug("CSSWTF Request to write data to file %s IGNORED because file already contains correct data",fileName.c_str());
return true;
}
}
}
// the file didn't already exist or content
return writeToFile(fileName);
}
} // namespace NLMISC
Reference in a new issue View git blame Copy permalink