wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
6381b45f6d
gecko/xpcom/string/nsStringObsolete.cpp

1054 lines
28 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsString.h"
/**
* nsTString obsolete API support
*/
#if MOZ_STRING_WITH_OBSOLETE_API
#include "nsDependentString.h"
#include "nsDependentSubstring.h"
#include "nsReadableUtils.h"
#include "nsCRT.h"
#include "nsUTF8Utils.h"
#include "prdtoa.h"
/* ***** BEGIN RICKG BLOCK *****
*
* NOTE: This section of code was extracted from rickg's bufferRoutines.h file.
* For the most part it remains unmodified. We want to eliminate (or at
* least clean up) this code at some point. If you find the formatting
* in this section somewhat inconsistent, don't blame me! ;-)
*/
// avoid STDC's tolower since it may do weird things with non-ASCII bytes
inline char
ascii_tolower(char aChar)
{
if (aChar >= 'A' && aChar <= 'Z')
return aChar + ('a' - 'A');
return aChar;
}
//-----------------------------------------------------------------------------
//
// This set of methods is used to search a buffer looking for a char.
//
/**
* This methods cans the given buffer for the given char
*
* @update gess 02/17/00
* @param aDest is the buffer to be searched
* @param aDestLength is the size (in char-units, not bytes) of the buffer
* @param anOffset is the start pos to begin searching
* @param aChar is the target character we're looking for
* @param aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.
* @return index of pos if found, else -1 (kNotFound)
*/
static int32_t
FindChar1(const char* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {
if(anOffset < 0)
anOffset=0;
if(aCount < 0)
aCount = (int32_t)aDestLength;
if((aChar < 256) && (0 < aDestLength) && ((uint32_t)anOffset < aDestLength)) {
//We'll only search if the given aChar is within the normal ascii a range,
//(Since this string is definitely within the ascii range).
if(0<aCount) {
const char* left= aDest+anOffset;
const char* last= left+aCount;
const char* max = aDest+aDestLength;
const char* end = (last<max) ? last : max;
int32_t theMax = end-left;
if(0<theMax) {
unsigned char theChar = (unsigned char) aChar;
const char* result=(const char*)memchr(left, (int)theChar, theMax);
if(result)
return result-aDest;
}
}
}
return kNotFound;
}
/**
* This methods cans the given buffer for the given char
*
* @update gess 3/25/98
* @param aDest is the buffer to be searched
* @param aDestLength is the size (in char-units, not bytes) of the buffer
* @param anOffset is the start pos to begin searching
* @param aChar is the target character we're looking for
* @param aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.
* @return index of pos if found, else -1 (kNotFound)
*/
static int32_t
FindChar2(const char16_t* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {
if(anOffset < 0)
anOffset=0;
if(aCount < 0)
aCount = (int32_t)aDestLength;
if((0<aDestLength) && ((uint32_t)anOffset < aDestLength)) {
if(0<aCount) {
const char16_t* root = aDest;
const char16_t* left = root+anOffset;
const char16_t* last = left+aCount;
const char16_t* max = root+aDestLength;
const char16_t* end = (last<max) ? last : max;
while(left<end){
if(*left==aChar)
return (left-root);
++left;
}
}
}
return kNotFound;
}
/**
* This methods cans the given buffer (in reverse) for the given char
*
* @update gess 02/17/00
* @param aDest is the buffer to be searched
* @param aDestLength is the size (in char-units, not bytes) of the buffer
* @param anOffset is the start pos to begin searching
* @param aChar is the target character we're looking for
* @param aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.
* @return index of pos if found, else -1 (kNotFound)
*/
static int32_t
RFindChar1(const char* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {
if(anOffset < 0)
anOffset=(int32_t)aDestLength-1;
if(aCount < 0)
aCount = int32_t(aDestLength);
if((aChar<256) && (0 < aDestLength) && ((uint32_t)anOffset < aDestLength)) {
//We'll only search if the given aChar is within the normal ascii a range,
//(Since this string is definitely within the ascii range).
if(0 < aCount) {
const char* rightmost = aDest + anOffset;
const char* min = rightmost - aCount + 1;
const char* leftmost = (min<aDest) ? aDest: min;
char theChar=(char)aChar;
while(leftmost <= rightmost){
if((*rightmost) == theChar)
return rightmost - aDest;
--rightmost;
}
}
}
return kNotFound;
}
/**
* This methods cans the given buffer for the given char
*
* @update gess 3/25/98
* @param aDest is the buffer to be searched
* @param aDestLength is the size (in char-units, not bytes) of the buffer
* @param anOffset is the start pos to begin searching
* @param aChar is the target character we're looking for
* @param aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.
* @return index of pos if found, else -1 (kNotFound)
*/
static int32_t
RFindChar2(const char16_t* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {
if(anOffset < 0)
anOffset=(int32_t)aDestLength-1;
if(aCount < 0)
aCount = int32_t(aDestLength);
if((0 < aDestLength) && ((uint32_t)anOffset < aDestLength)) {
if(0 < aCount) {
const char16_t* root = aDest;
const char16_t* rightmost = root + anOffset;
const char16_t* min = rightmost - aCount + 1;
const char16_t* leftmost = (min<root) ? root: min;
while(leftmost <= rightmost){
if((*rightmost) == aChar)
return rightmost - root;
--rightmost;
}
}
}
return kNotFound;
}
//-----------------------------------------------------------------------------
//
// This set of methods is used to compare one buffer onto another. The
// functions are differentiated by the size of source and dest character
// sizes. WARNING: Your destination buffer MUST be big enough to hold all the
// source bytes. We don't validate these ranges here (this should be done in
// higher level routines).
//
/**
* This method compares the data in one buffer with another
* @update gess 01/04/99
* @param aStr1 is the first buffer to be compared
* @param aStr2 is the 2nd buffer to be compared
* @param aCount is the number of chars to compare
* @param aIgnoreCase tells us whether to use a case-sensitive comparison
* @return -1,0,1 depending on <,==,>
*/
static
#ifdef __SUNPRO_CC
inline
#endif /* __SUNPRO_CC */
int32_t
Compare1To1(const char* aStr1,const char* aStr2,uint32_t aCount,bool aIgnoreCase) {
int32_t result=0;
if(aIgnoreCase)
result=int32_t(PL_strncasecmp(aStr1, aStr2, aCount));
else
result=nsCharTraits<char>::compare(aStr1,aStr2,aCount);
// alien comparisons may return out-of-bound answers
// instead of the -1, 0, 1 expected by most clients
if ( result < -1 )
result = -1;
else if ( result > 1 )
result = 1;
return result;
}
/**
* This method compares the data in one buffer with another
* @update gess 01/04/99
* @param aStr1 is the first buffer to be compared
* @param aStr2 is the 2nd buffer to be compared
* @param aCount is the number of chars to compare
* @param aIgnoreCase tells us whether to use a case-sensitive comparison
* @return -1,0,1 depending on <,==,>
*/
static
#ifdef __SUNPRO_CC
inline
#endif /* __SUNPRO_CC */
int32_t
Compare2To2(const char16_t* aStr1,const char16_t* aStr2,uint32_t aCount){
int32_t result;
if ( aStr1 && aStr2 )
result = nsCharTraits<char16_t>::compare(aStr1, aStr2, aCount);
// The following cases are rare and survivable caller errors.
// Two null pointers are equal, but any string, even 0 length
// is greater than a null pointer. It might not really matter,
// but we pick something reasonable anyway.
else if ( !aStr1 && !aStr2 )
result = 0;
else if ( aStr1 )
result = 1;
else
result = -1;
// alien comparisons may give answers outside the -1, 0, 1 expected by callers
if ( result < -1 )
result = -1;
else if ( result > 1 )
result = 1;
return result;
}
/**
* This method compares the data in one buffer with another
* @update gess 01/04/99
* @param aStr1 is the first buffer to be compared
* @param aStr2 is the 2nd buffer to be compared
* @param aCount is the number of chars to compare
* @param aIgnoreCase tells us whether to use a case-sensitive comparison
* @return -1,0,1 depending on <,==,>
*/
static
#ifdef __SUNPRO_CC
inline
#endif /* __SUNPRO_CC */
int32_t
Compare2To1(const char16_t* aStr1,const char* aStr2,uint32_t aCount,bool aIgnoreCase){
const char16_t* s1 = aStr1;
const char *s2 = aStr2;
if (aStr1 && aStr2) {
if (aCount != 0) {
do {
char16_t c1 = *s1++;
char16_t c2 = char16_t((unsigned char)*s2++);
if (c1 != c2) {
#ifdef DEBUG
// we won't warn on c1>=128 (the 2-byte value) because often
// it is just fine to compare an constant, ascii value (i.e. "body")
// against some non-ascii value (i.e. a unicode string that
// was downloaded from a web page)
if (aIgnoreCase && c2>=128)
NS_WARNING("got a non-ASCII string, but we can't do an accurate case conversion!");
#endif
// can't do case conversion on characters out of our range
if (aIgnoreCase && c1<128 && c2<128) {
c1 = ascii_tolower(char(c1));
c2 = ascii_tolower(char(c2));
if (c1 == c2) continue;
}
if (c1 < c2) return -1;
return 1;
}
} while (--aCount);
}
}
return 0;
}
/**
* This method compares the data in one buffer with another
* @update gess 01/04/99
* @param aStr1 is the first buffer to be compared
* @param aStr2 is the 2nd buffer to be compared
* @param aCount is the number of chars to compare
* @param aIgnoreCase tells us whether to use a case-sensitive comparison
* @return -1,0,1 depending on <,==,>
*/
inline int32_t
Compare1To2(const char* aStr1,const char16_t* aStr2,uint32_t aCount,bool aIgnoreCase){
return Compare2To1(aStr2, aStr1, aCount, aIgnoreCase) * -1;
}
//-----------------------------------------------------------------------------
//
// This set of methods is used compress char sequences in a buffer...
//
/**
* This method compresses duplicate runs of a given char from the given buffer
*
* @update rickg 03.23.2000
* @param aString is the buffer to be manipulated
* @param aLength is the length of the buffer
* @param aSet tells us which chars to compress from given buffer
* @param aEliminateLeading tells us whether to strip chars from the start of the buffer
* @param aEliminateTrailing tells us whether to strip chars from the start of the buffer
* @return the new length of the given buffer
*/
static int32_t
CompressChars1(char* aString,uint32_t aLength,const char* aSet){
char* from = aString;
char* end = aString + aLength;
char* to = from;
//this code converts /n, /t, /r into normal space ' ';
//it also compresses runs of whitespace down to a single char...
if(aSet && aString && (0 < aLength)){
uint32_t aSetLen=strlen(aSet);
while (from < end) {
char theChar = *from++;
*to++=theChar; //always copy this char...
if((kNotFound!=FindChar1(aSet,aSetLen,0,theChar,aSetLen))){
while (from < end) {
theChar = *from++;
if(kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen)){
*to++ = theChar;
break;
}
} //while
} //if
} //if
*to = 0;
}
return to - aString;
}
/**
* This method compresses duplicate runs of a given char from the given buffer
*
* @update rickg 03.23.2000
* @param aString is the buffer to be manipulated
* @param aLength is the length of the buffer
* @param aSet tells us which chars to compress from given buffer
* @param aEliminateLeading tells us whether to strip chars from the start of the buffer
* @param aEliminateTrailing tells us whether to strip chars from the start of the buffer
* @return the new length of the given buffer
*/
static int32_t
CompressChars2(char16_t* aString,uint32_t aLength,const char* aSet) {
char16_t* from = aString;
char16_t* end = from + aLength;
char16_t* to = from;
//this code converts /n, /t, /r into normal space ' ';
//it also compresses runs of whitespace down to a single char...
if(aSet && aString && (0 < aLength)){
uint32_t aSetLen=strlen(aSet);
while (from < end) {
char16_t theChar = *from++;
*to++=theChar; //always copy this char...
if((theChar<256) && (kNotFound!=FindChar1(aSet,aSetLen,0,theChar,aSetLen))){
while (from < end) {
theChar = *from++;
if(kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen)){
*to++ = theChar;
break;
}
} //while
} //if
} //if
*to = 0;
}
return to - (char16_t*)aString;
}
/**
* This method strips chars in a given set from the given buffer
*
* @update gess 01/04/99
* @param aString is the buffer to be manipulated
* @param aLength is the length of the buffer
* @param aSet tells us which chars to compress from given buffer
* @param aEliminateLeading tells us whether to strip chars from the start of the buffer
* @param aEliminateTrailing tells us whether to strip chars from the start of the buffer
* @return the new length of the given buffer
*/
static int32_t
StripChars1(char* aString,uint32_t aLength,const char* aSet) {
// XXX(darin): this code should defer writing until necessary.
char* to = aString;
char* from = aString-1;
char* end = aString + aLength;
if(aSet && aString && (0 < aLength)){
uint32_t aSetLen=strlen(aSet);
while (++from < end) {
char theChar = *from;
if(kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen)){
*to++ = theChar;
}
}
*to = 0;
}
return to - (char*)aString;
}
/**
* This method strips chars in a given set from the given buffer
*
* @update gess 01/04/99
* @param aString is the buffer to be manipulated
* @param aLength is the length of the buffer
* @param aSet tells us which chars to compress from given buffer
* @param aEliminateLeading tells us whether to strip chars from the start of the buffer
* @param aEliminateTrailing tells us whether to strip chars from the start of the buffer
* @return the new length of the given buffer
*/
static int32_t
StripChars2(char16_t* aString,uint32_t aLength,const char* aSet) {
// XXX(darin): this code should defer writing until necessary.
char16_t* to = aString;
char16_t* from = aString-1;
char16_t* end = to + aLength;
if(aSet && aString && (0 < aLength)){
uint32_t aSetLen=strlen(aSet);
while (++from < end) {
char16_t theChar = *from;
//Note the test for ascii range below. If you have a real unicode char,
//and you're searching for chars in the (given) ascii string, there's no
//point in doing the real search since it's out of the ascii range.
if((255<theChar) || (kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen))){
*to++ = theChar;
}
}
*to = 0;
}
return to - (char16_t*)aString;
}
/* ***** END RICKG BLOCK ***** */
static const char* kWhitespace="\f\t\r\n ";
// This function is used to implement FindCharInSet and friends
template <class CharT>
#ifndef __SUNPRO_CC
static
#endif /* !__SUNPRO_CC */
CharT
GetFindInSetFilter( const CharT* set)
{
CharT filter = ~CharT(0); // All bits set
while (*set) {
filter &= ~(*set);
++set;
}
return filter;
}
// This template class is used by our code to access rickg's buffer routines.
template <class CharT> struct nsBufferRoutines {};
template <>
struct nsBufferRoutines<char>
{
static
int32_t compare( const char* a, const char* b, uint32_t max, bool ic )
{
return Compare1To1(a, b, max, ic);
}
static
int32_t compare( const char* a, const char16_t* b, uint32_t max, bool ic )
{
return Compare1To2(a, b, max, ic);
}
static
int32_t find_char( const char* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )
{
return FindChar1(s, max, offset, c, count);
}
static
int32_t rfind_char( const char* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )
{
return RFindChar1(s, max, offset, c, count);
}
static
char get_find_in_set_filter( const char* set )
{
return GetFindInSetFilter(set);
}
static
int32_t strip_chars( char* s, uint32_t len, const char* set )
{
return StripChars1(s, len, set);
}
static
int32_t compress_chars( char* s, uint32_t len, const char* set )
{
return CompressChars1(s, len, set);
}
};
template <>
struct nsBufferRoutines<char16_t>
{
static
int32_t compare( const char16_t* a, const char16_t* b, uint32_t max, bool ic )
{
NS_ASSERTION(!ic, "no case-insensitive compare here");
return Compare2To2(a, b, max);
}
static
int32_t compare( const char16_t* a, const char* b, uint32_t max, bool ic )
{
return Compare2To1(a, b, max, ic);
}
static
int32_t find_char( const char16_t* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )
{
return FindChar2(s, max, offset, c, count);
}
static
int32_t rfind_char( const char16_t* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )
{
return RFindChar2(s, max, offset, c, count);
}
static
char16_t get_find_in_set_filter( const char16_t* set )
{
return GetFindInSetFilter(set);
}
static
char16_t get_find_in_set_filter( const char* set )
{
return (~char16_t(0)^~char(0)) | GetFindInSetFilter(set);
}
static
int32_t strip_chars( char16_t* s, uint32_t max, const char* set )
{
return StripChars2(s, max, set);
}
static
int32_t compress_chars( char16_t* s, uint32_t len, const char* set )
{
return CompressChars2(s, len, set);
}
};
//-----------------------------------------------------------------------------
template <class L, class R>
#ifndef __SUNPRO_CC
static
#endif /* !__SUNPRO_CC */
int32_t
FindSubstring( const L* big, uint32_t bigLen,
const R* little, uint32_t littleLen,
bool ignoreCase )
{
if (littleLen > bigLen)
return kNotFound;
int32_t i, max = int32_t(bigLen - littleLen);
for (i=0; i<=max; ++i, ++big)
{
if (nsBufferRoutines<L>::compare(big, little, littleLen, ignoreCase) == 0)
return i;
}
return kNotFound;
}
template <class L, class R>
#ifndef __SUNPRO_CC
static
#endif /* !__SUNPRO_CC */
int32_t
RFindSubstring( const L* big, uint32_t bigLen,
const R* little, uint32_t littleLen,
bool ignoreCase )
{
if (littleLen > bigLen)
return kNotFound;
int32_t i, max = int32_t(bigLen - littleLen);
const L* iter = big + max;
for (i=max; iter >= big; --i, --iter)
{
if (nsBufferRoutines<L>::compare(iter, little, littleLen, ignoreCase) == 0)
return i;
}
return kNotFound;
}
template <class CharT, class SetCharT>
#ifndef __SUNPRO_CC
static
#endif /* !__SUNPRO_CC */
int32_t
FindCharInSet( const CharT* data, uint32_t dataLen, const SetCharT* set )
{
CharT filter = nsBufferRoutines<CharT>::get_find_in_set_filter(set);
const CharT* end = data + dataLen;
for (const CharT* iter = data; iter < end; ++iter)
{
CharT currentChar = *iter;
if (currentChar & filter)
continue; // char is not in filter set; go on with next char.
// test all chars
const SetCharT* charInSet = set;
CharT setChar = CharT(*charInSet);
while (setChar)
{
if (setChar == currentChar)
return iter - data; // found it! return index of the found char.
setChar = CharT(*(++charInSet));
}
}
return kNotFound;
}
template <class CharT, class SetCharT>
#ifndef __SUNPRO_CC
static
#endif /* !__SUNPRO_CC */
int32_t
RFindCharInSet( const CharT* data, uint32_t dataLen, const SetCharT* set )
{
CharT filter = nsBufferRoutines<CharT>::get_find_in_set_filter(set);
for (const CharT* iter = data + dataLen - 1; iter >= data; --iter)
{
CharT currentChar = *iter;
if (currentChar & filter)
continue; // char is not in filter set; go on with next char.
// test all chars
const CharT* charInSet = set;
CharT setChar = *charInSet;
while (setChar)
{
if (setChar == currentChar)
return iter - data; // found it! return index of the found char.
setChar = *(++charInSet);
}
}
return kNotFound;
}
/**
* this method changes the meaning of |offset| and |count|:
*
* upon return,
* |offset| specifies start of search range
* |count| specifies length of search range
*/
static void
Find_ComputeSearchRange( uint32_t bigLen, uint32_t littleLen, int32_t& offset, int32_t& count )
{
// |count| specifies how many iterations to make from |offset|
if (offset < 0)
{
offset = 0;
}
else if (uint32_t(offset) > bigLen)
{
count = 0;
return;
}
int32_t maxCount = bigLen - offset;
if (count < 0 || count > maxCount)
{
count = maxCount;
}
else
{
count += littleLen;
if (count > maxCount)
count = maxCount;
}
}
/**
* this method changes the meaning of |offset| and |count|:
*
* upon entry,
* |offset| specifies the end point from which to search backwards
* |count| specifies the number of iterations from |offset|
*
* upon return,
* |offset| specifies start of search range
* |count| specifies length of search range
*
*
* EXAMPLE
*
* + -- littleLen=4 -- +
* : :
* |____|____|____|____|____|____|____|____|____|____|____|____|
* : :
* offset=5 bigLen=12
*
* if count = 4, then we expect this function to return offset = 2 and
* count = 7.
*
*/
static void
RFind_ComputeSearchRange( uint32_t bigLen, uint32_t littleLen, int32_t& offset, int32_t& count )
{
if (littleLen > bigLen)
{
offset = 0;
count = 0;
return;
}
if (offset < 0)
offset = bigLen - littleLen;
if (count < 0)
count = offset + 1;
int32_t start = offset - count + 1;
if (start < 0)
start = 0;
count = offset + littleLen - start;
offset = start;
}
//-----------------------------------------------------------------------------
// define nsString obsolete methods
#include "string-template-def-unichar.h"
#include "nsTStringObsolete.cpp"
#include "string-template-undef.h"
// define nsCString obsolete methods
#include "string-template-def-char.h"
#include "nsTStringObsolete.cpp"
#include "string-template-undef.h"
//-----------------------------------------------------------------------------
// specialized methods:
int32_t
nsString::Find( const nsAFlatString& aString, int32_t aOffset, int32_t aCount ) const
{
// this method changes the meaning of aOffset and aCount:
Find_ComputeSearchRange(mLength, aString.Length(), aOffset, aCount);
int32_t result = FindSubstring(mData + aOffset, aCount, static_cast<const char16_t*>(aString.get()), aString.Length(), false);
if (result != kNotFound)
result += aOffset;
return result;
}
int32_t
nsString::Find( const char16_t* aString, int32_t aOffset, int32_t aCount ) const
{
return Find(nsDependentString(aString), aOffset, aCount);
}
int32_t
nsString::RFind( const nsAFlatString& aString, int32_t aOffset, int32_t aCount ) const
{
// this method changes the meaning of aOffset and aCount:
RFind_ComputeSearchRange(mLength, aString.Length(), aOffset, aCount);
int32_t result = RFindSubstring(mData + aOffset, aCount, static_cast<const char16_t*>(aString.get()), aString.Length(), false);
if (result != kNotFound)
result += aOffset;
return result;
}
int32_t
nsString::RFind( const char16_t* aString, int32_t aOffset, int32_t aCount ) const
{
return RFind(nsDependentString(aString), aOffset, aCount);
}
int32_t
nsString::FindCharInSet( const char16_t* aSet, int32_t aOffset ) const
{
if (aOffset < 0)
aOffset = 0;
else if (aOffset >= int32_t(mLength))
return kNotFound;
int32_t result = ::FindCharInSet(mData + aOffset, mLength - aOffset, aSet);
if (result != kNotFound)
result += aOffset;
return result;
}
void
nsString::ReplaceChar( const char16_t* aSet, char16_t aNewChar )
{
if (!EnsureMutable()) // XXX do this lazily?
AllocFailed(mLength);
char16_t* data = mData;
uint32_t lenRemaining = mLength;
while (lenRemaining)
{
int32_t i = ::FindCharInSet(data, lenRemaining, aSet);
if (i == kNotFound)
break;
data[i++] = aNewChar;
data += i;
lenRemaining -= i;
}
}
/**
* nsTString::Compare,CompareWithConversion,etc.
*/
int32_t
nsCString::Compare( const char* aString, bool aIgnoreCase, int32_t aCount ) const
{
uint32_t strLen = char_traits::length(aString);
int32_t maxCount = int32_t(XPCOM_MIN(mLength, strLen));
int32_t compareCount;
if (aCount < 0 || aCount > maxCount)
compareCount = maxCount;
else
compareCount = aCount;
int32_t result =
nsBufferRoutines<char>::compare(mData, aString, compareCount, aIgnoreCase);
if (result == 0 &&
(aCount < 0 || strLen < uint32_t(aCount) || mLength < uint32_t(aCount)))
{
// Since the caller didn't give us a length to test, or strings shorter
// than aCount, and compareCount characters matched, we have to assume
// that the longer string is greater.
if (mLength != strLen)
result = (mLength < strLen) ? -1 : 1;
}
return result;
}
bool
nsString::EqualsIgnoreCase( const char* aString, int32_t aCount ) const
{
uint32_t strLen = nsCharTraits<char>::length(aString);
int32_t maxCount = int32_t(XPCOM_MIN(mLength, strLen));
int32_t compareCount;
if (aCount < 0 || aCount > maxCount)
compareCount = maxCount;
else
compareCount = aCount;
int32_t result =
nsBufferRoutines<char16_t>::compare(mData, aString, compareCount, true);
if (result == 0 &&
(aCount < 0 || strLen < uint32_t(aCount) || mLength < uint32_t(aCount)))
{
// Since the caller didn't give us a length to test, or strings shorter
// than aCount, and compareCount characters matched, we have to assume
// that the longer string is greater.
if (mLength != strLen)
result = 1; // Arbitrarily using any number != 0
}
return result == 0;
}
/**
* nsTString::ToDouble
*/
double
nsCString::ToDouble(nsresult* aErrorCode) const
{
double res = 0.0;
if (mLength > 0)
{
char *conv_stopped;
const char *str = mData;
// Use PR_strtod, not strtod, since we don't want locale involved.
res = PR_strtod(str, &conv_stopped);
if (conv_stopped == str+mLength)
*aErrorCode = NS_OK;
else // Not all the string was scanned
*aErrorCode = NS_ERROR_ILLEGAL_VALUE;
}
else
{
// The string was too short (0 characters)
*aErrorCode = NS_ERROR_ILLEGAL_VALUE;
}
return res;
}
double
nsString::ToDouble(nsresult* aErrorCode) const
{
return NS_LossyConvertUTF16toASCII(*this).ToDouble(aErrorCode);
}
/**
* nsTString::AssignWithConversion
*/
void
nsCString::AssignWithConversion( const nsAString& aData )
{
LossyCopyUTF16toASCII(aData, *this);
}
void
nsString::AssignWithConversion( const nsACString& aData )
{
CopyASCIItoUTF16(aData, *this);
}
#endif // !MOZ_STRING_WITH_OBSOLETE_API
Reference in New Issue View Git Blame Copy Permalink