2012-05-29 13:31:11 +00:00
// 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 ;
}
2013-09-06 13:00:35 +00:00
uint i , j ;
2012-05-29 13:31:11 +00:00
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 + = " " " ; continue ;
case ' & ' : result + = " & " ; continue ;
case ' < ' : result + = " < " ; continue ;
case ' > ' : result + = " > " ; 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 ) = = " " " ) { foundToken = true ; i - = 5 ; break ; }
if ( i > = 4 & & substr ( i - 4 , 4 ) = = " & " ) { foundToken = true ; i - = 4 ; break ; }
if ( i > = 3 & & substr ( i - 3 , 3 ) = = " < " ) { foundToken = true ; i - = 3 ; break ; }
if ( i > = 3 & & substr ( i - 3 , 3 ) = = " > " ) { 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: �
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 ) = = " " " ) { i - = 5 ; continue ; }
if ( i > = 4 & & substr ( i - 4 , 4 ) = = " & " ) { i - = 4 ; continue ; }
if ( i > = 3 & & substr ( i - 3 , 3 ) = = " < " ) { i - = 3 ; continue ; }
if ( i > = 3 & & substr ( i - 3 , 3 ) = = " > " ) { 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: �
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
{
2015-01-13 18:47:14 +00:00
double val ;
NLMISC : : fromString ( * this , val ) ;
return val ;
2012-05-29 13:31:11 +00:00
}
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