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; }