/[jscoverage]/trunk/js/jsatom.cpp
ViewVC logotype

Annotation of /trunk/js/jsatom.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 507 - (hide annotations)
Sun Jan 10 07:23:34 2010 UTC (9 years, 6 months ago) by siliconforks
File size: 40821 byte(s)
Update SpiderMonkey from Firefox 3.6rc1.

1 siliconforks 507 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 siliconforks 332 *
3     * ***** BEGIN LICENSE BLOCK *****
4     * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5     *
6     * The contents of this file are subject to the Mozilla Public License Version
7     * 1.1 (the "License"); you may not use this file except in compliance with
8     * the License. You may obtain a copy of the License at
9     * http://www.mozilla.org/MPL/
10     *
11     * Software distributed under the License is distributed on an "AS IS" basis,
12     * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13     * for the specific language governing rights and limitations under the
14     * License.
15     *
16     * The Original Code is Mozilla Communicator client code, released
17     * March 31, 1998.
18     *
19     * The Initial Developer of the Original Code is
20     * Netscape Communications Corporation.
21     * Portions created by the Initial Developer are Copyright (C) 1998
22     * the Initial Developer. All Rights Reserved.
23     *
24     * Contributor(s):
25     *
26     * Alternatively, the contents of this file may be used under the terms of
27     * either of the GNU General Public License Version 2 or later (the "GPL"),
28     * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
29     * in which case the provisions of the GPL or the LGPL are applicable instead
30     * of those above. If you wish to allow use of your version of this file only
31     * under the terms of either the GPL or the LGPL, and not to allow others to
32     * use your version of this file under the terms of the MPL, indicate your
33     * decision by deleting the provisions above and replace them with the notice
34     * and other provisions required by the GPL or the LGPL. If you do not delete
35     * the provisions above, a recipient may use your version of this file under
36     * the terms of any one of the MPL, the GPL or the LGPL.
37     *
38     * ***** END LICENSE BLOCK ***** */
39    
40     /*
41     * JS atom table.
42     */
43     #include <stdlib.h>
44     #include <string.h>
45     #include "jstypes.h"
46 siliconforks 507 #include "jsstdint.h"
47 siliconforks 332 #include "jsutil.h" /* Added by JSIFY */
48     #include "jshash.h" /* Added by JSIFY */
49     #include "jsprf.h"
50     #include "jsapi.h"
51     #include "jsatom.h"
52 siliconforks 460 #include "jsbit.h"
53 siliconforks 332 #include "jscntxt.h"
54     #include "jsgc.h"
55     #include "jslock.h"
56     #include "jsnum.h"
57 siliconforks 460 #include "jsparse.h"
58 siliconforks 332 #include "jsscan.h"
59     #include "jsstr.h"
60 siliconforks 460 #include "jsversion.h"
61 siliconforks 507 #include "jsstrinlines.h"
62 siliconforks 332
63 siliconforks 460 /*
64     * ATOM_HASH assumes that JSHashNumber is 32-bit even on 64-bit systems.
65     */
66     JS_STATIC_ASSERT(sizeof(JSHashNumber) == 4);
67     JS_STATIC_ASSERT(sizeof(JSAtom *) == JS_BYTES_PER_WORD);
68    
69     /*
70     * Start and limit offsets for atom pointers in JSAtomState must be aligned
71     * on the word boundary.
72     */
73     JS_STATIC_ASSERT(ATOM_OFFSET_START % sizeof(JSAtom *) == 0);
74     JS_STATIC_ASSERT(ATOM_OFFSET_LIMIT % sizeof(JSAtom *) == 0);
75    
76     /*
77     * JS_BOOLEAN_STR and JS_TYPE_STR assume that boolean names starts from the
78     * index 1 and type name starts from the index 1+2 atoms in JSAtomState.
79     */
80     JS_STATIC_ASSERT(1 * sizeof(JSAtom *) ==
81     offsetof(JSAtomState, booleanAtoms) - ATOM_OFFSET_START);
82     JS_STATIC_ASSERT((1 + 2) * sizeof(JSAtom *) ==
83     offsetof(JSAtomState, typeAtoms) - ATOM_OFFSET_START);
84    
85 siliconforks 332 const char *
86     js_AtomToPrintableString(JSContext *cx, JSAtom *atom)
87     {
88     return js_ValueToPrintableString(cx, ATOM_KEY(atom));
89     }
90    
91     #define JS_PROTO(name,code,init) const char js_##name##_str[] = #name;
92     #include "jsproto.tbl"
93     #undef JS_PROTO
94    
95     /*
96 siliconforks 399 * String constants for common atoms defined in JSAtomState starting from
97 siliconforks 332 * JSAtomState.emptyAtom until JSAtomState.lazy.
98     *
99     * The elements of the array after the first empty string define strings
100 siliconforks 399 * corresponding to the two boolean literals, false and true, followed by the
101     * JSType enumerators from jspubtd.h starting with "undefined" for JSTYPE_VOID
102 siliconforks 507 * (which is special-value 2) and continuing as initialized below. The static
103 siliconforks 399 * asserts check these relations.
104 siliconforks 332 */
105     JS_STATIC_ASSERT(JSTYPE_LIMIT == 8);
106 siliconforks 399 JS_STATIC_ASSERT(JSTYPE_VOID == 0);
107    
108 siliconforks 332 const char *const js_common_atom_names[] = {
109     "", /* emptyAtom */
110 siliconforks 399 js_false_str, /* booleanAtoms[0] */
111     js_true_str, /* booleanAtoms[1] */
112 siliconforks 332 js_undefined_str, /* typeAtoms[JSTYPE_VOID] */
113     js_object_str, /* typeAtoms[JSTYPE_OBJECT] */
114     js_function_str, /* typeAtoms[JSTYPE_FUNCTION] */
115     "string", /* typeAtoms[JSTYPE_STRING] */
116     "number", /* typeAtoms[JSTYPE_NUMBER] */
117     "boolean", /* typeAtoms[JSTYPE_BOOLEAN] */
118     js_null_str, /* typeAtoms[JSTYPE_NULL] */
119     "xml", /* typeAtoms[JSTYPE_XML] */
120     js_null_str, /* nullAtom */
121    
122     #define JS_PROTO(name,code,init) js_##name##_str,
123     #include "jsproto.tbl"
124     #undef JS_PROTO
125    
126     js_anonymous_str, /* anonymousAtom */
127 siliconforks 399 js_apply_str, /* applyAtom */
128 siliconforks 332 js_arguments_str, /* argumentsAtom */
129     js_arity_str, /* arityAtom */
130 siliconforks 399 js_call_str, /* callAtom */
131 siliconforks 332 js_callee_str, /* calleeAtom */
132     js_caller_str, /* callerAtom */
133     js_class_prototype_str, /* classPrototypeAtom */
134     js_constructor_str, /* constructorAtom */
135     js_count_str, /* countAtom */
136     js_each_str, /* eachAtom */
137     js_eval_str, /* evalAtom */
138     js_fileName_str, /* fileNameAtom */
139     js_get_str, /* getAtom */
140     js_getter_str, /* getterAtom */
141     js_index_str, /* indexAtom */
142     js_input_str, /* inputAtom */
143     js_iterator_str, /* iteratorAtom */
144     js_length_str, /* lengthAtom */
145     js_lineNumber_str, /* lineNumberAtom */
146     js_message_str, /* messageAtom */
147     js_name_str, /* nameAtom */
148     js_next_str, /* nextAtom */
149     js_noSuchMethod_str, /* noSuchMethodAtom */
150     js_parent_str, /* parentAtom */
151     js_proto_str, /* protoAtom */
152     js_set_str, /* setAtom */
153     js_setter_str, /* setterAtom */
154     js_stack_str, /* stackAtom */
155     js_toLocaleString_str, /* toLocaleStringAtom */
156     js_toSource_str, /* toSourceAtom */
157     js_toString_str, /* toStringAtom */
158     js_valueOf_str, /* valueOfAtom */
159     js_toJSON_str, /* toJSONAtom */
160     "(void 0)", /* void0Atom */
161    
162     #if JS_HAS_XML_SUPPORT
163     js_etago_str, /* etagoAtom */
164     js_namespace_str, /* namespaceAtom */
165     js_ptagc_str, /* ptagcAtom */
166     js_qualifier_str, /* qualifierAtom */
167     js_space_str, /* spaceAtom */
168     js_stago_str, /* stagoAtom */
169     js_star_str, /* starAtom */
170     js_starQualifier_str, /* starQualifierAtom */
171     js_tagc_str, /* tagcAtom */
172     js_xml_str, /* xmlAtom */
173     #endif
174    
175     #ifdef NARCISSUS
176 siliconforks 399 js___call___str, /* __call__Atom */
177     js___construct___str, /* __construct__Atom */
178     js___hasInstance___str, /* __hasInstance__Atom */
179 siliconforks 332 js_ExecutionContext_str, /* ExecutionContextAtom */
180     js_current_str, /* currentAtom */
181     #endif
182     };
183 siliconforks 399
184 siliconforks 332 JS_STATIC_ASSERT(JS_ARRAY_LENGTH(js_common_atom_names) * sizeof(JSAtom *) ==
185     LAZY_ATOM_OFFSET_START - ATOM_OFFSET_START);
186    
187 siliconforks 399 /*
188     * Interpreter macros called by the trace recorder assume common atom indexes
189     * fit in one byte of immediate operand.
190     */
191     JS_STATIC_ASSERT(JS_ARRAY_LENGTH(js_common_atom_names) < 256);
192    
193     const size_t js_common_atom_count = JS_ARRAY_LENGTH(js_common_atom_names);
194    
195 siliconforks 332 const char js_anonymous_str[] = "anonymous";
196 siliconforks 399 const char js_apply_str[] = "apply";
197 siliconforks 332 const char js_arguments_str[] = "arguments";
198     const char js_arity_str[] = "arity";
199 siliconforks 399 const char js_call_str[] = "call";
200 siliconforks 332 const char js_callee_str[] = "callee";
201     const char js_caller_str[] = "caller";
202     const char js_class_prototype_str[] = "prototype";
203     const char js_constructor_str[] = "constructor";
204     const char js_count_str[] = "__count__";
205     const char js_each_str[] = "each";
206     const char js_eval_str[] = "eval";
207     const char js_fileName_str[] = "fileName";
208     const char js_get_str[] = "get";
209     const char js_getter_str[] = "getter";
210     const char js_index_str[] = "index";
211     const char js_input_str[] = "input";
212     const char js_iterator_str[] = "__iterator__";
213     const char js_length_str[] = "length";
214     const char js_lineNumber_str[] = "lineNumber";
215     const char js_message_str[] = "message";
216     const char js_name_str[] = "name";
217     const char js_next_str[] = "next";
218     const char js_noSuchMethod_str[] = "__noSuchMethod__";
219     const char js_object_str[] = "object";
220     const char js_parent_str[] = "__parent__";
221     const char js_proto_str[] = "__proto__";
222     const char js_setter_str[] = "setter";
223     const char js_set_str[] = "set";
224     const char js_stack_str[] = "stack";
225     const char js_toSource_str[] = "toSource";
226     const char js_toString_str[] = "toString";
227     const char js_toLocaleString_str[] = "toLocaleString";
228     const char js_undefined_str[] = "undefined";
229     const char js_valueOf_str[] = "valueOf";
230     const char js_toJSON_str[] = "toJSON";
231    
232     #if JS_HAS_XML_SUPPORT
233     const char js_etago_str[] = "</";
234     const char js_namespace_str[] = "namespace";
235     const char js_ptagc_str[] = "/>";
236     const char js_qualifier_str[] = "::";
237     const char js_space_str[] = " ";
238     const char js_stago_str[] = "<";
239     const char js_star_str[] = "*";
240     const char js_starQualifier_str[] = "*::";
241     const char js_tagc_str[] = ">";
242     const char js_xml_str[] = "xml";
243     #endif
244    
245     #if JS_HAS_GENERATORS
246     const char js_close_str[] = "close";
247     const char js_send_str[] = "send";
248     #endif
249    
250     #ifdef NARCISSUS
251 siliconforks 399 const char js___call___str[] = "__call__";
252     const char js___construct___str[] = "__construct__";
253     const char js___hasInstance___str[] = "__hasInstance__";
254 siliconforks 332 const char js_ExecutionContext_str[] = "ExecutionContext";
255     const char js_current_str[] = "current";
256     #endif
257    
258     /*
259     * JSAtomState.doubleAtoms and JSAtomState.stringAtoms hashtable entry. To
260     * support pinned and interned string atoms, we use the lowest bits of the
261     * keyAndFlags field to store ATOM_PINNED and ATOM_INTERNED flags.
262     */
263     typedef struct JSAtomHashEntry {
264     JSDHashEntryHdr hdr;
265     jsuword keyAndFlags;
266     } JSAtomHashEntry;
267    
268     #define ATOM_ENTRY_FLAG_MASK (ATOM_PINNED | ATOM_INTERNED)
269    
270     JS_STATIC_ASSERT(ATOM_ENTRY_FLAG_MASK < JSVAL_ALIGN);
271    
272     /*
273     * Helper macros to access and modify JSAtomHashEntry.
274     */
275     #define TO_ATOM_ENTRY(hdr) ((JSAtomHashEntry *) hdr)
276     #define ATOM_ENTRY_KEY(entry) \
277     ((void *)((entry)->keyAndFlags & ~ATOM_ENTRY_FLAG_MASK))
278     #define ATOM_ENTRY_FLAGS(entry) \
279     ((uintN)((entry)->keyAndFlags & ATOM_ENTRY_FLAG_MASK))
280     #define INIT_ATOM_ENTRY(entry, key) \
281     ((void)((entry)->keyAndFlags = (jsuword)(key)))
282     #define ADD_ATOM_ENTRY_FLAGS(entry, flags) \
283     ((void)((entry)->keyAndFlags |= (jsuword)(flags)))
284     #define CLEAR_ATOM_ENTRY_FLAGS(entry, flags) \
285     ((void)((entry)->keyAndFlags &= ~(jsuword)(flags)))
286    
287     static JSDHashNumber
288     HashDouble(JSDHashTable *table, const void *key);
289    
290     static JSBool
291     MatchDouble(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key);
292    
293     static JSDHashNumber
294     HashString(JSDHashTable *table, const void *key);
295    
296     static JSBool
297     MatchString(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key);
298    
299     static const JSDHashTableOps DoubleHashOps = {
300     JS_DHashAllocTable,
301     JS_DHashFreeTable,
302     HashDouble,
303     MatchDouble,
304     JS_DHashMoveEntryStub,
305     JS_DHashClearEntryStub,
306     JS_DHashFinalizeStub,
307     NULL
308     };
309    
310     static const JSDHashTableOps StringHashOps = {
311     JS_DHashAllocTable,
312     JS_DHashFreeTable,
313     HashString,
314     MatchString,
315     JS_DHashMoveEntryStub,
316     JS_DHashClearEntryStub,
317     JS_DHashFinalizeStub,
318     NULL
319     };
320    
321     #define IS_DOUBLE_TABLE(table) ((table)->ops == &DoubleHashOps)
322     #define IS_STRING_TABLE(table) ((table)->ops == &StringHashOps)
323    
324     #define IS_INITIALIZED_STATE(state) IS_DOUBLE_TABLE(&(state)->doubleAtoms)
325    
326     static JSDHashNumber
327     HashDouble(JSDHashTable *table, const void *key)
328     {
329     JS_ASSERT(IS_DOUBLE_TABLE(table));
330 siliconforks 507 return JS_HASH_DOUBLE(*(jsdouble *)key);
331 siliconforks 332 }
332    
333     static JSDHashNumber
334     HashString(JSDHashTable *table, const void *key)
335     {
336     JS_ASSERT(IS_STRING_TABLE(table));
337     return js_HashString((JSString *)key);
338     }
339    
340     static JSBool
341     MatchDouble(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key)
342     {
343     JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
344     jsdouble d1, d2;
345    
346     JS_ASSERT(IS_DOUBLE_TABLE(table));
347     if (entry->keyAndFlags == 0) {
348     /* See comments in MatchString. */
349     return JS_FALSE;
350     }
351    
352     d1 = *(jsdouble *)ATOM_ENTRY_KEY(entry);
353     d2 = *(jsdouble *)key;
354     if (JSDOUBLE_IS_NaN(d1))
355     return JSDOUBLE_IS_NaN(d2);
356     #if defined(XP_WIN)
357     /* XXX MSVC miscompiles such that (NaN == 0) */
358     if (JSDOUBLE_IS_NaN(d2))
359     return JS_FALSE;
360     #endif
361     return d1 == d2;
362     }
363    
364     static JSBool
365     MatchString(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *key)
366     {
367     JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
368    
369     JS_ASSERT(IS_STRING_TABLE(table));
370     if (entry->keyAndFlags == 0) {
371     /*
372     * This happens when js_AtomizeString adds a new hash entry and
373     * releases the lock but before it takes the lock the second time to
374     * initialize keyAndFlags for the entry.
375     *
376     * We always return false for such entries so JS_DHashTableOperate
377     * never finds them. We clean them during GC's sweep phase.
378     *
379     * It means that with a contested lock or when GC is triggered outside
380     * the lock we may end up adding two entries, but this is a price for
381     * simpler code.
382     */
383     return JS_FALSE;
384     }
385     return js_EqualStrings((JSString *)ATOM_ENTRY_KEY(entry), (JSString *)key);
386     }
387    
388     /*
389     * For a browser build from 2007-08-09 after the browser starts up there are
390     * just 55 double atoms, but over 15000 string atoms. Not to penalize more
391     * economical embeddings allocating too much memory initially we initialize
392     * atomized strings with just 1K entries.
393     */
394     #define JS_STRING_HASH_COUNT 1024
395     #define JS_DOUBLE_HASH_COUNT 64
396    
397     JSBool
398     js_InitAtomState(JSRuntime *rt)
399     {
400     JSAtomState *state = &rt->atomState;
401    
402     /*
403     * The caller must zero the state before calling this function.
404     */
405     JS_ASSERT(!state->stringAtoms.ops);
406     JS_ASSERT(!state->doubleAtoms.ops);
407    
408     if (!JS_DHashTableInit(&state->stringAtoms, &StringHashOps,
409     NULL, sizeof(JSAtomHashEntry),
410     JS_DHASH_DEFAULT_CAPACITY(JS_STRING_HASH_COUNT))) {
411     state->stringAtoms.ops = NULL;
412     return JS_FALSE;
413     }
414     JS_ASSERT(IS_STRING_TABLE(&state->stringAtoms));
415    
416     if (!JS_DHashTableInit(&state->doubleAtoms, &DoubleHashOps,
417     NULL, sizeof(JSAtomHashEntry),
418     JS_DHASH_DEFAULT_CAPACITY(JS_DOUBLE_HASH_COUNT))) {
419     state->doubleAtoms.ops = NULL;
420     JS_DHashTableFinish(&state->stringAtoms);
421     state->stringAtoms.ops = NULL;
422     return JS_FALSE;
423     }
424     JS_ASSERT(IS_DOUBLE_TABLE(&state->doubleAtoms));
425    
426     #ifdef JS_THREADSAFE
427     js_InitLock(&state->lock);
428     #endif
429     JS_ASSERT(IS_INITIALIZED_STATE(state));
430     return JS_TRUE;
431     }
432    
433     static JSDHashOperator
434     js_string_uninterner(JSDHashTable *table, JSDHashEntryHdr *hdr,
435     uint32 number, void *arg)
436     {
437     JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
438     JSRuntime *rt = (JSRuntime *)arg;
439     JSString *str;
440    
441     /*
442     * Any string entry that remains at this point must be initialized, as the
443     * last GC should clean any uninitialized ones.
444     */
445     JS_ASSERT(IS_STRING_TABLE(table));
446     JS_ASSERT(entry->keyAndFlags != 0);
447     str = (JSString *)ATOM_ENTRY_KEY(entry);
448    
449     /* Pass null as context. */
450     js_FinalizeStringRT(rt, str, js_GetExternalStringGCType(str), NULL);
451     return JS_DHASH_NEXT;
452     }
453    
454     void
455     js_FinishAtomState(JSRuntime *rt)
456     {
457     JSAtomState *state = &rt->atomState;
458    
459     if (!IS_INITIALIZED_STATE(state)) {
460     /*
461     * We are called with uninitialized state when JS_NewRuntime fails and
462     * calls JS_DestroyRuntime on a partially initialized runtime.
463     */
464     return;
465     }
466    
467     JS_DHashTableEnumerate(&state->stringAtoms, js_string_uninterner, rt);
468     JS_DHashTableFinish(&state->stringAtoms);
469     JS_DHashTableFinish(&state->doubleAtoms);
470    
471     #ifdef JS_THREADSAFE
472     js_FinishLock(&state->lock);
473     #endif
474     #ifdef DEBUG
475     memset(state, JS_FREE_PATTERN, sizeof *state);
476     #endif
477     }
478    
479     JSBool
480     js_InitCommonAtoms(JSContext *cx)
481     {
482     JSAtomState *state = &cx->runtime->atomState;
483     uintN i;
484     JSAtom **atoms;
485    
486     atoms = COMMON_ATOMS_START(state);
487     for (i = 0; i < JS_ARRAY_LENGTH(js_common_atom_names); i++, atoms++) {
488     *atoms = js_Atomize(cx, js_common_atom_names[i],
489     strlen(js_common_atom_names[i]), ATOM_PINNED);
490     if (!*atoms)
491     return JS_FALSE;
492     }
493     JS_ASSERT((uint8 *)atoms - (uint8 *)state == LAZY_ATOM_OFFSET_START);
494     memset(atoms, 0, ATOM_OFFSET_LIMIT - LAZY_ATOM_OFFSET_START);
495    
496     return JS_TRUE;
497     }
498    
499     static JSDHashOperator
500     js_atom_unpinner(JSDHashTable *table, JSDHashEntryHdr *hdr,
501     uint32 number, void *arg)
502     {
503     JS_ASSERT(IS_STRING_TABLE(table));
504     CLEAR_ATOM_ENTRY_FLAGS(TO_ATOM_ENTRY(hdr), ATOM_PINNED);
505     return JS_DHASH_NEXT;
506     }
507    
508     void
509     js_FinishCommonAtoms(JSContext *cx)
510     {
511     JSAtomState *state = &cx->runtime->atomState;
512    
513     JS_DHashTableEnumerate(&state->stringAtoms, js_atom_unpinner, NULL);
514     #ifdef DEBUG
515     memset(COMMON_ATOMS_START(state), JS_FREE_PATTERN,
516     ATOM_OFFSET_LIMIT - ATOM_OFFSET_START);
517     #endif
518     }
519    
520     static JSDHashOperator
521     js_locked_atom_tracer(JSDHashTable *table, JSDHashEntryHdr *hdr,
522     uint32 number, void *arg)
523     {
524     JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
525     JSTracer *trc = (JSTracer *)arg;
526    
527     if (entry->keyAndFlags == 0) {
528     /* Ignore uninitialized entries during tracing. */
529     return JS_DHASH_NEXT;
530     }
531     JS_SET_TRACING_INDEX(trc, "locked_atom", (size_t)number);
532     JS_CallTracer(trc, ATOM_ENTRY_KEY(entry),
533     IS_STRING_TABLE(table) ? JSTRACE_STRING : JSTRACE_DOUBLE);
534     return JS_DHASH_NEXT;
535     }
536    
537     static JSDHashOperator
538     js_pinned_atom_tracer(JSDHashTable *table, JSDHashEntryHdr *hdr,
539     uint32 number, void *arg)
540     {
541     JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
542     JSTracer *trc = (JSTracer *)arg;
543     uintN flags = ATOM_ENTRY_FLAGS(entry);
544    
545     JS_ASSERT(IS_STRING_TABLE(table));
546     if (flags & (ATOM_PINNED | ATOM_INTERNED)) {
547     JS_SET_TRACING_INDEX(trc,
548     flags & ATOM_PINNED
549     ? "pinned_atom"
550     : "interned_atom",
551     (size_t)number);
552     JS_CallTracer(trc, ATOM_ENTRY_KEY(entry), JSTRACE_STRING);
553     }
554     return JS_DHASH_NEXT;
555     }
556    
557     void
558     js_TraceAtomState(JSTracer *trc, JSBool allAtoms)
559     {
560 siliconforks 507 JSRuntime *rt = trc->context->runtime;
561     JSAtomState *state = &rt->atomState;
562 siliconforks 332
563     if (allAtoms) {
564     JS_DHashTableEnumerate(&state->doubleAtoms, js_locked_atom_tracer, trc);
565     JS_DHashTableEnumerate(&state->stringAtoms, js_locked_atom_tracer, trc);
566     } else {
567     JS_DHashTableEnumerate(&state->stringAtoms, js_pinned_atom_tracer, trc);
568     }
569     }
570    
571     static JSDHashOperator
572     js_atom_sweeper(JSDHashTable *table, JSDHashEntryHdr *hdr,
573     uint32 number, void *arg)
574     {
575     JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
576     JSContext *cx = (JSContext *)arg;
577    
578     /* Remove uninitialized entries. */
579     if (entry->keyAndFlags == 0)
580     return JS_DHASH_REMOVE;
581    
582     if (ATOM_ENTRY_FLAGS(entry) & (ATOM_PINNED | ATOM_INTERNED)) {
583     /* Pinned or interned key cannot be finalized. */
584     JS_ASSERT(!js_IsAboutToBeFinalized(cx, ATOM_ENTRY_KEY(entry)));
585     } else if (js_IsAboutToBeFinalized(cx, ATOM_ENTRY_KEY(entry))) {
586     /* Remove entries with things about to be GC'ed. */
587     return JS_DHASH_REMOVE;
588     }
589     return JS_DHASH_NEXT;
590     }
591    
592     void
593     js_SweepAtomState(JSContext *cx)
594     {
595     JSAtomState *state = &cx->runtime->atomState;
596    
597     JS_DHashTableEnumerate(&state->doubleAtoms, js_atom_sweeper, cx);
598     JS_DHashTableEnumerate(&state->stringAtoms, js_atom_sweeper, cx);
599    
600     /*
601     * Optimize for simplicity and mutate table generation numbers even if the
602     * sweeper has not removed any entries.
603     */
604     state->doubleAtoms.generation++;
605     state->stringAtoms.generation++;
606     }
607    
608     JSAtom *
609     js_AtomizeDouble(JSContext *cx, jsdouble d)
610     {
611     JSAtomState *state;
612     JSDHashTable *table;
613     JSAtomHashEntry *entry;
614     uint32 gen;
615     jsdouble *key;
616     jsval v;
617    
618     state = &cx->runtime->atomState;
619     table = &state->doubleAtoms;
620    
621     JS_LOCK(cx, &state->lock);
622     entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, &d, JS_DHASH_ADD));
623     if (!entry)
624     goto failed_hash_add;
625     if (entry->keyAndFlags == 0) {
626     gen = ++table->generation;
627     JS_UNLOCK(cx, &state->lock);
628    
629     key = js_NewWeaklyRootedDouble(cx, d);
630     if (!key)
631     return NULL;
632    
633     JS_LOCK(cx, &state->lock);
634     if (table->generation == gen) {
635     JS_ASSERT(entry->keyAndFlags == 0);
636     } else {
637     entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, key,
638     JS_DHASH_ADD));
639     if (!entry)
640     goto failed_hash_add;
641     if (entry->keyAndFlags != 0)
642     goto finish;
643     ++table->generation;
644     }
645     INIT_ATOM_ENTRY(entry, key);
646     }
647    
648     finish:
649     v = DOUBLE_TO_JSVAL((jsdouble *)ATOM_ENTRY_KEY(entry));
650     cx->weakRoots.lastAtom = v;
651     JS_UNLOCK(cx, &state->lock);
652    
653     return (JSAtom *)v;
654    
655     failed_hash_add:
656     JS_UNLOCK(cx, &state->lock);
657     JS_ReportOutOfMemory(cx);
658     return NULL;
659     }
660    
661     JSAtom *
662     js_AtomizeString(JSContext *cx, JSString *str, uintN flags)
663     {
664     jsval v;
665     JSAtomState *state;
666     JSDHashTable *table;
667     JSAtomHashEntry *entry;
668     JSString *key;
669     uint32 gen;
670    
671     JS_ASSERT(!(flags & ~(ATOM_PINNED|ATOM_INTERNED|ATOM_TMPSTR|ATOM_NOCOPY)));
672     JS_ASSERT_IF(flags & ATOM_NOCOPY, flags & ATOM_TMPSTR);
673    
674 siliconforks 507 if (str->isAtomized())
675     return (JSAtom *) STRING_TO_JSVAL(str);
676    
677     size_t length = str->length();
678     if (length == 1) {
679     jschar c = str->chars()[0];
680     if (c < UNIT_STRING_LIMIT)
681     return (JSAtom *) STRING_TO_JSVAL(JSString::unitString(c));
682     }
683    
684     /*
685     * Here we know that JSString::intStringTable covers only 256 (or at least
686     * not 1000 or more) chars. We rely on order here to resolve the unit vs.
687     * int string atom identity issue by giving priority to unit strings for
688     * '0' through '9' (see JSString::intString in jsstrinlines.h).
689     */
690     JS_STATIC_ASSERT(INT_STRING_LIMIT <= 999);
691     if (2 <= length && length <= 3) {
692     const jschar *chars = str->chars();
693    
694     if ('1' <= chars[0] && chars[0] <= '9' &&
695     '0' <= chars[1] && chars[1] <= '9' &&
696     (length == 2 || ('0' <= chars[2] && chars[2] <= '9'))) {
697     jsint i = (chars[0] - '0') * 10 + chars[1] - '0';
698    
699     if (length == 3)
700     i = i * 10 + chars[2] - '0';
701     if (jsuint(i) < INT_STRING_LIMIT)
702     return (JSAtom *) STRING_TO_JSVAL(JSString::intString(i));
703     }
704     }
705    
706 siliconforks 332 state = &cx->runtime->atomState;
707     table = &state->stringAtoms;
708    
709     JS_LOCK(cx, &state->lock);
710     entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, str, JS_DHASH_ADD));
711     if (!entry)
712     goto failed_hash_add;
713     if (entry->keyAndFlags != 0) {
714     key = (JSString *)ATOM_ENTRY_KEY(entry);
715     } else {
716     /*
717     * We created a new hashtable entry. Unless str is already allocated
718     * from the GC heap and flat, we have to release state->lock as
719     * string construction is a complex operation. For example, it can
720     * trigger GC which may rehash the table and make the entry invalid.
721     */
722     ++table->generation;
723 siliconforks 507 if (!(flags & ATOM_TMPSTR) && str->isFlat()) {
724     str->flatClearMutable();
725 siliconforks 332 key = str;
726     } else {
727     gen = table->generation;
728     JS_UNLOCK(cx, &state->lock);
729    
730     if (flags & ATOM_TMPSTR) {
731     if (flags & ATOM_NOCOPY) {
732 siliconforks 507 key = js_NewString(cx, str->flatChars(), str->flatLength());
733 siliconforks 332 if (!key)
734     return NULL;
735    
736     /* Finish handing off chars to the GC'ed key string. */
737 siliconforks 507 str->mChars = NULL;
738 siliconforks 332 } else {
739 siliconforks 507 key = js_NewStringCopyN(cx, str->flatChars(), str->flatLength());
740 siliconforks 332 if (!key)
741     return NULL;
742     }
743     } else {
744 siliconforks 507 JS_ASSERT(str->isDependent());
745 siliconforks 332 if (!js_UndependString(cx, str))
746     return NULL;
747     key = str;
748     }
749    
750     JS_LOCK(cx, &state->lock);
751     if (table->generation == gen) {
752     JS_ASSERT(entry->keyAndFlags == 0);
753     } else {
754     entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, key,
755     JS_DHASH_ADD));
756     if (!entry)
757     goto failed_hash_add;
758     if (entry->keyAndFlags != 0) {
759     key = (JSString *)ATOM_ENTRY_KEY(entry);
760     goto finish;
761     }
762     ++table->generation;
763     }
764     }
765     INIT_ATOM_ENTRY(entry, key);
766 siliconforks 507 key->flatSetAtomized();
767 siliconforks 332 }
768    
769     finish:
770     ADD_ATOM_ENTRY_FLAGS(entry, flags & (ATOM_PINNED | ATOM_INTERNED));
771 siliconforks 507 JS_ASSERT(key->isAtomized());
772 siliconforks 332 v = STRING_TO_JSVAL(key);
773     cx->weakRoots.lastAtom = v;
774     JS_UNLOCK(cx, &state->lock);
775     return (JSAtom *)v;
776    
777     failed_hash_add:
778     JS_UNLOCK(cx, &state->lock);
779     JS_ReportOutOfMemory(cx);
780     return NULL;
781     }
782    
783     JSAtom *
784     js_Atomize(JSContext *cx, const char *bytes, size_t length, uintN flags)
785     {
786     jschar *chars;
787     JSString str;
788     JSAtom *atom;
789    
790     /*
791     * Avoiding the malloc in js_InflateString on shorter strings saves us
792     * over 20,000 malloc calls on mozilla browser startup. This compares to
793     * only 131 calls where the string is longer than a 31 char (net) buffer.
794     * The vast majority of atomized strings are already in the hashtable. So
795     * js_AtomizeString rarely has to copy the temp string we make.
796     */
797     #define ATOMIZE_BUF_MAX 32
798     jschar inflated[ATOMIZE_BUF_MAX];
799     size_t inflatedLength = ATOMIZE_BUF_MAX - 1;
800    
801     if (length < ATOMIZE_BUF_MAX) {
802     js_InflateStringToBuffer(cx, bytes, length, inflated, &inflatedLength);
803     inflated[inflatedLength] = 0;
804     chars = inflated;
805     } else {
806     inflatedLength = length;
807     chars = js_InflateString(cx, bytes, &inflatedLength);
808     if (!chars)
809     return NULL;
810     flags |= ATOM_NOCOPY;
811     }
812    
813 siliconforks 507 str.initFlat(chars, inflatedLength);
814 siliconforks 332 atom = js_AtomizeString(cx, &str, ATOM_TMPSTR | flags);
815 siliconforks 507 if (chars != inflated && str.flatChars())
816     cx->free(chars);
817 siliconforks 332 return atom;
818     }
819    
820     JSAtom *
821     js_AtomizeChars(JSContext *cx, const jschar *chars, size_t length, uintN flags)
822     {
823     JSString str;
824    
825 siliconforks 507 str.initFlat((jschar *)chars, length);
826 siliconforks 332 return js_AtomizeString(cx, &str, ATOM_TMPSTR | flags);
827     }
828    
829     JSAtom *
830     js_GetExistingStringAtom(JSContext *cx, const jschar *chars, size_t length)
831     {
832     JSString str, *str2;
833     JSAtomState *state;
834     JSDHashEntryHdr *hdr;
835    
836 siliconforks 507 if (length == 1) {
837     jschar c = *chars;
838     if (c < UNIT_STRING_LIMIT)
839     return (JSAtom *) STRING_TO_JSVAL(JSString::unitString(c));
840     }
841    
842     str.initFlat((jschar *)chars, length);
843 siliconforks 332 state = &cx->runtime->atomState;
844    
845     JS_LOCK(cx, &state->lock);
846     hdr = JS_DHashTableOperate(&state->stringAtoms, &str, JS_DHASH_LOOKUP);
847     str2 = JS_DHASH_ENTRY_IS_BUSY(hdr)
848     ? (JSString *)ATOM_ENTRY_KEY(TO_ATOM_ENTRY(hdr))
849     : NULL;
850     JS_UNLOCK(cx, &state->lock);
851    
852     return str2 ? (JSAtom *)STRING_TO_JSVAL(str2) : NULL;
853     }
854    
855     JSBool
856     js_AtomizePrimitiveValue(JSContext *cx, jsval v, JSAtom **atomp)
857     {
858     JSAtom *atom;
859    
860     if (JSVAL_IS_STRING(v)) {
861     atom = js_AtomizeString(cx, JSVAL_TO_STRING(v), 0);
862     if (!atom)
863     return JS_FALSE;
864     } else if (JSVAL_IS_DOUBLE(v)) {
865     atom = js_AtomizeDouble(cx, *JSVAL_TO_DOUBLE(v));
866     if (!atom)
867     return JS_FALSE;
868     } else {
869     JS_ASSERT(JSVAL_IS_INT(v) || JSVAL_IS_BOOLEAN(v) ||
870     JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v));
871     atom = (JSAtom *)v;
872     }
873     *atomp = atom;
874     return JS_TRUE;
875     }
876    
877     #ifdef DEBUG
878    
879     static JSDHashOperator
880     atom_dumper(JSDHashTable *table, JSDHashEntryHdr *hdr,
881     uint32 number, void *arg)
882     {
883     JSAtomHashEntry *entry = TO_ATOM_ENTRY(hdr);
884     FILE *fp = (FILE *)arg;
885     void *key;
886     uintN flags;
887    
888     fprintf(fp, "%3u %08x ", number, (uintN)entry->hdr.keyHash);
889     if (entry->keyAndFlags == 0) {
890     fputs("<uninitialized>", fp);
891     } else {
892     key = ATOM_ENTRY_KEY(entry);
893     if (IS_DOUBLE_TABLE(table)) {
894     fprintf(fp, "%.16g", *(jsdouble *)key);
895     } else {
896     JS_ASSERT(IS_STRING_TABLE(table));
897     js_FileEscapedString(fp, (JSString *)key, '"');
898     }
899     flags = ATOM_ENTRY_FLAGS(entry);
900     if (flags != 0) {
901     fputs((flags & (ATOM_PINNED | ATOM_INTERNED))
902     ? " pinned | interned"
903     : (flags & ATOM_PINNED) ? " pinned" : " interned",
904     fp);
905     }
906     }
907     putc('\n', fp);
908     return JS_DHASH_NEXT;
909     }
910    
911     JS_FRIEND_API(void)
912     js_DumpAtoms(JSContext *cx, FILE *fp)
913     {
914     JSAtomState *state = &cx->runtime->atomState;
915    
916     fprintf(fp, "stringAtoms table contents:\n");
917     JS_DHashTableEnumerate(&state->stringAtoms, atom_dumper, fp);
918     #ifdef JS_DHASHMETER
919     JS_DHashTableDumpMeter(&state->stringAtoms, atom_dumper, fp);
920     #endif
921     putc('\n', fp);
922    
923     fprintf(fp, "doubleAtoms table contents:\n");
924     JS_DHashTableEnumerate(&state->doubleAtoms, atom_dumper, fp);
925     #ifdef JS_DHASHMETER
926     JS_DHashTableDumpMeter(&state->doubleAtoms, atom_dumper, fp);
927     #endif
928     putc('\n', fp);
929     }
930    
931     #endif
932    
933     static JSHashNumber
934     js_hash_atom_ptr(const void *key)
935     {
936     const JSAtom *atom = (const JSAtom *) key;
937     return ATOM_HASH(atom);
938     }
939    
940 siliconforks 460 #if JS_BITS_PER_WORD == 32
941     # define TEMP_SIZE_START_LOG2 5
942     #else
943     # define TEMP_SIZE_START_LOG2 6
944     #endif
945     #define TEMP_SIZE_LIMIT_LOG2 (TEMP_SIZE_START_LOG2 + NUM_TEMP_FREELISTS)
946    
947     #define TEMP_SIZE_START JS_BIT(TEMP_SIZE_START_LOG2)
948     #define TEMP_SIZE_LIMIT JS_BIT(TEMP_SIZE_LIMIT_LOG2)
949    
950     JS_STATIC_ASSERT(TEMP_SIZE_START >= sizeof(JSHashTable));
951    
952 siliconforks 332 static void *
953     js_alloc_temp_space(void *priv, size_t size)
954     {
955 siliconforks 460 JSCompiler *jsc = (JSCompiler *) priv;
956    
957 siliconforks 332 void *space;
958 siliconforks 460 if (size < TEMP_SIZE_LIMIT) {
959     int bin = JS_CeilingLog2(size) - TEMP_SIZE_START_LOG2;
960     JS_ASSERT(unsigned(bin) < NUM_TEMP_FREELISTS);
961 siliconforks 332
962 siliconforks 460 space = jsc->tempFreeList[bin];
963     if (space) {
964     jsc->tempFreeList[bin] = *(void **)space;
965     return space;
966     }
967     }
968    
969     JS_ARENA_ALLOCATE(space, &jsc->context->tempPool, size);
970 siliconforks 332 if (!space)
971 siliconforks 460 js_ReportOutOfScriptQuota(jsc->context);
972 siliconforks 332 return space;
973     }
974    
975     static void
976 siliconforks 460 js_free_temp_space(void *priv, void *item, size_t size)
977 siliconforks 332 {
978 siliconforks 460 if (size >= TEMP_SIZE_LIMIT)
979     return;
980    
981     JSCompiler *jsc = (JSCompiler *) priv;
982     int bin = JS_CeilingLog2(size) - TEMP_SIZE_START_LOG2;
983     JS_ASSERT(unsigned(bin) < NUM_TEMP_FREELISTS);
984    
985     *(void **)item = jsc->tempFreeList[bin];
986     jsc->tempFreeList[bin] = item;
987 siliconforks 332 }
988    
989     static JSHashEntry *
990     js_alloc_temp_entry(void *priv, const void *key)
991     {
992 siliconforks 460 JSCompiler *jsc = (JSCompiler *) priv;
993 siliconforks 332 JSAtomListElement *ale;
994    
995 siliconforks 460 ale = jsc->aleFreeList;
996     if (ale) {
997     jsc->aleFreeList = ALE_NEXT(ale);
998     return &ale->entry;
999     }
1000    
1001     JS_ARENA_ALLOCATE_TYPE(ale, JSAtomListElement, &jsc->context->tempPool);
1002 siliconforks 332 if (!ale) {
1003 siliconforks 460 js_ReportOutOfScriptQuota(jsc->context);
1004 siliconforks 332 return NULL;
1005     }
1006     return &ale->entry;
1007     }
1008    
1009     static void
1010     js_free_temp_entry(void *priv, JSHashEntry *he, uintN flag)
1011     {
1012 siliconforks 460 JSCompiler *jsc = (JSCompiler *) priv;
1013     JSAtomListElement *ale = (JSAtomListElement *) he;
1014    
1015     ALE_SET_NEXT(ale, jsc->aleFreeList);
1016     jsc->aleFreeList = ale;
1017 siliconforks 332 }
1018    
1019     static JSHashAllocOps temp_alloc_ops = {
1020     js_alloc_temp_space, js_free_temp_space,
1021     js_alloc_temp_entry, js_free_temp_entry
1022     };
1023    
1024     JSAtomListElement *
1025 siliconforks 460 JSAtomList::rawLookup(JSAtom *atom, JSHashEntry **&hep)
1026 siliconforks 332 {
1027 siliconforks 460 JSAtomListElement *ale;
1028    
1029     if (table) {
1030     hep = JS_HashTableRawLookup(table, ATOM_HASH(atom), atom);
1031     ale = *hep ? (JSAtomListElement *) *hep : NULL;
1032     } else {
1033     JSHashEntry **alep = &list;
1034     hep = NULL;
1035     while ((ale = (JSAtomListElement *)*alep) != NULL) {
1036     if (ALE_ATOM(ale) == atom) {
1037     /* Hit, move atom's element to the front of the list. */
1038     *alep = ale->entry.next;
1039     ale->entry.next = list;
1040     list = &ale->entry;
1041     break;
1042     }
1043     alep = &ale->entry.next;
1044     }
1045     }
1046     return ale;
1047     }
1048    
1049     #define ATOM_LIST_HASH_THRESHOLD 12
1050    
1051     JSAtomListElement *
1052     JSAtomList::add(JSCompiler *jsc, JSAtom *atom, AddHow how)
1053     {
1054     JS_ASSERT(!set);
1055    
1056 siliconforks 332 JSAtomListElement *ale, *ale2, *next;
1057     JSHashEntry **hep;
1058    
1059 siliconforks 460 ale = rawLookup(atom, hep);
1060     if (!ale || how != UNIQUE) {
1061     if (count < ATOM_LIST_HASH_THRESHOLD && !table) {
1062     /* Few enough for linear search and no hash table yet needed. */
1063     ale = (JSAtomListElement *)js_alloc_temp_entry(jsc, atom);
1064 siliconforks 332 if (!ale)
1065     return NULL;
1066     ALE_SET_ATOM(ale, atom);
1067 siliconforks 460
1068     if (how == HOIST) {
1069     ale->entry.next = NULL;
1070     hep = (JSHashEntry **) &list;
1071     while (*hep)
1072     hep = &(*hep)->next;
1073     *hep = &ale->entry;
1074     } else {
1075     ale->entry.next = list;
1076     list = &ale->entry;
1077     }
1078 siliconforks 332 } else {
1079 siliconforks 460 /*
1080     * We should hash, or else we already are hashing, but count was
1081     * reduced by JSAtomList::rawRemove below ATOM_LIST_HASH_THRESHOLD.
1082     * Check whether we should create the table.
1083     */
1084     if (!table) {
1085 siliconforks 332 /* No hash table yet, so hep had better be null! */
1086     JS_ASSERT(!hep);
1087 siliconforks 460 table = JS_NewHashTable(count + 1, js_hash_atom_ptr,
1088     JS_CompareValues, JS_CompareValues,
1089     &temp_alloc_ops, jsc);
1090     if (!table)
1091 siliconforks 332 return NULL;
1092    
1093     /*
1094     * Set ht->nentries explicitly, because we are moving entries
1095 siliconforks 460 * from list to ht, not calling JS_HashTable(Raw|)Add.
1096 siliconforks 332 */
1097 siliconforks 460 table->nentries = count;
1098 siliconforks 332
1099 siliconforks 460 /*
1100     * Insert each ale on list into the new hash table. Append to
1101     * the hash chain rather than inserting at the bucket head, to
1102     * preserve order among entries with the same key.
1103     */
1104     for (ale2 = (JSAtomListElement *)list; ale2; ale2 = next) {
1105 siliconforks 332 next = ALE_NEXT(ale2);
1106     ale2->entry.keyHash = ATOM_HASH(ALE_ATOM(ale2));
1107 siliconforks 460 hep = JS_HashTableRawLookup(table, ale2->entry.keyHash,
1108 siliconforks 332 ale2->entry.key);
1109 siliconforks 460 while (*hep)
1110     hep = &(*hep)->next;
1111 siliconforks 332 *hep = &ale2->entry;
1112 siliconforks 460 ale2->entry.next = NULL;
1113 siliconforks 332 }
1114 siliconforks 460 list = NULL;
1115 siliconforks 332
1116     /* Set hep for insertion of atom's ale, immediately below. */
1117 siliconforks 460 hep = JS_HashTableRawLookup(table, ATOM_HASH(atom), atom);
1118 siliconforks 332 }
1119    
1120     /* Finally, add an entry for atom into the hash bucket at hep. */
1121     ale = (JSAtomListElement *)
1122 siliconforks 460 JS_HashTableRawAdd(table, hep, ATOM_HASH(atom), atom, NULL);
1123 siliconforks 332 if (!ale)
1124     return NULL;
1125 siliconforks 460
1126     /*
1127     * If hoisting, move ale to the end of its chain after we called
1128     * JS_HashTableRawAdd, since RawAdd may have grown the table and
1129     * then recomputed hep to refer to the pointer to the first entry
1130     * with the given key.
1131     */
1132     if (how == HOIST && ale->entry.next) {
1133 siliconforks 507 JS_ASSERT(*hep == &ale->entry);
1134 siliconforks 460 *hep = ale->entry.next;
1135     ale->entry.next = NULL;
1136     do {
1137     hep = &(*hep)->next;
1138     } while (*hep);
1139     *hep = &ale->entry;
1140     }
1141 siliconforks 332 }
1142    
1143 siliconforks 460 ALE_SET_INDEX(ale, count++);
1144 siliconforks 332 }
1145     return ale;
1146     }
1147    
1148 siliconforks 460 void
1149     JSAtomList::rawRemove(JSCompiler *jsc, JSAtomListElement *ale, JSHashEntry **hep)
1150     {
1151     JS_ASSERT(!set);
1152     JS_ASSERT(count != 0);
1153    
1154     if (table) {
1155     JS_ASSERT(hep);
1156     JS_HashTableRawRemove(table, hep, &ale->entry);
1157     } else {
1158     JS_ASSERT(!hep);
1159     hep = &list;
1160     while (*hep != &ale->entry) {
1161     JS_ASSERT(*hep);
1162     hep = &(*hep)->next;
1163     }
1164     *hep = ale->entry.next;
1165     js_free_temp_entry(jsc, &ale->entry, HT_FREE_ENTRY);
1166     }
1167    
1168     --count;
1169     }
1170    
1171     JSAtomListElement *
1172     JSAtomListIterator::operator ()()
1173     {
1174     JSAtomListElement *ale;
1175     JSHashTable *ht;
1176    
1177     if (index == uint32(-1))
1178     return NULL;
1179    
1180     ale = next;
1181     if (!ale) {
1182     ht = list->table;
1183     if (!ht)
1184     goto done;
1185     do {
1186     if (index == JS_BIT(JS_HASH_BITS - ht->shift))
1187     goto done;
1188     next = (JSAtomListElement *) ht->buckets[index++];
1189     } while (!next);
1190     ale = next;
1191     }
1192    
1193     next = ALE_NEXT(ale);
1194     return ale;
1195    
1196     done:
1197     index = uint32(-1);
1198     return NULL;
1199     }
1200    
1201 siliconforks 332 static intN
1202     js_map_atom(JSHashEntry *he, intN i, void *arg)
1203     {
1204     JSAtomListElement *ale = (JSAtomListElement *)he;
1205     JSAtom **vector = (JSAtom **) arg;
1206    
1207     vector[ALE_INDEX(ale)] = ALE_ATOM(ale);
1208     return HT_ENUMERATE_NEXT;
1209     }
1210    
1211     #ifdef DEBUG
1212     static jsrefcount js_atom_map_count;
1213     static jsrefcount js_atom_map_hash_table_count;
1214     #endif
1215    
1216     void
1217     js_InitAtomMap(JSContext *cx, JSAtomMap *map, JSAtomList *al)
1218     {
1219     JSAtom **vector;
1220     JSAtomListElement *ale;
1221     uint32 count;
1222    
1223     /* Map length must already be initialized. */
1224     JS_ASSERT(al->count == map->length);
1225     #ifdef DEBUG
1226     JS_ATOMIC_INCREMENT(&js_atom_map_count);
1227     #endif
1228     ale = (JSAtomListElement *)al->list;
1229     if (!ale && !al->table) {
1230     JS_ASSERT(!map->vector);
1231     return;
1232     }
1233    
1234     count = al->count;
1235     vector = map->vector;
1236     if (al->table) {
1237     #ifdef DEBUG
1238     JS_ATOMIC_INCREMENT(&js_atom_map_hash_table_count);
1239     #endif
1240     JS_HashTableEnumerateEntries(al->table, js_map_atom, vector);
1241     } else {
1242     do {
1243     vector[ALE_INDEX(ale)] = ALE_ATOM(ale);
1244     } while ((ale = ALE_NEXT(ale)) != NULL);
1245     }
1246 siliconforks 460 al->clear();
1247 siliconforks 332 }

  ViewVC Help
Powered by ViewVC 1.1.24