/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/*
* JS atom table.
*/
#include "jsstddef.h"
#include <stdlib.h>
#include <string.h>
#include "jstypes.h"
#include "jsutil.h" /* Added by JSIFY */
#include "jshash.h" /* Added by JSIFY */
#include "jsprf.h"
#include "jsapi.h"
#include "jsatom.h"
#include "jscntxt.h"
#include "jsconfig.h"
#include "jsgc.h"
#include "jslock.h"
#include "jsnum.h"
#include "jsscan.h"
#include "jsstr.h"
const char *
js_AtomToPrintableString(JSContext *cx, JSAtom *atom)
{
return js_ValueToPrintableString(cx, ATOM_KEY(atom));
}
#define JS_PROTO(name,code,init) const char js_##name##_str[] = #name;
#include "jsproto.tbl"
#undef JS_PROTO
/*
* Names for common atoms defined in JSAtomState starting from
* JSAtomState.emptyAtom until JSAtomState.lazy.
*
* The elements of the array after the first empty string define strings
* corresponding to JSType enumerators from jspubtd.h and to two boolean
* literals, false and true. The following assert insists that JSType defines
* exactly 8 types.
*/
JS_STATIC_ASSERT(JSTYPE_LIMIT == 8);
const char *const js_common_atom_names[] = {
"", /* emptyAtom */
js_undefined_str, /* typeAtoms[JSTYPE_VOID] */
js_object_str, /* typeAtoms[JSTYPE_OBJECT] */
js_function_str, /* typeAtoms[JSTYPE_FUNCTION] */
"string", /* typeAtoms[JSTYPE_STRING] */
"number", /* typeAtoms[JSTYPE_NUMBER] */
"boolean", /* typeAtoms[JSTYPE_BOOLEAN] */
js_null_str, /* typeAtoms[JSTYPE_NULL] */
"xml", /* typeAtoms[JSTYPE_XML] */
js_false_str, /* booleanAtoms[0] */
js_true_str, /* booleanAtoms[1] */
js_null_str, /* nullAtom */
#define JS_PROTO(name,code,init) js_##name##_str,
#include "jsproto.tbl"
#undef JS_PROTO
js_anonymous_str, /* anonymousAtom */
js_arguments_str, /* argumentsAtom */
js_arity_str, /* arityAtom */
js_callee_str, /* calleeAtom */
js_caller_str, /* callerAtom */
js_class_prototype_str, /* classPrototypeAtom */
js_constructor_str, /* constructorAtom */
js_count_str, /* countAtom */
js_each_str, /* eachAtom */
js_eval_str, /* evalAtom */
js_fileName_str, /* fileNameAtom */
js_get_str, /* getAtom */
js_getter_str, /* getterAtom */
js_index_str, /* indexAtom */
js_input_str, /* inputAtom */
js_iterator_str, /* iteratorAtom */
js_length_str, /* lengthAtom */
js_lineNumber_str, /* lineNumberAtom */
js_message_str, /* messageAtom */
js_name_str, /* nameAtom */
js_next_str, /* nextAtom */
js_noSuchMethod_str, /* noSuchMethodAtom */
js_parent_str, /* parentAtom */
js_proto_str, /* protoAtom */
js_set_str, /* setAtom */
js_setter_str, /* setterAtom */
js_stack_str, /* stackAtom */
js_toLocaleString_str, /* toLocaleStringAtom */
js_toSource_str, /* toSourceAtom */
js_toString_str, /* toStringAtom */
js_valueOf_str, /* valueOfAtom */
"(void 0)", /* void0Atom */
#if JS_HAS_XML_SUPPORT
js_etago_str, /* etagoAtom */
js_namespace_str, /* namespaceAtom */
js_ptagc_str, /* ptagcAtom */
js_qualifier_str, /* qualifierAtom */
js_space_str, /* spaceAtom */
js_stago_str, /* stagoAtom */
js_star_str, /* starAtom */
js_starQualifier_str, /* starQualifierAtom */
js_tagc_str, /* tagcAtom */
js_xml_str, /* xmlAtom */
#endif
#ifdef NARCISSUS
js_call_str, /* callAtom */
js_construct_str, /* constructAtom */
js_hasInstance_str, /* hasInstanceAtom */
js_ExecutionContext_str, /* ExecutionContextAtom */
js_current_str, /* currentAtom */
#endif
};
JS_STATIC_ASSERT(JS_ARRAY_LENGTH(js_common_atom_names) * sizeof(JSAtom *) ==
LAZY_ATOM_OFFSET_START - ATOM_OFFSET_START);
const char js_anonymous_str[] = "anonymous";
const char js_arguments_str[] = "arguments";
const char js_arity_str[] = "arity";
const char js_callee_str[] = "callee";
const char js_caller_str[] = "caller";
const char js_class_prototype_str[] = "prototype";
const char js_constructor_str[] = "constructor";
const char js_count_str[] = "__count__";
const char js_each_str[] = "each";
const char js_eval_str[] = "eval";
const char js_fileName_str[] = "fileName";
const char js_get_str[] = "get";
const char js_getter_str[] = "getter";
const char js_index_str[] = "index";
const char js_input_str[] = "input";
const char js_iterator_str[] = "__iterator__";
const char js_length_str[] = "length";
const char js_lineNumber_str[] = "lineNumber";
const char js_message_str[] = "message";
const char js_name_str[] = "name";
const char js_next_str[] = "next";
const char js_noSuchMethod_str[] = "__noSuchMethod__";
const char js_object_str[] = "object";
const char js_parent_str[] = "__parent__";
const char js_proto_str[] = "__proto__";
const char js_setter_str[] = "setter";
const char js_set_str[] = "set";
const char js_stack_str[] = "stack";
const char js_toSource_str[] = "toSource";
const char js_toString_str[] = "toString";
const char js_toLocaleString_str[] = "toLocaleString";
const char js_undefined_str[] = "undefined";
const char js_valueOf_str[] = "valueOf";
#if JS_HAS_XML_SUPPORT
const char js_etago_str[] = "</";
const char js_namespace_str[] = "namespace";
const char js_ptagc_str[] = "/>";
const char js_qualifier_str[] = "::";
const char js_space_str[] = " ";
const char js_stago_str[] = "<";
const char js_star_str[] = "*";
const char js_starQualifier_str[] = "*::";
const char js_tagc_str[] = ">";
const char js_xml_str[] = "xml";
#endif
#if JS_HAS_GENERATORS
const char js_close_str[] = "close";
const char js_send_str[] = "send";
#endif
#ifdef NARCISSUS
const char js_call_str[] = "__call__";
const char js_construct_str[] = "__construct__";
const char js_hasInstance_str[] = "__hasInstance__";
const char js_ExecutionContext_str[] = "ExecutionContext";
const char js_current_str[] = "current";
#endif
/*
* JSAtomState.doubleAtoms and JSAtomState.stringAtoms hashtable entry. To
* support pinned and interned string atoms, we use the lowest bits of the
* keyAndFlags field to store ATOM_PINNED and ATOM_INTERNED flags.
*/
typedef struct JSAtomHashEntry {
JSDHashEntryHdr hdr;
jsuword keyAndFlags;
} JSAtomHashEntry;
#define ATOM_ENTRY_FLAG_MASK (ATOM_PINNED | ATOM_INTERNED)
JS_STATIC_ASSERT(ATOM_ENTRY_FLAG_MASK < JSVAL_ALIGN);
/*
* Helper macros to access and modify JSAtomHashEntry.
*/
#define TO_ATOM_ENTRY(hdr) ((JSAtomHashEntry *) hdr)
#define ATOM_ENTRY_KEY(entry) \
((void *)((entry)->keyAndFlags & ~ATOM_ENTRY_FLAG_MASK))
#define ATOM_ENTRY_FLAGS(entry) \
((uintN)((entry)->keyAndFlags & ATOM_ENTRY_FLAG_MASK))
#define INIT_ATOM_ENTRY(entry, key) \
((void)((entry)->keyAndFlags = (jsuword)(key)))
#define ADD_ATOM_ENTRY_FLAGS(entry, flags) \
((void)((entry)->keyAndFlags |= (jsuword)(flags)))
#define CLEAR_ATOM_ENTRY_FLAGS(entry, flags) \
((void)((entry)->keyAndFlags &= ~(jsuword)(flags)))
JS_STATIC_DLL_CALLBACK(JSDHashNumber)
HashDouble(JSDHashTable *table, const void *key);
JS_STATIC_DLL_CALLBACK(JSBool)
MatchDouble(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key);
JS_STATIC_DLL_CALLBACK(JSDHashNumber)
HashString(JSDHashTable *table, const void *key);
JS_STATIC_DLL_CALLBACK(JSBool)
MatchString(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key);
static const JSDHashTableOps DoubleHashOps = {
JS_DHashAllocTable,
JS_DHashFreeTable,
HashDouble,
MatchDouble,
JS_DHashMoveEntryStub,
JS_DHashClearEntryStub,
JS_DHashFinalizeStub,
NULL
};
static const JSDHashTableOps StringHashOps = {
JS_DHashAllocTable,
JS_DHashFreeTable,
HashString,
MatchString,
JS_DHashMoveEntryStub,
JS_DHashClearEntryStub,
JS_DHashFinalizeStub,
NULL
};
#define IS_DOUBLE_TABLE(table) ((table)->ops == &DoubleHashOps)
#define IS_STRING_TABLE(table) ((table)->ops == &StringHashOps)
#define IS_INITIALIZED_STATE(state) IS_DOUBLE_TABLE(&(state)->doubleAtoms)
JS_STATIC_DLL_CALLBACK(JSDHashNumber)
HashDouble(JSDHashTable *table, const void *key)
{
jsdouble d;
JS_ASSERT(IS_DOUBLE_TABLE(table));
d = *(jsdouble *)key;
return JSDOUBLE_HI32(d) ^ JSDOUBLE_LO32(d);
}
JS_STATIC_DLL_CALLBACK(JSDHashNumber)
HashString(JSDHashTable *table, const void *key)
{
JS_ASSERT(IS_STRING_TABLE(table));
return js_HashString((JSString *)key);
}
JS_STATIC_DLL_CALLBACK(JSBool)
MatchDouble(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key)
{
JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
jsdouble d1, d2;
JS_ASSERT(IS_DOUBLE_TABLE(table));
if (entry->keyAndFlags == 0) {
/* See comments in MatchString. */
return JS_FALSE;
}
d1 = *(jsdouble *)ATOM_ENTRY_KEY(entry);
d2 = *(jsdouble *)key;
if (JSDOUBLE_IS_NaN(d1))
return JSDOUBLE_IS_NaN(d2);
#if defined(XP_WIN)
/* XXX MSVC miscompiles such that (NaN == 0) */
if (JSDOUBLE_IS_NaN(d2))
return JS_FALSE;
#endif
return d1 == d2;
}
JS_STATIC_DLL_CALLBACK(JSBool)
MatchString(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key)
{
JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
JS_ASSERT(IS_STRING_TABLE(table));
if (entry->keyAndFlags == 0) {
/*
* This happens when js_AtomizeString adds a new hash entry and
* releases the lock but before it takes the lock the second time to
* initialize keyAndFlags for the entry.
*
* We always return false for such entries so JS_DHashTableOperate
* never finds them. We clean them during GC's sweep phase.
*
* It means that with a contested lock or when GC is triggered outside
* the lock we may end up adding two entries, but this is a price for
* simpler code.
*/
return JS_FALSE;
}
return js_EqualStrings((JSString *)ATOM_ENTRY_KEY(entry), (JSString *)key);
}
/*
* For a browser build from 2007-08-09 after the browser starts up there are
* just 55 double atoms, but over 15000 string atoms. Not to penalize more
* economical embeddings allocating too much memory initially we initialize
* atomized strings with just 1K entries.
*/
#define JS_STRING_HASH_COUNT 1024
#define JS_DOUBLE_HASH_COUNT 64
JSBool
js_InitAtomState(JSRuntime *rt)
{
JSAtomState *state = &rt->atomState;
/*
* The caller must zero the state before calling this function.
*/
JS_ASSERT(!state->stringAtoms.ops);
JS_ASSERT(!state->doubleAtoms.ops);
if (!JS_DHashTableInit(&state->stringAtoms, &StringHashOps,
NULL, sizeof(JSAtomHashEntry),
JS_DHASH_DEFAULT_CAPACITY(JS_STRING_HASH_COUNT))) {
state->stringAtoms.ops = NULL;
return JS_FALSE;
}
JS_ASSERT(IS_STRING_TABLE(&state->stringAtoms));
if (!JS_DHashTableInit(&state->doubleAtoms, &DoubleHashOps,
NULL, sizeof(JSAtomHashEntry),
JS_DHASH_DEFAULT_CAPACITY(JS_DOUBLE_HASH_COUNT))) {
state->doubleAtoms.ops = NULL;
JS_DHashTableFinish(&state->stringAtoms);
state->stringAtoms.ops = NULL;
return JS_FALSE;
}
JS_ASSERT(IS_DOUBLE_TABLE(&state->doubleAtoms));
#ifdef JS_THREADSAFE
js_InitLock(&state->lock);
#endif
JS_ASSERT(IS_INITIALIZED_STATE(state));
return JS_TRUE;
}
JS_STATIC_DLL_CALLBACK(JSDHashOperator)
js_string_uninterner(JSDHashTable *table, JSDHashEntryHdr *hdr,
uint32 number, void *arg)
{
JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
JSRuntime *rt = (JSRuntime *)arg;
JSString *str;
/*
* Any string entry that remains at this point must be initialized, as the
* last GC should clean any uninitialized ones.
*/
JS_ASSERT(IS_STRING_TABLE(table));
JS_ASSERT(entry->keyAndFlags != 0);
str = (JSString *)ATOM_ENTRY_KEY(entry);
/* Pass null as context. */
js_FinalizeStringRT(rt, str, js_GetExternalStringGCType(str), NULL);
return JS_DHASH_NEXT;
}
void
js_FinishAtomState(JSRuntime *rt)
{
JSAtomState *state = &rt->atomState;
if (!IS_INITIALIZED_STATE(state)) {
/*
* We are called with uninitialized state when JS_NewRuntime fails and
* calls JS_DestroyRuntime on a partially initialized runtime.
*/
return;
}
JS_DHashTableEnumerate(&state->stringAtoms, js_string_uninterner, rt);
JS_DHashTableFinish(&state->stringAtoms);
JS_DHashTableFinish(&state->doubleAtoms);
#ifdef JS_THREADSAFE
js_FinishLock(&state->lock);
#endif
#ifdef DEBUG
memset(state, JS_FREE_PATTERN, sizeof *state);
#endif
}
JSBool
js_InitCommonAtoms(JSContext *cx)
{
JSAtomState *state = &cx->runtime->atomState;
uintN i;
JSAtom **atoms;
atoms = COMMON_ATOMS_START(state);
for (i = 0; i < JS_ARRAY_LENGTH(js_common_atom_names); i++, atoms++) {
*atoms = js_Atomize(cx, js_common_atom_names[i],
strlen(js_common_atom_names[i]), ATOM_PINNED);
if (!*atoms)
return JS_FALSE;
}
JS_ASSERT((uint8 *)atoms - (uint8 *)state == LAZY_ATOM_OFFSET_START);
memset(atoms, 0, ATOM_OFFSET_LIMIT - LAZY_ATOM_OFFSET_START);
return JS_TRUE;
}
JS_STATIC_DLL_CALLBACK(JSDHashOperator)
js_atom_unpinner(JSDHashTable *table, JSDHashEntryHdr *hdr,
uint32 number, void *arg)
{
JS_ASSERT(IS_STRING_TABLE(table));
CLEAR_ATOM_ENTRY_FLAGS(TO_ATOM_ENTRY(hdr), ATOM_PINNED);
return JS_DHASH_NEXT;
}
void
js_FinishCommonAtoms(JSContext *cx)
{
JSAtomState *state = &cx->runtime->atomState;
JS_DHashTableEnumerate(&state->stringAtoms, js_atom_unpinner, NULL);
#ifdef DEBUG
memset(COMMON_ATOMS_START(state), JS_FREE_PATTERN,
ATOM_OFFSET_LIMIT - ATOM_OFFSET_START);
#endif
}
JS_STATIC_DLL_CALLBACK(JSDHashOperator)
js_locked_atom_tracer(JSDHashTable *table, JSDHashEntryHdr *hdr,
uint32 number, void *arg)
{
JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
JSTracer *trc = (JSTracer *)arg;
if (entry->keyAndFlags == 0) {
/* Ignore uninitialized entries during tracing. */
return JS_DHASH_NEXT;
}
JS_SET_TRACING_INDEX(trc, "locked_atom", (size_t)number);
JS_CallTracer(trc, ATOM_ENTRY_KEY(entry),
IS_STRING_TABLE(table) ? JSTRACE_STRING : JSTRACE_DOUBLE);
return JS_DHASH_NEXT;
}
JS_STATIC_DLL_CALLBACK(JSDHashOperator)
js_pinned_atom_tracer(JSDHashTable *table, JSDHashEntryHdr *hdr,
uint32 number, void *arg)
{
JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
JSTracer *trc = (JSTracer *)arg;
uintN flags = ATOM_ENTRY_FLAGS(entry);
JS_ASSERT(IS_STRING_TABLE(table));
if (flags & (ATOM_PINNED | ATOM_INTERNED)) {
JS_SET_TRACING_INDEX(trc,
flags & ATOM_PINNED
? "pinned_atom"
: "interned_atom",
(size_t)number);
JS_CallTracer(trc, ATOM_ENTRY_KEY(entry), JSTRACE_STRING);
}
return JS_DHASH_NEXT;
}
void
js_TraceAtomState(JSTracer *trc, JSBool allAtoms)
{
JSAtomState *state;
state = &trc->context->runtime->atomState;
if (allAtoms) {
JS_DHashTableEnumerate(&state->doubleAtoms, js_locked_atom_tracer, trc);
JS_DHashTableEnumerate(&state->stringAtoms, js_locked_atom_tracer, trc);
} else {
JS_DHashTableEnumerate(&state->stringAtoms, js_pinned_atom_tracer, trc);
}
}
JS_STATIC_DLL_CALLBACK(JSDHashOperator)
js_atom_sweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
uint32 number, void *arg)
{
JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
JSContext *cx = (JSContext *)arg;
/* Remove uninitialized entries. */
if (entry->keyAndFlags == 0)
return JS_DHASH_REMOVE;
if (ATOM_ENTRY_FLAGS(entry) & (ATOM_PINNED | ATOM_INTERNED)) {
/* Pinned or interned key cannot be finalized. */
JS_ASSERT(!js_IsAboutToBeFinalized(cx, ATOM_ENTRY_KEY(entry)));
} else if (js_IsAboutToBeFinalized(cx, ATOM_ENTRY_KEY(entry))) {
/* Remove entries with things about to be GC'ed. */
return JS_DHASH_REMOVE;
}
return JS_DHASH_NEXT;
}
void
js_SweepAtomState(JSContext *cx)
{
JSAtomState *state = &cx->runtime->atomState;
JS_DHashTableEnumerate(&state->doubleAtoms, js_atom_sweeper, cx);
JS_DHashTableEnumerate(&state->stringAtoms, js_atom_sweeper, cx);
/*
* Optimize for simplicity and mutate table generation numbers even if the
* sweeper has not removed any entries.
*/
state->doubleAtoms.generation++;
state->stringAtoms.generation++;
}
JSAtom *
js_AtomizeDouble(JSContext *cx, jsdouble d)
{
JSAtomState *state;
JSDHashTable *table;
JSAtomHashEntry *entry;
uint32 gen;
jsdouble *key;
jsval v;
state = &cx->runtime->atomState;
table = &state->doubleAtoms;
JS_LOCK(&state->lock, cx);
entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, &d, JS_DHASH_ADD));
if (!entry)
goto failed_hash_add;
if (entry->keyAndFlags == 0) {
gen = ++table->generation;
JS_UNLOCK(&state->lock, cx);
key = js_NewWeaklyRootedDouble(cx, d);
if (!key)
return NULL;
JS_LOCK(&state->lock, cx);
if (table->generation == gen) {
JS_ASSERT(entry->keyAndFlags == 0);
} else {
entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, key,
JS_DHASH_ADD));
if (!entry)
goto failed_hash_add;
if (entry->keyAndFlags != 0)
goto finish;
++table->generation;
}
INIT_ATOM_ENTRY(entry, key);
}
finish:
v = DOUBLE_TO_JSVAL((jsdouble *)ATOM_ENTRY_KEY(entry));
cx->weakRoots.lastAtom = v;
JS_UNLOCK(&state->lock,cx);
return (JSAtom *)v;
failed_hash_add:
JS_UNLOCK(&state->lock,cx);
JS_ReportOutOfMemory(cx);
return NULL;
}
JSAtom *
js_AtomizeString(JSContext *cx, JSString *str, uintN flags)
{
jsval v;
JSAtomState *state;
JSDHashTable *table;
JSAtomHashEntry *entry;
JSString *key;
uint32 gen;
JS_ASSERT(!(flags & ~(ATOM_PINNED|ATOM_INTERNED|ATOM_TMPSTR|ATOM_NOCOPY)));
JS_ASSERT_IF(flags & ATOM_NOCOPY, flags & ATOM_TMPSTR);
state = &cx->runtime->atomState;
table = &state->stringAtoms;
JS_LOCK(&state->lock, cx);
entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, str, JS_DHASH_ADD));
if (!entry)
goto failed_hash_add;
if (entry->keyAndFlags != 0) {
key = (JSString *)ATOM_ENTRY_KEY(entry);
} else {
/*
* We created a new hashtable entry. Unless str is already allocated
* from the GC heap and flat, we have to release state->lock as
* string construction is a complex operation. For example, it can
* trigger GC which may rehash the table and make the entry invalid.
*/
++table->generation;
if (!(flags & ATOM_TMPSTR) && JSSTRING_IS_FLAT(str)) {
JSFLATSTR_CLEAR_MUTABLE(str);
key = str;
} else {
gen = table->generation;
JS_UNLOCK(&state->lock, cx);
if (flags & ATOM_TMPSTR) {
if (flags & ATOM_NOCOPY) {
key = js_NewString(cx, JSFLATSTR_CHARS(str),
JSFLATSTR_LENGTH(str));
if (!key)
return NULL;
/* Finish handing off chars to the GC'ed key string. */
str->u.chars = NULL;
} else {
key = js_NewStringCopyN(cx, JSFLATSTR_CHARS(str),
JSFLATSTR_LENGTH(str));
if (!key)
return NULL;
}
} else {
JS_ASSERT(JSSTRING_IS_DEPENDENT(str));
if (!js_UndependString(cx, str))
return NULL;
key = str;
}
JS_LOCK(&state->lock, cx);
if (table->generation == gen) {
JS_ASSERT(entry->keyAndFlags == 0);
} else {
entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, key,
JS_DHASH_ADD));
if (!entry)
goto failed_hash_add;
if (entry->keyAndFlags != 0) {
key = (JSString *)ATOM_ENTRY_KEY(entry);
goto finish;
}
++table->generation;
}
}
INIT_ATOM_ENTRY(entry, key);
JSFLATSTR_SET_ATOMIZED(key);
}
finish:
ADD_ATOM_ENTRY_FLAGS(entry, flags & (ATOM_PINNED | ATOM_INTERNED));
JS_ASSERT(JSSTRING_IS_ATOMIZED(key));
v = STRING_TO_JSVAL(key);
cx->weakRoots.lastAtom = v;
JS_UNLOCK(&state->lock, cx);
return (JSAtom *)v;
failed_hash_add:
JS_UNLOCK(&state->lock,cx);
JS_ReportOutOfMemory(cx);
return NULL;
}
JSAtom *
js_Atomize(JSContext *cx, const char *bytes, size_t length, uintN flags)
{
jschar *chars;
JSString str;
JSAtom *atom;
/*
* Avoiding the malloc in js_InflateString on shorter strings saves us
* over 20,000 malloc calls on mozilla browser startup. This compares to
* only 131 calls where the string is longer than a 31 char (net) buffer.
* The vast majority of atomized strings are already in the hashtable. So
* js_AtomizeString rarely has to copy the temp string we make.
*/
#define ATOMIZE_BUF_MAX 32
jschar inflated[ATOMIZE_BUF_MAX];
size_t inflatedLength = ATOMIZE_BUF_MAX - 1;
if (length < ATOMIZE_BUF_MAX) {
js_InflateStringToBuffer(cx, bytes, length, inflated, &inflatedLength);
inflated[inflatedLength] = 0;
chars = inflated;
} else {
inflatedLength = length;
chars = js_InflateString(cx, bytes, &inflatedLength);
if (!chars)
return NULL;
flags |= ATOM_NOCOPY;
}
JSFLATSTR_INIT(&str, (jschar *)chars, inflatedLength);
atom = js_AtomizeString(cx, &str, ATOM_TMPSTR | flags);
if (chars != inflated && str.u.chars)
JS_free(cx, chars);
return atom;
}
JSAtom *
js_AtomizeChars(JSContext *cx, const jschar *chars, size_t length, uintN flags)
{
JSString str;
JSFLATSTR_INIT(&str, (jschar *)chars, length);
return js_AtomizeString(cx, &str, ATOM_TMPSTR | flags);
}
JSAtom *
js_GetExistingStringAtom(JSContext *cx, const jschar *chars, size_t length)
{
JSString str, *str2;
JSAtomState *state;
JSDHashEntryHdr *hdr;
JSFLATSTR_INIT(&str, (jschar *)chars, length);
state = &cx->runtime->atomState;
JS_LOCK(&state->lock, cx);
hdr = JS_DHashTableOperate(&state->stringAtoms, &str, JS_DHASH_LOOKUP);
str2 = JS_DHASH_ENTRY_IS_BUSY(hdr)
? (JSString *)ATOM_ENTRY_KEY(TO_ATOM_ENTRY(hdr))
: NULL;
JS_UNLOCK(&state->lock, cx);
return str2 ? (JSAtom *)STRING_TO_JSVAL(str2) : NULL;
}
JSBool
js_AtomizePrimitiveValue(JSContext *cx, jsval v, JSAtom **atomp)
{
JSAtom *atom;
if (JSVAL_IS_STRING(v)) {
atom = js_AtomizeString(cx, JSVAL_TO_STRING(v), 0);
if (!atom)
return JS_FALSE;
} else if (JSVAL_IS_DOUBLE(v)) {
atom = js_AtomizeDouble(cx, *JSVAL_TO_DOUBLE(v));
if (!atom)
return JS_FALSE;
} else {
JS_ASSERT(JSVAL_IS_INT(v) || v == JSVAL_TRUE || v == JSVAL_FALSE ||
v == JSVAL_NULL || v == JSVAL_VOID);
atom = (JSAtom *)v;
}
*atomp = atom;
return JS_TRUE;
}
JSBool
js_ValueToStringId(JSContext *cx, jsval v, jsid *idp)
{
JSString *str;
JSAtom *atom;
/*
* Optimize for the common case where v is an already-atomized string. The
* comment in jsstr.h before the JSSTRING_SET_ATOMIZED macro's definition
* explains why this is thread-safe. The extra rooting via lastAtom (which
* would otherwise be done in js_js_AtomizeString) ensures the caller that
* the resulting id at is least weakly rooted.
*/
if (JSVAL_IS_STRING(v)) {
str = JSVAL_TO_STRING(v);
if (JSSTRING_IS_ATOMIZED(str)) {
cx->weakRoots.lastAtom = v;
*idp = ATOM_TO_JSID((JSAtom *) v);
return JS_TRUE;
}
} else {
str = js_ValueToString(cx, v);
if (!str)
return JS_FALSE;
}
atom = js_AtomizeString(cx, str, 0);
if (!atom)
return JS_FALSE;
*idp = ATOM_TO_JSID(atom);
return JS_TRUE;
}
#ifdef DEBUG
JS_STATIC_DLL_CALLBACK(JSDHashOperator)
atom_dumper(JSDHashTable *table, JSDHashEntryHdr *hdr,
uint32 number, void *arg)
{
JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
FILE *fp = (FILE *)arg;
void *key;
uintN flags;
fprintf(fp, "%3u %08x ", number, (uintN)entry->hdr.keyHash);
if (entry->keyAndFlags == 0) {
fputs("<uninitialized>", fp);
} else {
key = ATOM_ENTRY_KEY(entry);
if (IS_DOUBLE_TABLE(table)) {
fprintf(fp, "%.16g", *(jsdouble *)key);
} else {
JS_ASSERT(IS_STRING_TABLE(table));
js_FileEscapedString(fp, (JSString *)key, '"');
}
flags = ATOM_ENTRY_FLAGS(entry);
if (flags != 0) {
fputs((flags & (ATOM_PINNED | ATOM_INTERNED))
? " pinned | interned"
: (flags & ATOM_PINNED) ? " pinned" : " interned",
fp);
}
}
putc('\n', fp);
return JS_DHASH_NEXT;
}
JS_FRIEND_API(void)
js_DumpAtoms(JSContext *cx, FILE *fp)
{
JSAtomState *state = &cx->runtime->atomState;
fprintf(fp, "stringAtoms table contents:\n");
JS_DHashTableEnumerate(&state->stringAtoms, atom_dumper, fp);
#ifdef JS_DHASHMETER
JS_DHashTableDumpMeter(&state->stringAtoms, atom_dumper, fp);
#endif
putc('\n', fp);
fprintf(fp, "doubleAtoms table contents:\n");
JS_DHashTableEnumerate(&state->doubleAtoms, atom_dumper, fp);
#ifdef JS_DHASHMETER
JS_DHashTableDumpMeter(&state->doubleAtoms, atom_dumper, fp);
#endif
putc('\n', fp);
}
#endif
JS_STATIC_DLL_CALLBACK(JSHashNumber)
js_hash_atom_ptr(const void *key)
{
const JSAtom *atom = (const JSAtom *) key;
return ATOM_HASH(atom);
}
JS_STATIC_DLL_CALLBACK(void *)
js_alloc_temp_space(void *priv, size_t size)
{
JSContext *cx = (JSContext *) priv;
void *space;
JS_ARENA_ALLOCATE(space, &cx->tempPool, size);
if (!space)
js_ReportOutOfScriptQuota(cx);
return space;
}
JS_STATIC_DLL_CALLBACK(void)
js_free_temp_space(void *priv, void *item)
{
}
JS_STATIC_DLL_CALLBACK(JSHashEntry *)
js_alloc_temp_entry(void *priv, const void *key)
{
JSContext *cx = (JSContext *) priv;
JSAtomListElement *ale;
JS_ARENA_ALLOCATE_TYPE(ale, JSAtomListElement, &cx->tempPool);
if (!ale) {
js_ReportOutOfScriptQuota(cx);
return NULL;
}
return &ale->entry;
}
JS_STATIC_DLL_CALLBACK(void)
js_free_temp_entry(void *priv, JSHashEntry *he, uintN flag)
{
}
static JSHashAllocOps temp_alloc_ops = {
js_alloc_temp_space, js_free_temp_space,
js_alloc_temp_entry, js_free_temp_entry
};
JSAtomListElement *
js_IndexAtom(JSContext *cx, JSAtom *atom, JSAtomList *al)
{
JSAtomListElement *ale, *ale2, *next;
JSHashEntry **hep;
ATOM_LIST_LOOKUP(ale, hep, al, atom);
if (!ale) {
if (al->count < 10) {
/* Few enough for linear search, no hash table needed. */
JS_ASSERT(!al->table);
ale = (JSAtomListElement *)js_alloc_temp_entry(cx, atom);
if (!ale)
return NULL;
ALE_SET_ATOM(ale, atom);
ale->entry.next = al->list;
al->list = &ale->entry;
} else {
/* We want to hash. Have we already made a hash table? */
if (!al->table) {
/* No hash table yet, so hep had better be null! */
JS_ASSERT(!hep);
al->table = JS_NewHashTable(al->count + 1, js_hash_atom_ptr,
JS_CompareValues, JS_CompareValues,
&temp_alloc_ops, cx);
if (!al->table)
return NULL;
/*
* Set ht->nentries explicitly, because we are moving entries
* from al to ht, not calling JS_HashTable(Raw|)Add.
*/
al->table->nentries = al->count;
/* Insert each ale on al->list into the new hash table. */
for (ale2 = (JSAtomListElement *)al->list; ale2; ale2 = next) {
next = ALE_NEXT(ale2);
ale2->entry.keyHash = ATOM_HASH(ALE_ATOM(ale2));
hep = JS_HashTableRawLookup(al->table, ale2->entry.keyHash,
ale2->entry.key);
ale2->entry.next = *hep;
*hep = &ale2->entry;
}
al->list = NULL;
/* Set hep for insertion of atom's ale, immediately below. */
hep = JS_HashTableRawLookup(al->table, ATOM_HASH(atom), atom);
}
/* Finally, add an entry for atom into the hash bucket at hep. */
ale = (JSAtomListElement *)
JS_HashTableRawAdd(al->table, hep, ATOM_HASH(atom), atom,
NULL);
if (!ale)
return NULL;
}
ALE_SET_INDEX(ale, al->count++);
}
return ale;
}
JS_STATIC_DLL_CALLBACK(intN)
js_map_atom(JSHashEntry *he, intN i, void *arg)
{
JSAtomListElement *ale = (JSAtomListElement *)he;
JSAtom **vector = (JSAtom **) arg;
vector[ALE_INDEX(ale)] = ALE_ATOM(ale);
return HT_ENUMERATE_NEXT;
}
#ifdef DEBUG
static jsrefcount js_atom_map_count;
static jsrefcount js_atom_map_hash_table_count;
#endif
void
js_InitAtomMap(JSContext *cx, JSAtomMap *map, JSAtomList *al)
{
JSAtom **vector;
JSAtomListElement *ale;
uint32 count;
/* Map length must already be initialized. */
JS_ASSERT(al->count == map->length);
#ifdef DEBUG
JS_ATOMIC_INCREMENT(&js_atom_map_count);
#endif
ale = (JSAtomListElement *)al->list;
if (!ale && !al->table) {
JS_ASSERT(!map->vector);
return;
}
count = al->count;
vector = map->vector;
if (al->table) {
#ifdef DEBUG
JS_ATOMIC_INCREMENT(&js_atom_map_hash_table_count);
#endif
JS_HashTableEnumerateEntries(al->table, js_map_atom, vector);
} else {
do {
vector[ALE_INDEX(ale)] = ALE_ATOM(ale);
} while ((ale = ALE_NEXT(ale)) != NULL);
}
ATOM_LIST_INIT(al);
}