JSAtom * js::AtomizeString(JSContext *cx, JSString *str, js::InternBehavior ib /* = js::DoNotInternAtom */) { if (str->isAtom()) { JSAtom &atom = str->asAtom(); /* N.B. static atoms are effectively always interned. */ if (ib != InternAtom || js::StaticStrings::isStatic(&atom)) return &atom; AtomSet::Ptr p = cx->runtime->atoms.lookup(AtomHasher::Lookup(&atom)); JS_ASSERT(p); /* Non-static atom must exist in atom state set. */ JS_ASSERT(p->asPtr() == &atom); JS_ASSERT(ib == InternAtom); p->setTagged(bool(ib)); return &atom; } const jschar *chars = str->getChars(cx); if (!chars) return NULL; if (JSAtom *atom = AtomizeAndCopyChars<NoGC>(cx, chars, str->length(), ib)) return atom; if (!allowGC) return NULL; JSLinearString *linear = str->ensureLinear(cx); if (!linear) return NULL; JS_ASSERT(linear->length() <= JSString::MAX_LENGTH); return AtomizeAndCopyChars<CanGC>(cx, linear->chars(), linear->length(), ib); }
JSAtom * js_AtomizeString(JSContext *cx, JSString *str, InternBehavior ib) { if (str->isAtom()) { JSAtom &atom = str->asAtom(); /* N.B. static atoms are effectively always interned. */ if (ib != InternAtom || atom.isStaticAtom()) return &atom; /* Here we have to check whether the atom is already interned. */ AutoLockAtomsCompartment lock(cx); AtomSet &atoms = cx->runtime->atomState.atoms; AtomSet::Ptr p = atoms.lookup(AtomHasher::Lookup(&atom)); JS_ASSERT(p); /* Non-static atom must exist in atom state set. */ JS_ASSERT(p->asPtr() == &atom); JS_ASSERT(ib == InternAtom); p->setTagged(bool(ib)); return &atom; } if (str->isAtom()) return &str->asAtom(); size_t length = str->length(); const jschar *chars = str->getChars(cx); if (!chars) return NULL; JS_ASSERT(length <= JSString::MAX_LENGTH); return Atomize(cx, &chars, length, ib); }
JSAtom * js::AtomizeString(ExclusiveContext *cx, JSString *str, js::InternBehavior ib /* = js::DoNotInternAtom */) { if (str->isAtom()) { JSAtom &atom = str->asAtom(); /* N.B. static atoms are effectively always interned. */ if (ib != InternAtom || js::StaticStrings::isStatic(&atom)) return &atom; AtomHasher::Lookup lookup(&atom); /* Likewise, permanent atoms are always interned. */ AtomSet::Ptr p = cx->permanentAtoms().readonlyThreadsafeLookup(lookup); if (p) return &atom; AutoLockForExclusiveAccess lock(cx); p = cx->atoms().lookup(lookup); JS_ASSERT(p); /* Non-static atom must exist in atom state set. */ JS_ASSERT(p->asPtr() == &atom); JS_ASSERT(ib == InternAtom); p->setTagged(bool(ib)); return &atom; } const jschar *chars = str->getChars(cx); if (!chars) return nullptr; return AtomizeAndCopyChars(cx, chars, str->length(), ib); }
JSAtom * js::AtomizeString(ExclusiveContext *cx, JSString *str, js::InternBehavior ib /* = js::DoNotInternAtom */) { if (str->isAtom()) { JSAtom &atom = str->asAtom(); /* N.B. static atoms are effectively always interned. */ if (ib != InternAtom || js::StaticStrings::isStatic(&atom)) return &atom; AtomHasher::Lookup lookup(&atom); /* Likewise, permanent atoms are always interned. */ MOZ_ASSERT(cx->isPermanentAtomsInitialized()); AtomSet::Ptr p = cx->permanentAtoms().readonlyThreadsafeLookup(lookup); if (p) return &atom; AutoLockForExclusiveAccess lock(cx); p = cx->atoms().lookup(lookup); MOZ_ASSERT(p); /* Non-static atom must exist in atom state set. */ MOZ_ASSERT(p->asPtr() == &atom); MOZ_ASSERT(ib == InternAtom); p->setTagged(bool(ib)); return &atom; } JSLinearString *linear = str->ensureLinear(cx); if (!linear) return nullptr; JS::AutoCheckCannotGC nogc; return linear->hasLatin1Chars() ? AtomizeAndCopyChars(cx, linear->latin1Chars(nogc), linear->length(), ib) : AtomizeAndCopyChars(cx, linear->twoByteChars(nogc), linear->length(), ib); }