// Replace all occurrences of |matchVal| with |newVal| static void ReplaceSubstring( nsACString& str, const nsACString& matchVal, const nsACString& newVal ) { const char* sp, *mp, *np; uint32_t sl, ml, nl; sl = NS_CStringGetData(str, &sp); ml = NS_CStringGetData(matchVal, &mp); nl = NS_CStringGetData(newVal, &np); for (const char* iter = sp; iter <= sp + sl - ml; ++iter) { if (memcmp(iter, mp, ml) == 0) { uint32_t offset = iter - sp; NS_CStringSetDataRange(str, offset, ml, np, nl); sl = NS_CStringGetData(str, &sp); iter = sp + offset + nl - 1; } } }
static bool test_convert() { nsStringContainer s; NS_StringContainerInit(s); NS_StringSetData(s, kUnicodeData, sizeof(kUnicodeData)/2 - 1); nsCStringContainer temp; NS_CStringContainerInit(temp); const char *data; NS_UTF16ToCString(s, NS_CSTRING_ENCODING_ASCII, temp); NS_CStringGetData(temp, &data); if (strcmp(data, kAsciiData) != 0) return false; NS_UTF16ToCString(s, NS_CSTRING_ENCODING_UTF8, temp); NS_CStringGetData(temp, &data); if (strcmp(data, kAsciiData) != 0) return false; NS_CStringContainerFinish(temp); NS_StringContainerFinish(s); return true; }
static void CompressWhitespace(nsACString &str) { const char *p; int32_t i, len = (int32_t) NS_CStringGetData(str, &p); // trim leading whitespace for (i=0; i<len; ++i) { if (!strchr(kWhitespace, (char) p[i])) break; } if (i>0) { NS_CStringCutData(str, 0, i); len = (int32_t) NS_CStringGetData(str, &p); } // trim trailing whitespace for (i=len-1; i>=0; --i) { if (!strchr(kWhitespace, (char) p[i])) break; } if (++i < len) NS_CStringCutData(str, i, len - i); }
static bool test_mutation() { nsCStringContainer s; NS_CStringContainerInit(s); const char kText[] = "Every good boy does fine."; char *buf; uint32_t len = NS_CStringGetMutableData(s, sizeof(kText) - 1, &buf); if (!buf || len != sizeof(kText) - 1) return false; memcpy(buf, kText, sizeof(kText)); const char *data; NS_CStringGetData(s, &data); if (strcmp(data, kText) != 0) return false; uint32_t newLen = len + 1; len = NS_CStringGetMutableData(s, newLen, &buf); if (!buf || len != newLen) return false; buf[len - 1] = '.'; NS_CStringGetData(s, &data); if (strncmp(data, kText, len - 1) != 0 || data[len - 1] != '.') return false; NS_CStringContainerFinish(s); return true; }
static bool test_basic_1() { nsCStringContainer s; NS_CStringContainerInit(s); const char *ptr; uint32_t len; char *clone; NS_CStringGetData(s, &ptr); if (ptr == nullptr || *ptr != '\0') { NS_ERROR("unexpected result"); return false; } NS_CStringSetData(s, kAsciiData, PR_UINT32_MAX); len = NS_CStringGetData(s, &ptr); if (ptr == nullptr || strcmp(ptr, kAsciiData) != 0) { NS_ERROR("unexpected result"); return false; } if (len != sizeof(kAsciiData)-1) { NS_ERROR("unexpected result"); return false; } clone = NS_CStringCloneData(s); if (ptr == nullptr || strcmp(ptr, kAsciiData) != 0) { NS_ERROR("unexpected result"); return false; } NS_Free(clone); nsCStringContainer temp; NS_CStringContainerInit(temp); NS_CStringCopy(temp, s); len = NS_CStringGetData(temp, &ptr); if (ptr == nullptr || strcmp(ptr, kAsciiData) != 0) { NS_ERROR("unexpected result"); return false; } if (len != sizeof(kAsciiData)-1) { NS_ERROR("unexpected result"); return false; } NS_CStringContainerFinish(temp); NS_CStringContainerFinish(s); return true; }
bool nsACString::Equals(const self_type &other, ComparatorFunc c) const { const char_type *cself; const char_type *cother; uint32_t selflen = NS_CStringGetData(*this, &cself); uint32_t otherlen = NS_CStringGetData(other, &cother); if (selflen != otherlen) return false; return c(cself, cother, selflen) == 0; }
PRBool nsACString::Equals(const self_type &other, ComparatorFunc c) const { const char_type *cself; const char_type *cother; PRUint32 selflen = NS_CStringGetData(*this, &cself); PRUint32 otherlen = NS_CStringGetData(other, &cother); if (selflen != otherlen) return PR_FALSE; return c(cself, cother, selflen) == 0; }
const char *nsStringToUTF8(const nsAString &str) { const char *cStr; nsCString tmpStr; CopyUTF16toUTF8(str, tmpStr); NS_CStringGetData(tmpStr, &cStr); return strdup(cStr); }
const nsACString::char_type* nsACString::EndReading() const { const char_type *data; uint32_t len = NS_CStringGetData(*this, &data); return data + len; }
const nsACString::char_type* nsACString::BeginReading() const { const char_type *data; NS_CStringGetData(*this, &data); return data; }
static bool test_replace_driver(const char *strVal, const char *matchVal, const char *newVal, const char *finalVal) { nsCStringContainer a; NS_CStringContainerInit(a); NS_CStringSetData(a, strVal); nsCStringContainer b; NS_CStringContainerInit(b); NS_CStringSetData(b, matchVal); nsCStringContainer c; NS_CStringContainerInit(c); NS_CStringSetData(c, newVal); ReplaceSubstring(a, b, c); const char *data; NS_CStringGetData(a, &data); if (strcmp(data, finalVal) != 0) return false; NS_CStringContainerFinish(c); NS_CStringContainerFinish(b); NS_CStringContainerFinish(a); return true; }
MPAPI::Decoder *AndroidMediaPluginHost::CreateDecoder(MediaResource *aResource, const MediaContentType& aMimeType) { NS_ENSURE_TRUE(aResource, nullptr); nsAutoPtr<Decoder> decoder(new Decoder()); if (!decoder) { return nullptr; } const char *chars; size_t len = NS_CStringGetData(aMimeType.Type().AsString(), &chars, nullptr); for (size_t n = 0; n < mPlugins.Length(); ++n) { Manifest *plugin = mPlugins[n]; const char* const *codecs; if (!plugin->CanDecode(chars, len, &codecs)) { continue; } nsCString url; nsresult rv = mResourceServer->AddResource(aResource, url); if (NS_FAILED (rv)) continue; decoder->mResource = strdup(url.get()); if (plugin->CreateDecoder(&sPluginHost, decoder, chars, len)) { return decoder.forget(); } } return nullptr; }
bool GStreamerFormatHelper::CanHandleMediaType(const nsACString& aMIMEType, const nsAString* aCodecs) { if (!sLoadOK) { return false; } const char *type; NS_CStringGetData(aMIMEType, &type, nullptr); GstCaps *caps; if (aCodecs && !aCodecs->IsEmpty()) { caps = ConvertFormatsToCaps(type, aCodecs); } else { // Get a minimal set of codec caps for this MIME type we should support so // that we don't overreport MIME types we are able to play. caps = GetDefaultCapsFromMIMEType(type); } if (!caps) { return false; } bool ret = HaveElementsToProcessCaps(caps); gst_caps_unref(caps); return ret; }
int32_t nsACString::Compare(const self_type &other, ComparatorFunc c) const { const char_type *cself, *cother; uint32_t selflen = NS_CStringGetData(*this, &cself); uint32_t otherlen = NS_CStringGetData(other, &cother); uint32_t comparelen = selflen <= otherlen ? selflen : otherlen; int32_t result = c(cself, cother, comparelen); if (result == 0) { if (selflen < otherlen) return -1; else if (selflen > otherlen) return 1; } return result; }
uint32_t nsACString::BeginReading(const char_type **begin, const char_type **end) const { uint32_t len = NS_CStringGetData(*this, begin); if (end) *end = *begin + len; return len; }
/* Open Clucene readable database */ NS_IMETHODIMP CluceneAccessor::OpenReadableDatabase(const nsACString &unixDirectory, const nsACString &winDirectory, mozbool *retVal) { *retVal = PR_TRUE; const char *directoryPath; #ifdef _WIN32 NS_CStringGetData(winDirectory, &directoryPath); #else NS_CStringGetData(unixDirectory, &directoryPath); #endif try { this->searcher = new kiwix::CluceneSearcher(directoryPath); } catch (...) { *retVal = PR_FALSE; } return NS_OK; }
uint32_t nsACString::BeginReading(const char_type** aBegin, const char_type** aEnd) const { uint32_t len = NS_CStringGetData(*this, aBegin); if (aEnd) { *aEnd = *aBegin + len; } return len; }
bool nsACString::Equals(const char_type *other, ComparatorFunc c) const { const char_type *cself; PRUint32 selflen = NS_CStringGetData(*this, &cself); PRUint32 otherlen = strlen(other); if (selflen != otherlen) return false; return c(cself, other, selflen) == 0; }
nsDependentCSubstring::nsDependentCSubstring(const abstract_string_type& aStr, uint32_t aStartPos) { const char* data; uint32_t len = NS_CStringGetData(aStr, &data); if (aStartPos > len) aStartPos = len; NS_CStringContainerInit2(*this, data + aStartPos, len - aStartPos, NS_CSTRING_CONTAINER_INIT_DEPEND | NS_CSTRING_CONTAINER_INIT_SUBSTRING); }
bool nsACString::Equals(const char_type* aOther, ComparatorFunc aComparator) const { const char_type* cself; uint32_t selflen = NS_CStringGetData(*this, &cself); uint32_t otherlen = strlen(aOther); if (selflen != otherlen) { return false; } return aComparator(cself, aOther, selflen) == 0; }
const char *nsStringToCString(const nsAString &str) { const char *cStr; nsCString tmpStr; #ifdef _WIN32 LossyCopyUTF16toASCII(str, tmpStr); #else CopyUTF16toUTF8(str, tmpStr); #endif NS_CStringGetData(tmpStr, &cStr); return strdup(cStr); }
static int CompareCString(const nsCString* aCString1, const nsCString* aCString2, void*) { #ifdef MOZILLA_INTERNAL_API return Compare(*aCString1, *aCString2); #else const char* s1; const char* s2; PRUint32 len1 = NS_CStringGetData(*aCString1, &s1); PRUint32 len2 = NS_CStringGetData(*aCString2, &s2); int r = memcmp(s1, s2, PR_MIN(len1, len2)); if (r) return r; if (len1 < len2) return -1; if (len1 > len2) return 1; return 0; #endif }
static bool test_compress_ws() { nsCStringContainer s; NS_CStringContainerInit(s); NS_CStringSetData(s, " \thello world\r \n"); CompressWhitespace(s); const char *d; NS_CStringGetData(s, &d); bool rv = !strcmp(d, "hello world"); if (!rv) printf("=> \"%s\"\n", d); NS_CStringContainerFinish(s); return rv; }
bool MediaPluginHost::FindDecoder(const nsACString& aMimeType, const char* const** aCodecs) { const char *chars; size_t len = NS_CStringGetData(aMimeType, &chars, nullptr); for (size_t n = 0; n < mPlugins.Length(); ++n) { Manifest *plugin = mPlugins[n]; const char* const *codecs; if (plugin->CanDecode(chars, len, &codecs)) { if (aCodecs) *aCodecs = codecs; return true; } } return false; }
/* Search strings in the database */ NS_IMETHODIMP CluceneAccessor::Search(const nsACString &search, mozuint32 resultStart, mozuint32 resultEnd, mozbool *retVal) { *retVal = PR_TRUE; const char *csearch; NS_CStringGetData(search, &csearch, NULL); try { std::string searchString = std::string(csearch); this->searcher->search(searchString, resultStart, resultEnd); } catch (exception &e) { cerr << e.what() << endl; *retVal = PR_FALSE; } return NS_OK; }
static bool test_depend() { static const char kData[] = "hello world"; nsCStringContainer s; NS_ENSURE_SUCCESS( NS_CStringContainerInit2(s, kData, sizeof(kData)-1, NS_CSTRING_CONTAINER_INIT_DEPEND), false); const char *sd; NS_CStringGetData(s, &sd); bool rv = (sd == kData); NS_CStringContainerFinish(s); return rv; }
nsDependentCSubstring::nsDependentCSubstring(const abstract_string_type& aStr, PRUint32 aStartPos, PRUint32 aLength) { const char* data; PRUint32 len = NS_CStringGetData(aStr, &data); if (aStartPos > len) aStartPos = len; if (aStartPos + aLength > len) aLength = len - aStartPos; NS_CStringContainerInit2(*this, data + aStartPos, aLength, NS_CSTRING_CONTAINER_INIT_DEPEND | NS_CSTRING_CONTAINER_INIT_SUBSTRING); }
PRInt32 nsACString::Compare(const char_type *other, ComparatorFunc c) const { const char_type *cself; PRUint32 selflen = NS_CStringGetData(*this, &cself); PRUint32 otherlen = strlen(other); PRUint32 comparelen = selflen <= otherlen ? selflen : otherlen; PRInt32 result = c(cself, other, comparelen); if (result == 0) { if (selflen < otherlen) return -1; else if (selflen > otherlen) return 1; } return result; }
int32_t nsACString::Compare(const char_type* aOther, ComparatorFunc aComparator) const { const char_type* cself; uint32_t selflen = NS_CStringGetData(*this, &cself); uint32_t otherlen = strlen(aOther); uint32_t comparelen = selflen <= otherlen ? selflen : otherlen; int32_t result = aComparator(cself, aOther, comparelen); if (result == 0) { if (selflen < otherlen) { return -1; } else if (selflen > otherlen) { return 1; } } return result; }
static bool test_depend_sub() { static const char kData[] = "hello world"; nsCStringContainer s; NS_ENSURE_SUCCESS( NS_CStringContainerInit2(s, kData, sizeof(kData)-1, NS_CSTRING_CONTAINER_INIT_DEPEND | NS_CSTRING_CONTAINER_INIT_SUBSTRING), false); bool terminated; const char *sd; uint32_t len = NS_CStringGetData(s, &sd, &terminated); bool rv = (sd == kData && len == sizeof(kData)-1 && !terminated); NS_CStringContainerFinish(s); return rv; }