nsresult
XMLUtils::splitQName(const nsAString& aName, nsIAtom** aPrefix,
nsIAtom** aLocalName)
{
const nsAFlatString& qName = PromiseFlatString(aName);
const PRUnichar* colon;
bool valid = XMLUtils::isValidQName(qName, &colon);
if (!valid) {
return NS_ERROR_FAILURE;
}
if (colon) {
const PRUnichar *end;
qName.EndReading(end);
*aPrefix = NS_NewAtom(Substring(qName.get(), colon));
*aLocalName = NS_NewAtom(Substring(colon + 1, end));
}
else {
*aPrefix = nsnull;
*aLocalName = NS_NewAtom(aName);
}
return NS_OK;
}
// static
nsresult
XMLUtils::splitExpatName(const PRUnichar *aExpatName, nsIAtom **aPrefix,
nsIAtom **aLocalName, PRInt32* aNameSpaceID)
{
/**
* Expat can send the following:
* localName
* namespaceURI<separator>localName
* namespaceURI<separator>localName<separator>prefix
*/
const PRUnichar *uriEnd = nsnull;
const PRUnichar *nameEnd = nsnull;
const PRUnichar *pos;
for (pos = aExpatName; *pos; ++pos) {
if (*pos == kExpatSeparatorChar) {
if (uriEnd) {
nameEnd = pos;
}
else {
uriEnd = pos;
}
}
}
const PRUnichar *nameStart;
if (uriEnd) {
*aNameSpaceID =
txNamespaceManager::getNamespaceID(nsDependentSubstring(aExpatName,
uriEnd));
if (*aNameSpaceID == kNameSpaceID_Unknown) {
return NS_ERROR_FAILURE;
}
nameStart = (uriEnd + 1);
if (nameEnd) {
const PRUnichar *prefixStart = nameEnd + 1;
*aPrefix = NS_NewAtom(NS_ConvertUTF16toUTF8(prefixStart,
pos - prefixStart));
if (!*aPrefix) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
else {
nameEnd = pos;
*aPrefix = nsnull;
}
}
else {
*aNameSpaceID = kNameSpaceID_None;
nameStart = aExpatName;
nameEnd = pos;
*aPrefix = nsnull;
}
*aLocalName = NS_NewAtom(NS_ConvertUTF16toUTF8(nameStart,
nameEnd - nameStart));
return *aLocalName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
const nsDependentSubstring
RDFContentSinkImpl::SplitExpatName(const PRUnichar *aExpatName,
nsIAtom **aLocalName)
{
/**
* Expat can send the following:
* localName
* namespaceURI<separator>localName
* namespaceURI<separator>localName<separator>prefix
*
* and we use 0xFFFF for the <separator>.
*
*/
const PRUnichar *uriEnd = aExpatName;
const PRUnichar *nameStart = aExpatName;
const PRUnichar *pos;
for (pos = aExpatName; *pos; ++pos) {
if (*pos == 0xFFFF) {
if (uriEnd != aExpatName) {
break;
}
uriEnd = pos;
nameStart = pos + 1;
}
}
const nsDependentSubstring& nameSpaceURI = Substring(aExpatName, uriEnd);
*aLocalName = NS_NewAtom(NS_ConvertUTF16toUTF8(nameStart,
pos - nameStart));
return nameSpaceURI;
}
/* static */
already_AddRefed<nsIAtom>
txXPathNodeUtils::getLocalName(const txXPathNode& aNode)
{
if (aNode.isDocument()) {
return nsnull;
}
if (aNode.isContent()) {
if (aNode.mNode->IsElement()) {
nsIAtom* localName = aNode.Content()->Tag();
NS_ADDREF(localName);
return localName;
}
if (aNode.mNode->IsNodeOfType(nsINode::ePROCESSING_INSTRUCTION)) {
nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aNode.mNode);
nsAutoString target;
node->GetNodeName(target);
return NS_NewAtom(target);
}
return nsnull;
}
nsIAtom* localName = aNode.Content()->
GetAttrNameAt(aNode.mIndex)->LocalName();
NS_ADDREF(localName);
return localName;
}
NS_IMETHODIMP
nsCharsetConverterManager::GetCharsetLangGroupRaw(const char * aCharset,
nsIAtom** aResult)
{
*aResult = nsnull;
if (aCharset == NULL)
return NS_ERROR_NULL_POINTER;
nsresult rv = NS_OK;
if (mDataBundle == NULL) {
rv = LoadExtensibleBundle(NS_DATA_BUNDLE_CATEGORY, &mDataBundle);
if (NS_FAILED(rv))
return rv;
}
nsAutoString langGroup;
rv = GetBundleValue(mDataBundle, aCharset, NS_LITERAL_STRING(".LangGroup"), langGroup);
if (NS_SUCCEEDED(rv)) {
ToLowerCase(langGroup); // use lowercase for all language atoms
*aResult = NS_NewAtom(langGroup);
}
return rv;
}
void
nsAttrValue::SetMiscAtomOrString(const nsAString* aValue)
{
NS_ASSERTION(GetMiscContainer(), "Must have MiscContainer!");
NS_ASSERTION(!GetMiscContainer()->mStringBits,
"Trying to re-set atom or string!");
if (aValue) {
PRUint32 len = aValue->Length();
// We're allowing eCSSStyleRule attributes to store empty strings as it
// can be beneficial to store an empty style attribute as a parsed rule.
// Add other types as needed.
NS_ASSERTION(len || Type() == eCSSStyleRule, "Empty string?");
MiscContainer* cont = GetMiscContainer();
if (len <= NS_ATTRVALUE_MAX_STRINGLENGTH_ATOM) {
nsIAtom* atom = NS_NewAtom(*aValue);
if (atom) {
cont->mStringBits = reinterpret_cast<PtrBits>(atom) | eAtomBase;
}
} else {
nsStringBuffer* buf = GetStringBuffer(*aValue);
if (buf) {
cont->mStringBits = reinterpret_cast<PtrBits>(buf) | eStringBase;
}
}
}
}
// answers true if the CSS property accepts more than one value
PRBool
ChangeCSSInlineStyleTxn::AcceptsMoreThanOneValue(nsIAtom *aCSSProperty)
{
nsIAtom * textDecorationAtom = NS_NewAtom("text-decoration");
PRBool res = (textDecorationAtom == aCSSProperty);
NS_IF_RELEASE(textDecorationAtom);
return res;
}
void
nsAttrValue::ParseAtom(const nsAString& aValue)
{
ResetIfSet();
nsIAtom* atom = NS_NewAtom(aValue);
if (atom) {
SetPtrValueAndType(atom, eAtomBase);
}
}
nsresult
nsAtomService::GetAtom(const PRUnichar *aString, nsIAtom ** aResult)
{
*aResult = NS_NewAtom(aString);
if (!*aResult)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
NS_IMETHODIMP
nsAtomService::GetAtomUTF8(const char *aValue, nsIAtom* *aResult)
{
*aResult = NS_NewAtom(aValue);
if (!*aResult)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
nsresult
txExprParser::resolveQName(const nsAString& aQName,
nsIAtom** aPrefix, txIParseContext* aContext,
nsIAtom** aLocalName, int32_t& aNamespace,
bool aIsNameTest)
{
aNamespace = kNameSpaceID_None;
int32_t idx = aQName.FindChar(':');
if (idx > 0) {
*aPrefix = NS_NewAtom(StringHead(aQName, (uint32_t)idx)).get();
if (!*aPrefix) {
return NS_ERROR_OUT_OF_MEMORY;
}
*aLocalName = NS_NewAtom(Substring(aQName, (uint32_t)idx + 1,
aQName.Length() - (idx + 1))).get();
if (!*aLocalName) {
NS_RELEASE(*aPrefix);
return NS_ERROR_OUT_OF_MEMORY;
}
return aContext->resolveNamespacePrefix(*aPrefix, aNamespace);
}
// the lexer dealt with idx == 0
*aPrefix = 0;
if (aIsNameTest && aContext->caseInsensitiveNameTests()) {
nsAutoString lcname;
nsContentUtils::ASCIIToLower(aQName, lcname);
*aLocalName = NS_NewAtom(lcname).get();
}
else {
*aLocalName = NS_NewAtom(aQName).get();
}
if (!*aLocalName) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
void
nsAttrValue::ParseAtom(const nsAString& aValue)
{
ResetIfSet();
nsIAtom* atom = NS_NewAtom(aValue);
if (atom) {
SetPtrValueAndType(atom, eAtomBase);
}
#ifdef TAINTED
if(aValue.isTainted()==1){
mTainted=1;
mJSStr=aValue.getJSReference();
}
#endif
}
nsresult nsStatusBarBiffManager::Init()
{
if (mInitialized)
return NS_ERROR_ALREADY_INITIALIZED;
nsresult rv;
kBiffStateAtom = NS_NewAtom("BiffState");
nsCOMPtr<nsIMsgMailSession> mailSession =
do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
if(NS_SUCCEEDED(rv))
mailSession->AddFolderListener(this, nsIFolderListener::intPropertyChanged);
mInitialized = PR_TRUE;
return NS_OK;
}
nsFind::nsFind()
: mFindBackward(PR_FALSE)
, mCaseSensitive(PR_FALSE)
, mIterOffset(0)
{
// Initialize the atoms if they aren't already:
if (sInstanceCount <= 0)
{
sImgAtom = NS_NewAtom("img");
sHRAtom = NS_NewAtom("hr");
sScriptAtom = NS_NewAtom("script");
sNoframesAtom = NS_NewAtom("noframes");
sSelectAtom = NS_NewAtom("select");
sTextareaAtom = NS_NewAtom("textarea");
sThAtom = NS_NewAtom("th");
sTdAtom = NS_NewAtom("td");
}
++sInstanceCount;
}
NS_IMETHODIMP
nsCharsetConverterManager::GetCharsetLangGroupRaw(const char * aCharset,
nsIAtom** aResult)
{
*aResult = nullptr;
nsAutoString langGroup;
// fully qualify to possibly avoid vtable call
nsresult rv = nsCharsetConverterManager::GetCharsetData(
aCharset, NS_LITERAL_STRING(".LangGroup").get(), langGroup);
if (NS_SUCCEEDED(rv)) {
ToLowerCase(langGroup); // use lowercase for all language atoms
*aResult = NS_NewAtom(langGroup);
}
return rv;
}
nsMsgAccountManagerDataSource::nsMsgAccountManagerDataSource()
{
#ifdef DEBUG_amds
printf("nsMsgAccountManagerDataSource() being created\n");
#endif
// do per-class initialization here
if (gAccountManagerResourceRefCnt++ == 0) {
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_CHILD), &kNC_Child);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_NAME), &kNC_Name);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREENAME),
&kNC_FolderTreeName);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREESIMPLENAME),
&kNC_FolderTreeSimpleName);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_NAME_SORT), &kNC_NameSort);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREENAME_SORT),
&kNC_FolderTreeNameSort);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETAG), &kNC_PageTag);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_ISDEFAULTSERVER),
&kNC_IsDefaultServer);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_SUPPORTSFILTERS),
&kNC_SupportsFilters);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANGETMESSAGES),
&kNC_CanGetMessages);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANGETINCOMINGMESSAGES),
&kNC_CanGetIncomingMessages);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_ACCOUNT), &kNC_Account);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_SERVER), &kNC_Server);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_IDENTITY), &kNC_Identity);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_JUNK), &kNC_Junk);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_MAIN),
&kNC_PageTitleMain);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_SERVER),
&kNC_PageTitleServer);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_COPIES),
&kNC_PageTitleCopies);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_OFFLINEANDDISKSPACE),
&kNC_PageTitleOfflineAndDiskSpace);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_DISKSPACE),
&kNC_PageTitleDiskSpace);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_ADDRESSING),
&kNC_PageTitleAddressing);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_SMTP),
&kNC_PageTitleSMTP);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_JUNK),
&kNC_PageTitleJunk);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_FAKEACCOUNT),
&kNC_PageTitleFakeAccount);
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_ACCOUNTROOT),
&kNC_AccountRoot);
getRDFService()->GetLiteral(NS_LITERAL_STRING("true").get(),
&kTrueLiteral);
// eventually these need to exist in some kind of array
// that's easily extensible
getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_SETTINGS), &kNC_Settings);
kDefaultServerAtom = NS_NewAtom("DefaultServer");
}
nsCOMPtr<nsIPrefBranch2> prefBranchInternal(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (prefBranchInternal)
prefBranchInternal->AddObserver(PREF_SHOW_FAKE_ACCOUNT, this, PR_FALSE);
}
int main(int argc, char** argv)
{
FILE* fp = fopen("words.txt", "r");
if (nsnull == fp) {
printf("can't open words.txt\n");
return -1;
}
PRInt32 count = 0;
PRUnichar** strings = new PRUnichar*[60000];
nsIAtom** ids = new nsIAtom*[60000];
nsAutoString s1, s2;
PRTime start = PR_Now();
PRInt32 i;
for (i = 0; i < 60000; i++) {
char buf[1000];
char* s = fgets(buf, sizeof(buf), fp);
if (nsnull == s) {
break;
}
nsCAutoString sb;
sb.Assign(buf);
strings[count++] = ToNewUnicode(sb);
ToUpperCase(sb);
strings[count++] = ToNewUnicode(sb);
}
PRTime end0 = PR_Now();
// Find and create idents
for (i = 0; i < count; i++) {
ids[i] = NS_NewAtom(strings[i]);
}
PRUnichar qqs[1]; qqs[0] = 0;
nsIAtom* qq = NS_NewAtom(qqs);
PRTime end1 = PR_Now();
// Now make sure we can find all the idents we just made
for (i = 0; i < count; i++) {
const char *utf8String;
ids[i]->GetUTF8String(&utf8String);
nsIAtom* id = NS_NewAtom(utf8String);
if (id != ids[i]) {
id->ToString(s1);
ids[i]->ToString(s2);
printf("find failed: id='%s' ids[%d]='%s'\n",
NS_LossyConvertUTF16toASCII(s1).get(), i, NS_LossyConvertUTF16toASCII(s2).get());
return -1;
}
NS_RELEASE(id);
}
PRTime end2 = PR_Now();
// Destroy all the atoms we just made
NS_RELEASE(qq);
for (i = 0; i < count; i++) {
NS_RELEASE(ids[i]);
}
// Print out timings
PRTime end3 = PR_Now();
PRTime creates, finds, lookups, dtor, ustoms;
LL_I2L(ustoms, 1000);
LL_SUB(creates, end0, start);
LL_DIV(creates, creates, ustoms);
LL_SUB(finds, end1, end0);
LL_DIV(finds, finds, ustoms);
LL_SUB(lookups, end2, end1);
LL_DIV(lookups, lookups, ustoms);
LL_SUB(dtor, end3, end2);
char buf[500];
PR_snprintf(buf, sizeof(buf), "making %d ident strings took %lldms",
count, creates);
puts(buf);
PR_snprintf(buf, sizeof(buf), "%d new idents took %lldms",
count, finds);
puts(buf);
PR_snprintf(buf, sizeof(buf), "%d ident lookups took %lldms",
count, lookups);
puts(buf);
PR_snprintf(buf, sizeof(buf), "dtor took %lldusec", dtor);
puts(buf);
printf("%d live atoms\n", NS_GetNumberOfAtoms());
NS_POSTCONDITION(0 == NS_GetNumberOfAtoms(), "dangling atoms");
return 0;
}
