static void AppendNonAsciiToNCR(const nsAString& in, nsCString& out)
{
nsAString::const_iterator start, end;
in.BeginReading(start);
in.EndReading(end);
while (start != end) {
if (*start < 128) {
out.Append(*start++);
} else {
out.AppendLiteral("&#x");
out.AppendInt(*start++, 16);
out.Append(';');
}
}
}
/* static */
bool
MatchAutoCompleteFunction::findOnBoundary(const nsDependentSubstring &aToken,
const nsAString &aSourceString)
{
// We cannot match anything if there is nothing to search.
if (aSourceString.IsEmpty())
return false;
// Define a const instance of this class so it is created once.
const nsCaseInsensitiveStringComparator caseInsensitiveCompare;
const_wchar_iterator tokenStart(aToken.BeginReading()),
tokenEnd(aToken.EndReading()),
sourceStart(aSourceString.BeginReading()),
sourceEnd(aSourceString.EndReading());
// The start of aSourceString is considered a word boundary, so start there.
do {
// We are on a word boundary, so start by copying the iterators.
const_wchar_iterator testTokenItr(tokenStart),
testSourceItr(sourceStart);
// Keep trying to match the token one by one until it doesn't match.
while (!caseInsensitiveCompare(*testTokenItr, *testSourceItr)) {
// We matched something, so move down one.
testTokenItr++;
testSourceItr++;
// Matched the full token, so we are done!
if (testTokenItr == tokenEnd)
return true;
// However, if we ran into the end of the source while matching the
// token, we will not find it.
if (testSourceItr == sourceEnd)
return false;
}
// Always advance our starting iterator, and if we are not currently on a
// word boundary, advance to the next word boundary.
if (!isWordBoundary(ToLowerCase(*sourceStart++)))
sourceStart = nextWordBoundary(sourceStart, sourceEnd);
} while (sourceStart != sourceEnd);
return false;
}
void
LossyAppendUTF16toASCII( const nsAString& aSource, nsACString& aDest )
{
uint32_t old_dest_length = aDest.Length();
aDest.SetLength(old_dest_length + aSource.Length());
nsAString::const_iterator fromBegin, fromEnd;
nsACString::iterator dest;
aDest.BeginWriting(dest);
dest.advance(old_dest_length);
// right now, this won't work on multi-fragment destinations
LossyConvertEncoding16to8 converter(dest.get());
copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter);
}
uint32_t
CountCharInReadable(const nsAString& aStr, char16_t aChar)
{
uint32_t count = 0;
nsAString::const_iterator begin, end;
aStr.BeginReading(begin);
aStr.EndReading(end);
while (begin != end) {
if (*begin == aChar) {
++count;
}
++begin;
}
return count;
}
void
Link::SetProtocol(const nsAString &aProtocol, ErrorResult& aError)
{
nsCOMPtr<nsIURI> uri(GetURIToMutate());
if (!uri) {
// Ignore failures to be compatible with NS4.
return;
}
nsAString::const_iterator start, end;
aProtocol.BeginReading(start);
aProtocol.EndReading(end);
nsAString::const_iterator iter(start);
(void)FindCharInReadable(':', iter, end);
(void)uri->SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)));
SetHrefAttribute(uri);
}
static bool
ParseKeySystem(const nsAString& aExpectedKeySystem,
const nsAString& aInputKeySystem,
int32_t& aOutCDMVersion)
{
if (!StringBeginsWith(aInputKeySystem, aExpectedKeySystem)) {
return false;
}
if (aInputKeySystem.Length() > aExpectedKeySystem.Length() + 8) {
// Allow up to 8 bytes for the ".version" field. 8 bytes should
// be enough for any versioning scheme...
NS_WARNING("Input KeySystem including was suspiciously long");
return false;
}
const char16_t* versionStart = aInputKeySystem.BeginReading() + aExpectedKeySystem.Length();
const char16_t* end = aInputKeySystem.EndReading();
if (versionStart == end) {
// No version supplied with keysystem.
aOutCDMVersion = NO_CDM_VERSION;
return true;
}
if (*versionStart != '.') {
// version not in correct format.
NS_WARNING("EME keySystem version string not prefixed by '.'");
return false;
}
versionStart++;
const nsAutoString versionStr(Substring(versionStart, end));
if (!ContainsOnlyDigits(versionStr)) {
NS_WARNING("Non-digit character in EME keySystem string's version suffix");
return false;
}
nsresult rv;
int32_t version = versionStr.ToInteger(&rv);
if (NS_FAILED(rv) || version < 0) {
NS_WARNING("Invalid version in EME keySystem string");
return false;
}
aOutCDMVersion = version;
return true;
}
nsresult
nsInternetCiter::StripCitesAndLinebreaks(const nsAString& aInString,
nsAString& aOutString,
bool aLinebreaksToo,
int32_t* aCiteLevel)
{
if (aCiteLevel)
*aCiteLevel = 0;
aOutString.Truncate();
nsReadingIterator <char16_t> beginIter,endIter;
aInString.BeginReading(beginIter);
aInString.EndReading(endIter);
while (beginIter!= endIter) // loop over lines
{
// Clear out cites first, at the beginning of the line:
int32_t thisLineCiteLevel = 0;
while (beginIter!= endIter && (*beginIter == gt || nsCRT::IsAsciiSpace(*beginIter)))
{
if (*beginIter == gt) ++thisLineCiteLevel;
++beginIter;
}
// Now copy characters until line end:
while (beginIter != endIter && (*beginIter != '\r' && *beginIter != '\n'))
{
aOutString.Append(*beginIter);
++beginIter;
}
if (aLinebreaksToo)
aOutString.Append(char16_t(' '));
else
aOutString.Append(char16_t('\n')); // DOM linebreaks, not NS_LINEBREAK
// Skip over any more consecutive linebreak-like characters:
while (beginIter != endIter && (*beginIter == '\r' || *beginIter == '\n'))
++beginIter;
// Done with this line -- update cite level
if (aCiteLevel && (thisLineCiteLevel > *aCiteLevel))
*aCiteLevel = thisLineCiteLevel;
}
return NS_OK;
}
nsresult
nsDOMTokenList::CheckToken(const nsAString& aStr)
{
if (aStr.IsEmpty()) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
nsAString::const_iterator iter, end;
aStr.BeginReading(iter);
aStr.EndReading(end);
while (iter != end) {
if (nsContentUtils::IsHTMLWhitespace(*iter))
return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
++iter;
}
return NS_OK;
}
bool nsDefaultURIFixup::PossiblyByteExpandedFileName(const nsAString& aIn)
{
// XXXXX HACK XXXXX : please don't copy this code.
// There are cases where aIn contains the locale byte chars padded to short
// (thus the name "ByteExpanded"); whereas other cases
// have proper Unicode code points.
// This is a temporary fix. Please refer to 58866, 86948
nsReadingIterator<char16_t> iter;
nsReadingIterator<char16_t> iterEnd;
aIn.BeginReading(iter);
aIn.EndReading(iterEnd);
while (iter != iterEnd)
{
if (*iter >= 0x0080 && *iter <= 0x00FF)
return true;
++iter;
}
return false;
}
nsresult
nsNodeInfoManager::GetNodeInfo(const nsAString& aQualifiedName,
const nsAString& aNamespaceURI,
nsINodeInfo** aNodeInfo)
{
NS_ENSURE_ARG(!aQualifiedName.IsEmpty());
nsAString::const_iterator start, end;
aQualifiedName.BeginReading(start);
aQualifiedName.EndReading(end);
nsCOMPtr<nsIAtom> prefixAtom;
nsAString::const_iterator iter(start);
if (FindCharInReadable(':', iter, end)) {
prefixAtom = do_GetAtom(Substring(start, iter));
NS_ENSURE_TRUE(prefixAtom, NS_ERROR_OUT_OF_MEMORY);
start = ++iter; // step over the ':'
if (iter == end) {
// No data after the ':'.
return NS_ERROR_INVALID_ARG;
}
}
nsCOMPtr<nsIAtom> nameAtom = do_GetAtom(Substring(start, end));
NS_ENSURE_TRUE(nameAtom, NS_ERROR_OUT_OF_MEMORY);
PRInt32 nsid = kNameSpaceID_None;
if (!aNamespaceURI.IsEmpty()) {
nsresult rv = nsContentUtils::NameSpaceManager()->
RegisterNameSpace(aNamespaceURI, nsid);
NS_ENSURE_SUCCESS(rv, rv);
}
return GetNodeInfo(nameAtom, prefixAtom, nsid, aNodeInfo);
}
nsresult
nsInternetCiter::GetCiteString(const nsAString& aInString, nsAString& aOutString)
{
aOutString.Truncate();
char16_t uch = nl;
// Strip trailing new lines which will otherwise turn up
// as ugly quoted empty lines.
nsReadingIterator <char16_t> beginIter,endIter;
aInString.BeginReading(beginIter);
aInString.EndReading(endIter);
while(beginIter!= endIter &&
(*endIter == cr ||
*endIter == nl))
{
--endIter;
}
// Loop over the string:
while (beginIter != endIter)
{
if (uch == nl)
{
aOutString.Append(gt);
// No space between >: this is ">>> " style quoting, for
// compatibility with RFC 2646 and format=flowed.
if (*beginIter != gt)
aOutString.Append(space);
}
uch = *beginIter;
++beginIter;
aOutString += uch;
}
if (uch != nl)
aOutString += nl;
return NS_OK;
}
void nsIDNService::normalizeFullStops(nsAString& s)
{
nsAString::const_iterator start, end;
s.BeginReading(start);
s.EndReading(end);
int32_t index = 0;
while (start != end) {
switch (*start) {
case 0x3002:
case 0xFF0E:
case 0xFF61:
s.Replace(index, 1, NS_LITERAL_STRING("."));
break;
default:
break;
}
start++;
index++;
}
}
nsresult
nsTreeUtils::TokenizeProperties(const nsAString& aProperties, nsISupportsArray* aPropertiesArray)
{
NS_PRECONDITION(aPropertiesArray != nullptr, "null ptr");
if (! aPropertiesArray)
return NS_ERROR_NULL_POINTER;
nsAString::const_iterator end;
aProperties.EndReading(end);
nsAString::const_iterator iter;
aProperties.BeginReading(iter);
do {
// Skip whitespace
while (iter != end && nsCRT::IsAsciiSpace(*iter))
++iter;
// If only whitespace, we're done
if (iter == end)
break;
// Note the first non-whitespace character
nsAString::const_iterator first = iter;
// Advance to the next whitespace character
while (iter != end && ! nsCRT::IsAsciiSpace(*iter))
++iter;
// XXX this would be nonsensical
NS_ASSERTION(iter != first, "eh? something's wrong here");
if (iter == first)
break;
nsCOMPtr<nsIAtom> atom = do_GetAtom(Substring(first, iter));
aPropertiesArray->AppendElement(atom);
} while (iter != end);
return NS_OK;
}
void
Key::EncodeString(const nsAString& aString, PRUint8 aTypeOffset)
{
// First measure how long the encoded string will be.
// The +2 is for initial 3 and trailing 0. We'll compensate for multi-byte
// chars below.
PRUint32 size = aString.Length() + 2;
const PRUnichar* start = aString.BeginReading();
const PRUnichar* end = aString.EndReading();
for (const PRUnichar* iter = start; iter < end; ++iter) {
if (*iter > ONE_BYTE_LIMIT) {
size += *iter > TWO_BYTE_LIMIT ? 2 : 1;
}
}
// Allocate memory for the new size
PRUint32 oldLen = mBuffer.Length();
char* buffer;
if (!mBuffer.GetMutableData(&buffer, oldLen + size)) {
return;
}
buffer += oldLen;
// Write type marker
*(buffer++) = eString + aTypeOffset;
// Encode string
for (const PRUnichar* iter = start; iter < end; ++iter) {
if (*iter <= ONE_BYTE_LIMIT) {
*(buffer++) = *iter + ONE_BYTE_ADJUST;
}
else if (*iter <= TWO_BYTE_LIMIT) {
PRUnichar c = PRUnichar(*iter) + TWO_BYTE_ADJUST + 0x8000;
*(buffer++) = (char)(c >> 8);
*(buffer++) = (char)(c & 0xFF);
}
else {
PRInt32
nsSMILParserUtils::CheckForNegativeNumber(const nsAString& aStr)
{
PRInt32 absValLocation = -1;
nsAString::const_iterator start, end;
aStr.BeginReading(start);
aStr.EndReading(end);
// Skip initial whitespace
SkipBeginWsp(start, end);
// Check for dash
if (start != end && *start == '-') {
++start;
// Check for numeric character
if (start != end && NS_IS_DIGIT(*start)) {
absValLocation = start.get() - start.start();
}
}
return absValLocation;
}
bool
nsSynthVoiceRegistry::FindVoiceByLang(const nsAString& aLang,
VoiceData** aRetval)
{
nsAString::const_iterator dashPos, start, end;
aLang.BeginReading(start);
aLang.EndReading(end);
while (true) {
nsAutoString langPrefix(Substring(start, end));
for (int32_t i = mDefaultVoices.Length(); i > 0; ) {
VoiceData* voice = mDefaultVoices[--i];
if (StringBeginsWith(voice->mLang, langPrefix)) {
*aRetval = voice;
return true;
}
}
for (int32_t i = mVoices.Length(); i > 0; ) {
VoiceData* voice = mVoices[--i];
if (StringBeginsWith(voice->mLang, langPrefix)) {
*aRetval = voice;
return true;
}
}
dashPos = end;
end = start;
if (!RFindInReadable(NS_LITERAL_STRING("-"), end, dashPos)) {
break;
}
}
return false;
}
void
Link::SetHost(const nsAString &aHost)
{
nsCOMPtr<nsIURI> uri(GetURIToMutate());
if (!uri) {
// Ignore failures to be compatible with NS4.
return;
}
// We cannot simply call nsIURI::SetHost because that would treat the name as
// an IPv6 address (like http:://[server:443]/). We also cannot call
// nsIURI::SetHostPort because that isn't implemented. Sadfaces.
// First set the hostname.
nsAString::const_iterator start, end;
aHost.BeginReading(start);
aHost.EndReading(end);
nsAString::const_iterator iter(start);
(void)FindCharInReadable(':', iter, end);
NS_ConvertUTF16toUTF8 host(Substring(start, iter));
(void)uri->SetHost(host);
// Also set the port if needed.
if (iter != end) {
iter++;
if (iter != end) {
nsAutoString portStr(Substring(iter, end));
nsresult rv;
int32_t port = portStr.ToInteger(&rv);
if (NS_SUCCEEDED(rv)) {
(void)uri->SetPort(port);
}
}
};
SetHrefAttribute(uri);
return;
}
void
URLMainThread::SetProtocol(const nsAString& aProtocol, ErrorResult& aRv)
{
nsAString::const_iterator start, end;
aProtocol.BeginReading(start);
aProtocol.EndReading(end);
nsAString::const_iterator iter(start);
FindCharInReadable(':', iter, end);
// Changing the protocol of a URL, changes the "nature" of the URI
// implementation. In order to do this properly, we have to serialize the
// existing URL and reparse it in a new object.
nsCOMPtr<nsIURI> clone;
nsresult rv = mURI->Clone(getter_AddRefs(clone));
if (NS_WARN_IF(NS_FAILED(rv)) || !clone) {
return;
}
rv = clone->SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)));
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
nsAutoCString href;
rv = clone->GetSpec(href);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), href);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
mURI = uri;
}
nsresult
nsDASHWebMODParser::GetTime(nsAString& aTimeStr, double& aTime)
{
NS_ENSURE_FALSE(aTimeStr.IsEmpty(), NS_ERROR_NOT_INITIALIZED);
// Fail if time string is not of the format "PT<time>S".
NS_NAMED_LITERAL_STRING(prefix, "PT");
NS_NAMED_LITERAL_STRING(suffix, "S");
nsAString::const_iterator start, end, prefixStart, prefixEnd,
suffixStart, suffixEnd;
// Search for "PT" at the start.
aTimeStr.BeginReading(start);
aTimeStr.EndReading(end);
prefixStart = start;
prefixEnd = end;
NS_ENSURE_TRUE(FindInReadable(prefix, prefixStart, prefixEnd),
NS_ERROR_ILLEGAL_VALUE);
NS_ENSURE_TRUE(prefixStart == start, NS_ERROR_ILLEGAL_VALUE);
// Search for "S" after "PT".
suffixStart = prefixEnd;
suffixEnd = end;
NS_ENSURE_TRUE(FindInReadable(suffix, suffixStart, suffixEnd),
NS_ERROR_ILLEGAL_VALUE);
NS_ENSURE_TRUE(suffixStart != prefixEnd, NS_ERROR_ILLEGAL_VALUE);
NS_ENSURE_TRUE(suffixEnd == end, NS_ERROR_ILLEGAL_VALUE);
// Parse inner substring for time.
const nsAutoString timeSubString(Substring(prefixEnd, suffixStart));
LOG("Parsing substring \"%s\" in \"%s\"",
NS_ConvertUTF16toUTF8(timeSubString).get(),
NS_ConvertUTF16toUTF8(aTimeStr).get());
NS_ENSURE_FALSE(timeSubString.IsEmpty(), NS_ERROR_ILLEGAL_VALUE);
nsresult rv;
aTime = timeSubString.ToDouble(&rv);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
bool
IsASCII( const nsAString& aString )
{
static const char16_t NOT_ASCII = char16_t(~0x007F);
// Don't want to use |copy_string| for this task, since we can stop at the first non-ASCII character
nsAString::const_iterator iter, done_reading;
aString.BeginReading(iter);
aString.EndReading(done_reading);
const char16_t* c = iter.get();
const char16_t* end = done_reading.get();
while ( c < end )
{
if ( *c++ & NOT_ASCII )
return false;
}
return true;
}
nsresult
nsHTMLEditorLog::PrintUnicode(const nsAString &aString)
{
//const PRUnichar *uc = aString.get();
char buf[10];
nsReadingIterator <PRUnichar> beginIter,endIter;
aString.BeginReading(beginIter);
aString.EndReading(endIter);
while(beginIter != endIter)
{
if (nsCRT::IsAsciiAlpha(*beginIter) || nsCRT::IsAsciiDigit(*beginIter) || *beginIter == ' ')
PR_snprintf(buf, sizeof(buf), "%c", *beginIter);
else
PR_snprintf(buf, sizeof(buf), "\\u%.4x", *beginIter);
nsresult result = Write(buf);
NS_ENSURE_SUCCESS(result, result);
++beginIter;
}
return NS_OK;
}
NS_IMETHODIMP
nsAOLCiter::StripCites(const nsAString& aInString, nsAString& aOutString)
{
// Remove the beginning cites, if any:
nsAutoString tOutputString;
nsReadingIterator <PRUnichar> iter, enditer;
aInString.BeginReading(iter);
aInString.EndReading(enditer);
if (StringBeginsWith(aInString, NS_LITERAL_STRING(">>")))
{
iter.advance(2);
while (nsCRT::IsAsciiSpace(*iter))
++iter;
AppendUnicodeTo(iter, enditer, tOutputString);
}
else
CopyUnicodeTo(iter, enditer, tOutputString);
// Remove the end cites, if any:
tOutputString.Trim("<", PR_FALSE, PR_TRUE, PR_FALSE);
aOutString.Assign(tOutputString);
return NS_OK;
}
/* long playAudio (in AString arquivo, in long inicio, in long fim); */
NS_IMETHODIMP CLidaAudio::PlayAudio(const nsAString & arquivo, PRInt32 inicio, PRInt32 fim, PRInt32 *_retval)
{
//marcamos erro se der problema no meio
*_retval = 3;
//tiramos uma copia da string
//ela nao é nulo-terminated
std::wstring arquivo_str;
arquivo_str.assign(arquivo.BeginReading(), arquivo.EndReading());
directshow::PlayAudioStatus status = m_directshow.PlayAudio(arquivo_str.c_str(), inicio, fim);
switch(status)
{
case directshow::PlayAudioStatus_ok:
*_retval = 0;
break;
case directshow::PlayAudioStatus_erro:
*_retval = 3;
break;
case directshow::PlayAudioStatus_semcodec:
*_retval = 2;
break;
case directshow::PlayAudioStatus_semarquivo:
case directshow::PlayAudioStatus_arquivodanificado:
*_retval = 1;
break;
default:
*_retval = 3;
break;
}
return NS_OK;
}
PRInt32
nsAttrValue::StringToInteger(const nsAString& aValue, bool* aStrict,
PRInt32* aErrorCode,
bool aCanBePercent,
bool* aIsPercent) const
{
*aStrict = true;
*aErrorCode = NS_ERROR_ILLEGAL_VALUE;
if (aCanBePercent) {
*aIsPercent = false;
}
nsAString::const_iterator iter, end;
aValue.BeginReading(iter);
aValue.EndReading(end);
while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
*aStrict = false;
++iter;
}
if (iter == end) {
return 0;
}
bool negate = false;
if (*iter == PRUnichar('-')) {
negate = true;
++iter;
} else if (*iter == PRUnichar('+')) {
*aStrict = false;
++iter;
}
PRInt32 value = 0;
PRInt32 pValue = 0; // Previous value, used to check integer overflow
while (iter != end) {
if (*iter >= PRUnichar('0') && *iter <= PRUnichar('9')) {
value = (value * 10) + (*iter - PRUnichar('0'));
++iter;
// Checking for integer overflow.
if (pValue > value) {
*aStrict = false;
*aErrorCode = NS_ERROR_ILLEGAL_VALUE;
break;
} else {
pValue = value;
*aErrorCode = NS_OK;
}
} else if (aCanBePercent && *iter == PRUnichar('%')) {
++iter;
*aIsPercent = true;
if (iter != end) {
*aStrict = false;
break;
}
} else {
*aStrict = false;
break;
}
}
if (negate) {
value = -value;
// Checking the special case of -0.
if (!value) {
*aStrict = false;
}
}
return value;
}
void
nsAttrValue::ParseAtomArray(const nsAString& aValue)
{
nsAString::const_iterator iter, end;
aValue.BeginReading(iter);
aValue.EndReading(end);
PRBool hasSpace = PR_FALSE;
// skip initial whitespace
while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
hasSpace = PR_TRUE;
++iter;
}
if (iter == end) {
SetTo(aValue);
return;
}
nsAString::const_iterator start(iter);
// get first - and often only - atom
do {
++iter;
} while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter));
nsCOMPtr<nsIAtom> classAtom = do_GetAtom(Substring(start, iter));
if (!classAtom) {
Reset();
return;
}
// skip whitespace
while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
hasSpace = PR_TRUE;
++iter;
}
if (iter == end && !hasSpace) {
// we only found one classname and there was no whitespace so
// don't bother storing a list
ResetIfSet();
nsIAtom* atom = nsnull;
classAtom.swap(atom);
SetPtrValueAndType(atom, eAtomBase);
return;
}
if (!EnsureEmptyAtomArray()) {
return;
}
AtomArray* array = GetAtomArrayValue();
if (!array->AppendElement(classAtom)) {
Reset();
return;
}
// parse the rest of the classnames
while (iter != end) {
start = iter;
do {
++iter;
} while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter));
classAtom = do_GetAtom(Substring(start, iter));
if (!array->AppendElement(classAtom)) {
Reset();
return;
}
// skip whitespace
while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
++iter;
}
}
SetMiscAtomOrString(&aValue);
return;
}
PRInt32
nsAttrValue::StringToInteger(const nsAString& aValue, PRBool* aStrict,
PRInt32* aErrorCode,
PRBool aCanBePercent,
PRBool* aIsPercent) const
{
*aStrict = PR_FALSE;
*aErrorCode = NS_ERROR_ILLEGAL_VALUE;
if (aCanBePercent) {
*aIsPercent = PR_FALSE;
}
nsAString::const_iterator iter, end;
aValue.BeginReading(iter);
aValue.EndReading(end);
PRBool negate = PR_FALSE;
PRInt32 value = 0;
if (iter != end) {
if (*iter == PRUnichar('-')) {
negate = PR_TRUE;
++iter;
}
if (iter != end) {
if ((*iter >= PRUnichar('1') || (*iter == PRUnichar('0') && !negate)) &&
*iter <= PRUnichar('9')) {
value = *iter - PRUnichar('0');
++iter;
*aStrict = (value != 0 || iter == end ||
(aCanBePercent && *iter == PRUnichar('%')));
while (iter != end && *aStrict) {
if (*iter >= PRUnichar('0') && *iter <= PRUnichar('9')) {
value = (value * 10) + (*iter - PRUnichar('0'));
++iter;
if (iter != end && value > ((PR_INT32_MAX / 10) - 9)) {
*aStrict = PR_FALSE;
}
} else if (aCanBePercent && *iter == PRUnichar('%')) {
++iter;
if (iter == end) {
*aIsPercent = PR_TRUE;
} else {
*aStrict = PR_FALSE;
}
} else {
*aStrict = PR_FALSE;
}
}
if (*aStrict) {
if (negate) {
value = -value;
}
if (!aCanBePercent || !*aIsPercent) {
*aErrorCode = NS_OK;
#ifdef DEBUG
nsAutoString stringValue;
stringValue.AppendInt(value);
if (aCanBePercent && *aIsPercent) {
stringValue.AppendLiteral("%");
}
NS_ASSERTION(stringValue.Equals(aValue), "Wrong conversion!");
#endif
return value;
}
}
}
}
}
nsAutoString tmp(aValue);
return tmp.ToInteger(aErrorCode);
}
// parse and process a formatting attribute.
// Generate an autocomplete value from the
// information in aMessage and append it to aValue. Any errors
// (including failure to find a required attribute while building up aValue)
// return an NS_ERROR_* up the stack so that the caller doesn't try and
// generate an nsIAutoCompleteItem from this.
//
nsresult
nsAbLDAPAutoCompFormatter::ProcessFormat(const nsAString & aFormat,
nsILDAPMessage *aMessage,
nsACString *aValue,
nsCString *aAttrs)
{
nsresult rv; // temp for return values
// get some iterators to parse aFormat
//
const PRUnichar *iter = aFormat.BeginReading();
const PRUnichar *iterEnd = aFormat.EndReading();
// get the console service for error logging
//
nsCOMPtr<nsIConsoleService> consoleSvc =
do_GetService("@mozilla.org/consoleservice;1", &rv);
if (NS_FAILED(rv)) {
NS_WARNING("nsAbLDAPAutoCompFormatter::ProcessFormat(): "
"couldn't get console service");
}
bool attrRequired = false; // is this attr required or optional?
nsCAutoString attrName; // current attr to get
// parse until we hit the end of the string
//
while (iter != iterEnd) {
switch (*iter) { // process the next char
case PRUnichar('{'):
attrRequired = true; // this attribute is required
/*FALLTHROUGH*/
case PRUnichar('['):
rv = ParseAttrName(&iter, iterEnd, attrRequired,
consoleSvc, attrName);
if ( NS_FAILED(rv) ) {
// something unrecoverable happened; stop parsing and
// propagate the error up the stack
//
return rv;
}
// If we're building a string of attributes...
if (aAttrs) {
// ...and it doesn't already contain this string
if (aAttrs->Find(attrName, CaseInsensitiveCompare) == kNotFound)
{
// add it
if (!aAttrs->IsEmpty())
aAttrs->Append(',');
aAttrs->Append(attrName);
}
} else {
// otherwise, append the first value of this attr to aValue
// XXXdmose should do better than this; bug 76595
rv = AppendFirstAttrValue(attrName, aMessage, attrRequired,
*aValue);
if ( NS_FAILED(rv) ) {
// something unrecoverable happened; stop parsing and
// propagate the error up the stack
//
return rv;
}
}
attrName.Truncate(); // clear out for next pass
attrRequired = false; // reset to the default for the next pass
break;
case PRUnichar('\\'):
// advance the iterator and be sure we haven't run off the end
//
++iter;
if (iter == iterEnd) {
// abort; missing escaped char
//
if (consoleSvc) {
consoleSvc->LogStringMessage(
NS_LITERAL_STRING(
"LDAP addressbook autocomplete formatter: error parsing format string: premature end of string after \\ escape").get());
NS_ERROR("LDAP addressbook autocomplete formatter: error "
"parsing format string: premature end of string "
"after \\ escape");
}
return NS_ERROR_ILLEGAL_VALUE;
}
/*FALLTHROUGH*/
default:
// if we're not just building an array of attribute names, append
// this character to the item we're generating.
//
if (!aAttrs) {
// this character gets treated as a literal
//
aValue->Append(NS_ConvertUTF16toUTF8(iter, 1));
}
}
++iter; // advance the iterator
}
return NS_OK;
}
static nsresult
mdn_normalize(bool do_composition, bool compat,
const nsAString& aSrcStr, nsAString& aToStr)
{
workbuf_t wb;
nsresult r = NS_OK;
/*
* Initialize working buffer.
*/
workbuf_init(&wb);
nsAString::const_iterator start, end;
aSrcStr.BeginReading(start);
aSrcStr.EndReading(end);
while (start != end) {
PRUint32 c;
PRUnichar curChar;
//assert(wb.cur == wb.last);
/*
* Get one character from 'from'.
*/
curChar= *start++;
if (NS_IS_HIGH_SURROGATE(curChar) && start != end && NS_IS_LOW_SURROGATE(*(start)) ) {
c = SURROGATE_TO_UCS4(curChar, *start);
++start;
} else {
c = curChar;
}
/*
* Decompose it.
*/
if ((r = decompose(&wb, c, compat)) != NS_OK)
break;
/*
* Get canonical class.
*/
get_class(&wb);
/*
* Reorder & compose.
*/
for (; wb.cur < wb.last; wb.cur++) {
if (wb.cur == 0) {
continue;
} else if (wb.cclass[wb.cur] > 0) {
/*
* This is not a starter. Try reordering.
* Note that characters up to it are
* already in canonical order.
*/
reorder(&wb);
continue;
}
/*
* This is a starter character, and there are
* some characters before it. Those characters
* have been reordered properly, and
* ready for composition.
*/
if (do_composition && wb.cclass[0] == 0)
compose(&wb);
/*
* If CUR points to a starter character,
* then process of characters before CUR are
* already finished, because any further
* reordering/composition for them are blocked
* by the starter CUR points.
*/
if (wb.cur > 0 && wb.cclass[wb.cur] == 0) {
/* Flush everything before CUR. */
r = flush_before_cur(&wb, aToStr);
if (r != NS_OK)
break;
}
}
}
if (r == NS_OK) {
if (do_composition && wb.cur > 0 && wb.cclass[0] == 0) {
/*
* There is some characters left in WB.
* They are ordered, but not composed yet.
* Now CUR points just after the last character in WB,
* and since compose() tries to compose characters
* between top and CUR inclusive, we must make CUR
* one character back during compose().
*/
wb.cur--;
compose(&wb);
wb.cur++;
}
/*
* Call this even when WB.CUR == 0, to make TO
* NUL-terminated.
*/
r = flush_before_cur(&wb, aToStr);
}
workbuf_free(&wb);
return (r);
}
bool
nsTemplateCondition::CheckMatchStrings(const nsAString& aLeftString,
const nsAString& aRightString)
{
bool match = false;
if (aRightString.IsEmpty()) {
if ((mRelation == eEquals) && aLeftString.IsEmpty())
match = true;
}
else {
switch (mRelation) {
case eEquals:
if (mIgnoreCase)
match = aLeftString.Equals(aRightString,
nsCaseInsensitiveStringComparator());
else
match = aLeftString.Equals(aRightString);
break;
case eLess:
case eGreater:
{
// non-numbers always compare false
nsresult err;
PRInt32 leftint = PromiseFlatString(aLeftString).ToInteger(&err);
if (NS_SUCCEEDED(err)) {
PRInt32 rightint = PromiseFlatString(aRightString).ToInteger(&err);
if (NS_SUCCEEDED(err)) {
match = (mRelation == eLess) ? (leftint < rightint) :
(leftint > rightint);
}
}
break;
}
case eBefore:
{
nsICollation* collation = nsXULContentUtils::GetCollation();
if (collation) {
PRInt32 sortOrder;
collation->CompareString((mIgnoreCase ?
static_cast<PRInt32>(nsICollation::kCollationCaseInSensitive) :
static_cast<PRInt32>(nsICollation::kCollationCaseSensitive)),
aLeftString,
aRightString,
&sortOrder);
match = (sortOrder < 0);
}
else if (mIgnoreCase) {
match = (Compare(aLeftString, aRightString,
nsCaseInsensitiveStringComparator()) < 0);
}
else {
match = (Compare(aLeftString, aRightString) < 0);
}
break;
}
case eAfter:
{
nsICollation* collation = nsXULContentUtils::GetCollation();
if (collation) {
PRInt32 sortOrder;
collation->CompareString((mIgnoreCase ?
static_cast<PRInt32>(nsICollation::kCollationCaseInSensitive) :
static_cast<PRInt32>(nsICollation::kCollationCaseSensitive)),
aLeftString,
aRightString,
&sortOrder);
match = (sortOrder > 0);
}
else if (mIgnoreCase) {
match = (Compare(aLeftString, aRightString,
nsCaseInsensitiveStringComparator()) > 0);
}
else {
match = (Compare(aLeftString, aRightString) > 0);
}
break;
}
case eStartswith:
if (mIgnoreCase)
match = (StringBeginsWith(aLeftString, aRightString,
nsCaseInsensitiveStringComparator()));
else
match = (StringBeginsWith(aLeftString, aRightString));
break;
case eEndswith:
if (mIgnoreCase)
match = (StringEndsWith(aLeftString, aRightString,
nsCaseInsensitiveStringComparator()));
else
match = (StringEndsWith(aLeftString, aRightString));
break;
case eContains:
{
nsAString::const_iterator start, end;
aLeftString.BeginReading(start);
aLeftString.EndReading(end);
if (mIgnoreCase)
match = CaseInsensitiveFindInReadable(aRightString, start, end);
else
match = FindInReadable(aRightString, start, end);
break;
}
default:
break;
}
}
if (mNegate) match = !match;
return match;
}
NS_IMETHODIMP
nsFileView::SetFilter(const nsAString& aFilterString)
{
PRUint32 filterCount = mCurrentFilters.Length();
for (PRUint32 i = 0; i < filterCount; ++i)
NS_Free(mCurrentFilters[i]);
mCurrentFilters.Clear();
nsAString::const_iterator start, iter, end;
aFilterString.BeginReading(iter);
aFilterString.EndReading(end);
while (true) {
// skip over delimiters
while (iter != end && (*iter == ';' || *iter == ' '))
++iter;
if (iter == end)
break;
start = iter; // start of a filter
// we know this is neither ';' nor ' ', skip to next char
++iter;
// find next delimiter or end of string
while (iter != end && (*iter != ';' && *iter != ' '))
++iter;
PRUnichar* filter = ToNewUnicode(Substring(start, iter));
if (!filter)
return NS_ERROR_OUT_OF_MEMORY;
if (!mCurrentFilters.AppendElement(filter)) {
NS_Free(filter);
return NS_ERROR_OUT_OF_MEMORY;
}
if (iter == end)
break;
++iter; // we know this is either ';' or ' ', skip to next char
}
if (mTree) {
mTree->BeginUpdateBatch();
PRUint32 count;
mDirList->Count(&count);
mTree->RowCountChanged(count, count - mTotalRows);
}
mFilteredFiles->Clear();
FilterFiles();
SortArray(mFilteredFiles);
if (mReverseSort)
ReverseArray(mFilteredFiles);
if (mTree)
mTree->EndUpdateBatch();
return NS_OK;
}
