void
nsTextBoxFrame::UpdateAccessIndex()
{
PRInt32 menuAccessKey;
nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
if (menuAccessKey) {
if (mAccessKey.IsEmpty()) {
if (mAccessKeyInfo) {
delete mAccessKeyInfo;
mAccessKeyInfo = nsnull;
}
} else {
if (!mAccessKeyInfo) {
mAccessKeyInfo = new nsAccessKeyInfo();
if (!mAccessKeyInfo)
return;
}
nsAString::const_iterator start, end;
mCroppedTitle.BeginReading(start);
mCroppedTitle.EndReading(end);
// remember the beginning of the string
nsAString::const_iterator originalStart = start;
PRBool found;
if (!AlwaysAppendAccessKey()) {
// not appending access key - do case-sensitive search
// first
found = FindInReadable(mAccessKey, start, end);
if (!found) {
// didn't find it - perform a case-insensitive search
start = originalStart;
found = FindInReadable(mAccessKey, start, end,
nsCaseInsensitiveStringComparator());
}
} else {
found = RFindInReadable(mAccessKey, start, end,
nsCaseInsensitiveStringComparator());
}
if (found)
mAccessKeyInfo->mAccesskeyIndex = Distance(originalStart, start);
else
mAccessKeyInfo->mAccesskeyIndex = kNotFound;
}
}
}
static bool
GetAppPaths(nsCString &aAppPath, nsCString &aAppBinaryPath)
{
nsAutoCString appPath;
nsAutoCString appBinaryPath(
(CommandLine::ForCurrentProcess()->argv()[0]).c_str());
nsAutoCString::const_iterator start, end;
appBinaryPath.BeginReading(start);
appBinaryPath.EndReading(end);
if (RFindInReadable(NS_LITERAL_CSTRING(".app/Contents/MacOS/"), start, end)) {
end = start;
++end; ++end; ++end; ++end;
appBinaryPath.BeginReading(start);
appPath.Assign(Substring(start, end));
} else {
return false;
}
nsCOMPtr<nsIFile> app, appBinary;
nsresult rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(appPath),
true, getter_AddRefs(app));
if (NS_FAILED(rv)) {
return false;
}
rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(appBinaryPath),
true, getter_AddRefs(appBinary));
if (NS_FAILED(rv)) {
return false;
}
bool isLink;
app->IsSymlink(&isLink);
if (isLink) {
app->GetNativeTarget(aAppPath);
} else {
app->GetNativePath(aAppPath);
}
appBinary->IsSymlink(&isLink);
if (isLink) {
appBinary->GetNativeTarget(aAppBinaryPath);
} else {
appBinary->GetNativePath(aAppBinaryPath);
}
return true;
}
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;
}
static bool
GetAppPaths(nsCString &aAppPath, nsCString &aAppBinaryPath)
{
nsAutoCString appPath;
nsAutoCString appBinaryPath(
(CommandLine::ForCurrentProcess()->argv()[0]).c_str());
nsAutoCString::const_iterator start, end;
appBinaryPath.BeginReading(start);
appBinaryPath.EndReading(end);
if (RFindInReadable(NS_LITERAL_CSTRING(".app/Contents/MacOS/"), start, end)) {
end = start;
++end; ++end; ++end; ++end;
appBinaryPath.BeginReading(start);
appPath.Assign(Substring(start, end));
} else {
return false;
}
nsCOMPtr<nsIFile> app, appBinary;
nsresult rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(appPath),
true, getter_AddRefs(app));
if (NS_FAILED(rv)) {
return false;
}
rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(appBinaryPath),
true, getter_AddRefs(appBinary));
if (NS_FAILED(rv)) {
return false;
}
// Mac sandbox rules expect paths to actual files and directories -- not
// soft links.
aAppPath = GetNativeTarget(app);
appBinaryPath = GetNativeTarget(appBinary);
return true;
}
/* static */ nsresult
LookupCache::GetLookupFragments(const nsACString& aSpec,
nsTArray<nsCString>* aFragments)
{
aFragments->Clear();
nsACString::const_iterator begin, end, iter;
aSpec.BeginReading(begin);
aSpec.EndReading(end);
iter = begin;
if (!FindCharInReadable('/', iter, end)) {
return NS_OK;
}
const nsCSubstring& host = Substring(begin, iter++);
nsAutoCString path;
path.Assign(Substring(iter, end));
/**
* From the protocol doc:
* For the hostname, the client will try at most 5 different strings. They
* are:
* a) The exact hostname of the url
* b) The 4 hostnames formed by starting with the last 5 components and
* successivly removing the leading component. The top-level component
* can be skipped. This is not done if the hostname is a numerical IP.
*/
nsTArray<nsCString> hosts;
hosts.AppendElement(host);
if (!IsCanonicalizedIP(host)) {
host.BeginReading(begin);
host.EndReading(end);
int numHostComponents = 0;
while (RFindInReadable(NS_LITERAL_CSTRING("."), begin, end) &&
numHostComponents < MAX_HOST_COMPONENTS) {
// don't bother checking toplevel domains
if (++numHostComponents >= 2) {
host.EndReading(iter);
hosts.AppendElement(Substring(end, iter));
}
end = begin;
host.BeginReading(begin);
}
}
/**
* From the protocol doc:
* For the path, the client will also try at most 6 different strings.
* They are:
* a) the exact path of the url, including query parameters
* b) the exact path of the url, without query parameters
* c) the 4 paths formed by starting at the root (/) and
* successively appending path components, including a trailing
* slash. This behavior should only extend up to the next-to-last
* path component, that is, a trailing slash should never be
* appended that was not present in the original url.
*/
nsTArray<nsCString> paths;
nsAutoCString pathToAdd;
path.BeginReading(begin);
path.EndReading(end);
iter = begin;
if (FindCharInReadable('?', iter, end)) {
pathToAdd = Substring(begin, iter);
paths.AppendElement(pathToAdd);
end = iter;
}
int numPathComponents = 1;
iter = begin;
while (FindCharInReadable('/', iter, end) &&
numPathComponents < MAX_PATH_COMPONENTS) {
iter++;
pathToAdd.Assign(Substring(begin, iter));
paths.AppendElement(pathToAdd);
numPathComponents++;
}
// If we haven't already done so, add the full path
if (!pathToAdd.Equals(path)) {
paths.AppendElement(path);
}
// Check an empty path (for whole-domain blacklist entries)
paths.AppendElement(EmptyCString());
for (uint32_t hostIndex = 0; hostIndex < hosts.Length(); hostIndex++) {
for (uint32_t pathIndex = 0; pathIndex < paths.Length(); pathIndex++) {
nsCString key;
key.Assign(hosts[hostIndex]);
key.Append('/');
key.Append(paths[pathIndex]);
LOG(("Checking fragment %s", key.get()));
aFragments->AppendElement(key);
}
}
return NS_OK;
}
PRBool test_rfindinreadable()
{
const char text[] = "jar:jar:file:///c:/software/mozilla/mozilla_2006_02_21.jar!/browser/chrome/classic.jar!/";
nsCAutoString value(text);
nsACString::const_iterator begin, end;
value.BeginReading(begin);
value.EndReading(end);
nsACString::const_iterator delim_begin (begin),
delim_end (end);
// Search for last !/ at the end of the string
if (!RFindInReadable(NS_LITERAL_CSTRING("!/"), delim_begin, delim_end))
return PR_FALSE;
char *r = ToNewCString(Substring(delim_begin, delim_end));
// Should match the last "!/"
if ((delim_end != end) || (strcmp(r, "!/")!=0))
{
printf("r = %s\n", r);
nsMemory::Free(r);
return PR_FALSE;
}
nsMemory::Free(r);
delim_begin = begin;
delim_end = end;
// Search for last jar: but not the first one...
if (!RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
return PR_FALSE;
r = ToNewCString(Substring(delim_begin, delim_end));
// Should not match the first jar:, but the second one
if ((delim_begin == begin) || (strcmp(r, "jar:")!=0))
{
printf("r = %s\n", r);
nsMemory::Free(r);
return PR_FALSE;
}
nsMemory::Free(r);
// Search for jar: in a Substring
delim_begin = begin;
delim_end = begin; for (int i=0;i<6;i++) delim_end++;
if (!RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end)) {
printf("Search for jar: in a Substring\n");
return PR_FALSE;
}
r = ToNewCString(Substring(delim_begin, delim_end));
// Should not match the first jar:, but the second one
if ((delim_begin != begin) || (strcmp(r, "jar:")!=0))
{
printf("r = %s\n", r);
nsMemory::Free(r);
return PR_FALSE;
}
nsMemory::Free(r);
// Should not find a match
delim_begin = begin;
delim_end = end;
if (RFindInReadable(NS_LITERAL_CSTRING("gecko"), delim_begin, delim_end)) {
printf("Should not find a match\n");
return PR_FALSE;
}
// When no match is found, range should be empty
if (delim_begin != delim_end) {
printf("1: When no match is found, range should be empty\n");
return PR_FALSE;
}
// Should not find a match (search not before Substring)
delim_begin = begin; for (int i=0;i<6;i++) delim_begin++;
delim_end = end;
if (RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end)) {
printf("Should not find a match (search not before Substring)\n");
return PR_FALSE;
}
// When no match is found, range should be empty
if (delim_begin != delim_end) {
printf("2: When no match is found, range should be empty\n");
return PR_FALSE;
}
// Should not find a match (search not beyond Substring)
delim_begin = begin;
delim_end = end; for (int i=0;i<7;i++) delim_end--;
if (RFindInReadable(NS_LITERAL_CSTRING("classic"), delim_begin, delim_end)) {
printf("Should not find a match (search not beyond Substring)\n");
return PR_FALSE;
}
// When no match is found, range should be empty
if (delim_begin != delim_end) {
printf("3: When no match is found, range should be empty\n");
return PR_FALSE;
}
return PR_TRUE;
}
PRBool
LocalSearchDataSource::doMatch(nsIRDFLiteral *literal,
const nsAString &matchMethod,
const nsString &matchText)
{
PRBool found = PR_FALSE;
if ((nsnull == literal) ||
matchMethod.IsEmpty() ||
matchText.IsEmpty())
return(found);
const PRUnichar *str = nsnull;
literal->GetValueConst( &str );
if (! str) return(found);
nsAutoString value(str);
if (matchMethod.EqualsLiteral("contains"))
{
if (FindInReadable(matchText, value,
nsCaseInsensitiveStringComparator()))
found = PR_TRUE;
}
else if (matchMethod.EqualsLiteral("startswith"))
{
nsAString::const_iterator start, realstart, end;
value.BeginReading(start);
value.EndReading(end);
realstart = start;
if (FindInReadable(matchText, start, end,
nsCaseInsensitiveStringComparator()) &&
start == realstart)
found = PR_TRUE;
}
else if (matchMethod.EqualsLiteral("endswith"))
{
nsAString::const_iterator start, end, realend;
value.BeginReading(start);
value.EndReading(end);
realend = end;
if (RFindInReadable(matchText, start, end,
nsCaseInsensitiveStringComparator()) &&
end == realend)
found = PR_TRUE;
}
else if (matchMethod.EqualsLiteral("is"))
{
if (value.Equals(matchText, nsCaseInsensitiveStringComparator()))
found = PR_TRUE;
}
else if (matchMethod.EqualsLiteral("isnot"))
{
if (!value.Equals(matchText, nsCaseInsensitiveStringComparator()))
found = PR_TRUE;
}
else if (matchMethod.EqualsLiteral("doesntcontain"))
{
if (!FindInReadable(matchText, value,
nsCaseInsensitiveStringComparator()))
found = PR_TRUE;
}
return(found);
}
nsresult nsSceneTracker::SplitHeading (const nsAString& aHeading,
nsAString& aIntExt,
nsAString& aSetting,
nsAString& aDayNight) {
NS_NAMED_LITERAL_STRING(kSeparatorChars, ". -");
NS_NAMED_LITERAL_STRING(kPrefixChars, ". -0123456789");
nsCOMPtr<nsIPrefService> ps = do_GetService(
"@mozilla.org/preferences-service;1");
nsCOMPtr<nsIPrefBranch> branch;
nsresult rv = ps->GetBranch("celtx.scripteditor.", getter_AddRefs(branch));
if (NS_FAILED(rv))
return rv;
nsXPIDLString strdata;
// Get the int/ext values
nsCOMPtr<nsISupportsString> intextstr;
rv = branch->GetComplexValue("intexts",
NS_GET_IID(nsISupportsString), getter_AddRefs(intextstr));
if (NS_FAILED(rv))
return rv;
intextstr->ToString(getter_Copies(strdata));
nsTArray<nsString> intexts;
intexts.AppendElement(NS_LITERAL_STRING("INT"));
intexts.AppendElement(NS_LITERAL_STRING("EXT"));
nsXPIDLString::size_type startoffset = 0;
nsXPIDLString::size_type endoffset = strdata.FindChar(PRUnichar(','));
while (PRInt32(endoffset) > 0) {
intexts.AppendElement(Substring(strdata, startoffset,
endoffset - startoffset));
startoffset = endoffset + 1;
endoffset = strdata.FindChar(PRUnichar(','), startoffset);
}
if (startoffset < strdata.Length())
intexts.AppendElement(Substring(strdata, startoffset,
strdata.Length() - startoffset));
// Get the day/night values
nsCOMPtr<nsISupportsString> daynightstr;
rv = branch->GetComplexValue("daynights",
NS_GET_IID(nsISupportsString), getter_AddRefs(daynightstr));
if (NS_FAILED(rv))
return rv;
daynightstr->ToString(getter_Copies(strdata));
nsTArray<nsString> daynights;
startoffset = 0;
endoffset = strdata.FindChar(PRUnichar(','));
while (PRInt32(endoffset) > 0) {
daynights.AppendElement(Substring(strdata, startoffset,
endoffset - startoffset));
startoffset = endoffset + 1;
endoffset = strdata.FindChar(PRUnichar(','), startoffset);
}
if (startoffset < strdata.Length())
daynights.AppendElement(Substring(strdata, startoffset,
strdata.Length() - startoffset));
aIntExt.Truncate();
aSetting.Truncate();
aDayNight.Truncate();
nsAString::const_iterator start, end;
aHeading.BeginReading(start);
aHeading.EndReading(end); // This is a one-past-the-end pointer!
PRUint32 maxfindlen = 0;
// Skip any prefix characters (e.g., scene numbers)
while (kPrefixChars.FindChar(*start) >= 0)
++start;
// Find the longest match for an int/ext string
for (PRUint32 i = 0; i < intexts.Length(); ++i) {
const nsAString& pattern = intexts[i];
nsAString::const_iterator aStart = start;
nsAString::const_iterator aEnd = end;
if (pattern.Length() <= maxfindlen)
continue;
if (CaseInsensitiveFindInReadable(pattern, aStart, aEnd) &&
aStart == start) {
maxfindlen = pattern.Length();
// The odds of assigning more than once should be zero for most locales
aIntExt = pattern;
}
}
start.advance(maxfindlen);
// Skip any separator characters
while (*start && kSeparatorChars.FindChar(*start) >= 0)
++start;
// Find the longest match for a day/night string
maxfindlen = 0;
nsCaseInsensitiveStringComparator insensitive;
for (PRUint32 i = 0; i < daynights.Length(); ++i) {
const nsAString& pattern = daynights[i];
nsAString::const_iterator aStart = start;
nsAString::const_iterator aEnd = end;
if (pattern.Length() <= maxfindlen)
continue;
if (RFindInReadable(pattern, aStart, aEnd, insensitive) && aEnd == end) {
maxfindlen = pattern.Length();
aDayNight = pattern;
}
}
if (maxfindlen > 0)
// Remember: End is one-past-the-end
end.advance(- (PRInt32)(maxfindlen + 1));
else if (end != start)
--end;
// Skip any separator characters
while (*end && kSeparatorChars.FindChar(*end) >= 0)
--end;
aSetting = Substring(start, *end ? ++end : end);
return NS_OK;
}
