1		/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2		*
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 execution context.
42		*/
43		#include "jsstddef.h"
44		#include <stdarg.h>
45		#include <stdlib.h>
46		#include <string.h>
47		#include "jstypes.h"
48		#include "jsarena.h" /* Added by JSIFY */
49		#include "jsutil.h" /* Added by JSIFY */
50		#include "jsclist.h"
51		#include "jsprf.h"
52		#include "jsatom.h"
53		#include "jscntxt.h"
54		#include "jsconfig.h"
55		#include "jsdbgapi.h"
56		#include "jsexn.h"
57		#include "jsgc.h"
58		#include "jslock.h"
59		#include "jsnum.h"
60		#include "jsobj.h"
61		#include "jsopcode.h"
62		#include "jsscan.h"
63		#include "jsscript.h"
64		#include "jsstr.h"
65
66		void
67		js_OnVersionChange(JSContext *cx)
68	0	{
69		#if !JS_BUG_FALLIBLE_EQOPS
70	0	if (JS_VERSION_IS_1_2(cx)) {
71	0	cx->jsop_eq = JSOP_NEW_EQ;
72	0	cx->jsop_ne = JSOP_NEW_NE;
73		} else {
74	0	cx->jsop_eq = JSOP_EQ;
75	0	cx->jsop_ne = JSOP_NE;
76		}
77		#endif /* !JS_BUG_FALLIBLE_EQOPS */
78		}
79
80		void
81		js_SetVersion(JSContext *cx, JSVersion version)
82	0	{
83	0	cx->version = version;
84	0	js_OnVersionChange(cx);
85		}
86
87		JSContext *
88		js_NewContext(JSRuntime *rt, size_t stackChunkSize)
89	16	{
90	16	JSContext *cx;
91	16	JSBool ok, first;
92
93	16	cx = (JSContext *) malloc(sizeof *cx);
94	16	if (!cx)
95	0	return NULL;
96	16	memset(cx, 0, sizeof *cx);
97
98	16	cx->runtime = rt;
99		#if JS_STACK_GROWTH_DIRECTION > 0
100		cx->stackLimit = (jsuword)-1;
101		#endif
102		#ifdef JS_THREADSAFE
103		js_InitContextForLocking(cx);
104		#endif
105
106	16	JS_LOCK_GC(rt);
107	32	for (;;) {
108	16	first = (rt->contextList.next == &rt->contextList);
109	16	if (rt->state == JSRTS_UP) {
110	0	JS_ASSERT(!first);
111	0	break;
112		}
113	16	if (rt->state == JSRTS_DOWN) {
114	16	JS_ASSERT(first);
115	16	rt->state = JSRTS_LAUNCHING;
116		break;
117		}
118	16	JS_WAIT_CONDVAR(rt->stateChange, JS_NO_TIMEOUT);
119		}
120	16	JS_APPEND_LINK(&cx->links, &rt->contextList);
121	16	JS_UNLOCK_GC(rt);
122
123		/*
124		* First we do the infallible, every-time per-context initializations.
125		* Should a later, fallible initialization (js_InitRegExpStatics, e.g.,
126		* or the stuff under 'if (first)' below) fail, at least the version
127		* and arena-pools will be valid and safe to use (say, from the last GC
128		* done by js_DestroyContext).
129		*/
130	16	cx->version = JSVERSION_DEFAULT;
131	16	cx->jsop_eq = JSOP_EQ;
132	16	cx->jsop_ne = JSOP_NE;
133	16	JS_InitArenaPool(&cx->stackPool, "stack", stackChunkSize, sizeof(jsval));
134	16	JS_InitArenaPool(&cx->tempPool, "temp", 1024, sizeof(jsdouble));
135
136		#if JS_HAS_REGEXPS
137	16	if (!js_InitRegExpStatics(cx, &cx->regExpStatics)) {
138	0	js_DestroyContext(cx, JS_NO_GC);
139	0	return NULL;
140		}
141		#endif
142		#if JS_HAS_EXCEPTIONS
143	16	cx->throwing = JS_FALSE;
144		#endif
145
146		/*
147		* If cx is the first context on this runtime, initialize well-known atoms,
148		* keywords, numbers, and strings.  If one of these steps should fail, the
149		* runtime will be left in a partially initialized state, with zeroes and
150		* nulls stored in the default-initialized remainder of the struct.  We'll
151		* clean the runtime up under js_DestroyContext, because cx will be "last"
152		* as well as "first".
153		*/
154	16	if (first) {
155		/*
156		* Both atomState and the scriptFilenameTable may be left over from a
157		* previous episode of non-zero contexts alive in rt, so don't re-init
158		* either table if it's not necessary.  Just repopulate atomState with
159		* well-known internal atoms, and with the reserved identifiers added
160		* by the scanner.
161		*/
162	16	ok = (rt->atomState.liveAtoms == 0)
163		? js_InitAtomState(cx, &rt->atomState)
164		: js_InitPinnedAtoms(cx, &rt->atomState);
165	16	if (ok)
166	16	ok = js_InitScanner(cx);
167	16	if (ok && !rt->scriptFilenameTable)
168	16	ok = js_InitRuntimeScriptState(rt);
169	16	if (ok)
170	16	ok = js_InitRuntimeNumberState(cx);
171	16	if (ok)
172	16	ok = js_InitRuntimeStringState(cx);
173	16	if (!ok) {
174	0	js_DestroyContext(cx, JS_NO_GC);
175	0	return NULL;
176		}
177
178	16	JS_LOCK_GC(rt);
179	16	rt->state = JSRTS_UP;
180	16	JS_NOTIFY_ALL_CONDVAR(rt->stateChange);
181	16	JS_UNLOCK_GC(rt);
182		}
183
184	16	return cx;
185		}
186
187		void
188		js_DestroyContext(JSContext *cx, JSGCMode gcmode)
189	16	{
190	16	JSRuntime *rt;
191	16	JSBool last;
192	16	JSArgumentFormatMap *map;
193	16	JSLocalRootStack *lrs;
194	16	JSLocalRootChunk *lrc;
195
196	16	rt = cx->runtime;
197
198		/* Remove cx from context list first. */
199	16	JS_LOCK_GC(rt);
200	16	JS_ASSERT(rt->state == JSRTS_UP || rt->state == JSRTS_LAUNCHING);
201	16	JS_REMOVE_LINK(&cx->links);
202	16	last = (rt->contextList.next == &rt->contextList);
203	16	if (last)
204	16	rt->state = JSRTS_LANDING;
205	16	JS_UNLOCK_GC(rt);
206
207	16	if (last) {
208		#ifdef JS_THREADSAFE
209		/*
210		* If cx is not in a request already, begin one now so that we wait
211		* for any racing GC started on a not-last context to finish, before
212		* we plow ahead and unpin atoms.  Note that even though we begin a
213		* request here if necessary, we end all requests on cx below before
214		* forcing a final GC.  This lets any not-last context destruction
215		* racing in another thread try to force or maybe run the GC, but by
216		* that point, rt->state will not be JSRTS_UP, and that GC attempt
217		* will return early.
218		*/
219		if (cx->requestDepth == 0)
220		JS_BeginRequest(cx);
221		#endif
222
223		/* Unpin all pinned atoms before final GC. */
224	16	js_UnpinPinnedAtoms(&rt->atomState);
225
226		/* Unlock and clear GC things held by runtime pointers. */
227	16	js_FinishRuntimeNumberState(cx);
228	16	js_FinishRuntimeStringState(cx);
229
230		/* Clear debugging state to remove GC roots. */
231	16	JS_ClearAllTraps(cx);
232	16	JS_ClearAllWatchPoints(cx);
233		}
234
235		#if JS_HAS_REGEXPS
236		/*
237		* Remove more GC roots in regExpStatics, then collect garbage.
238		* XXX anti-modularity alert: we rely on the call to js_RemoveRoot within
239		* XXX this function call to wait for any racing GC to complete, in the
240		* XXX case where JS_DestroyContext is called outside of a request on cx
241		*/
242	16	js_FreeRegExpStatics(cx, &cx->regExpStatics);
243		#endif
244
245		#ifdef JS_THREADSAFE
246		/*
247		* Destroying a context implicitly calls JS_EndRequest().  Also, we must
248		* end our request here in case we are "last" -- in that event, another
249		* js_DestroyContext that was not last might be waiting in the GC for our
250		* request to end.  We'll let it run below, just before we do the truly
251		* final GC and then free atom state.
252		*
253		* At this point, cx must be inaccessible to other threads.  It's off the
254		* rt->contextList, and it should not be reachable via any object private
255		* data structure.
256		*/
257		while (cx->requestDepth != 0)
258		JS_EndRequest(cx);
259		#endif
260
261	16	if (last) {
262		/* Always force, so we wait for any racing GC to finish. */
263	16	js_ForceGC(cx, GC_LAST_CONTEXT);
264
265		/* Iterate until no finalizer removes a GC root or lock. */
266	16	while (rt->gcPoke)
267	0	js_GC(cx, GC_LAST_CONTEXT);
268
269		/* Try to free atom state, now that no unrooted scripts survive. */
270	16	if (rt->atomState.liveAtoms == 0)
271	0	js_FreeAtomState(cx, &rt->atomState);
272
273		/* Also free the script filename table if it exists and is empty. */
274	16	if (rt->scriptFilenameTable && rt->scriptFilenameTable->nentries == 0)
275	16	js_FinishRuntimeScriptState(rt);
276
277		/* Take the runtime down, now that it has no contexts or atoms. */
278	16	JS_LOCK_GC(rt);
279	16	rt->state = JSRTS_DOWN;
280	16	JS_NOTIFY_ALL_CONDVAR(rt->stateChange);
281	16	JS_UNLOCK_GC(rt);
282		} else {
283	0	if (gcmode == JS_FORCE_GC)
284	0	js_ForceGC(cx, 0);
285	0	else if (gcmode == JS_MAYBE_GC)
286	0	JS_MaybeGC(cx);
287		}
288
289		/* Free the stuff hanging off of cx. */
290	16	JS_FinishArenaPool(&cx->stackPool);
291	16	JS_FinishArenaPool(&cx->tempPool);
292	16	if (cx->lastMessage)
293	0	free(cx->lastMessage);
294
295		/* Remove any argument formatters. */
296	16	map = cx->argumentFormatMap;
297	16	while (map) {
298	0	JSArgumentFormatMap *temp = map;
299	0	map = map->next;
300	0	JS_free(cx, temp);
301		}
302
303		/* Destroy the resolve recursion damper. */
304	16	if (cx->resolvingTable) {
305	16	JS_DHashTableDestroy(cx->resolvingTable);
306	16	cx->resolvingTable = NULL;
307		}
308
309	16	lrs = cx->localRootStack;
310	16	if (lrs) {
311	0	while ((lrc = lrs->topChunk) != &lrs->firstChunk) {
312	0	lrs->topChunk = lrc->down;
313	0	JS_free(cx, lrc);
314		}
315	0	JS_free(cx, lrs);
316		}
317
318		/* Finally, free cx itself. */
319	16	free(cx);
320		}
321
322		JSBool
323		js_ValidContextPointer(JSRuntime *rt, JSContext *cx)
324	0	{
325	0	JSCList *cl;
326
327	0	for (cl = rt->contextList.next; cl != &rt->contextList; cl = cl->next) {
328	0	if (cl == &cx->links)
329	0	return JS_TRUE;
330		}
331		JS_RUNTIME_METER(rt, deadContexts);
332	0	return JS_FALSE;
333		}
334
335		JSContext *
336		js_ContextIterator(JSRuntime *rt, JSBool unlocked, JSContext **iterp)
337	32	{
338	32	JSContext *cx = *iterp;
339
340	32	if (unlocked)
341	32	JS_LOCK_GC(rt);
342	32	if (!cx)
343	32	cx = (JSContext *)&rt->contextList;
344	32	cx = (JSContext *)cx->links.next;
345	32	if (&cx->links == &rt->contextList)
346	32	cx = NULL;
347	32	*iterp = cx;
348	32	if (unlocked)
349	32	JS_UNLOCK_GC(rt);
350	32	return cx;
351		}
352
353		JS_STATIC_DLL_CALLBACK(const void *)
354		resolving_GetKey(JSDHashTable *table, JSDHashEntryHdr *hdr)
355	0	{
356	0	JSResolvingEntry *entry = (JSResolvingEntry *)hdr;
357
358	0	return &entry->key;
359		}
360
361		JS_STATIC_DLL_CALLBACK(JSDHashNumber)
362		resolving_HashKey(JSDHashTable *table, const void *ptr)
363	285488	{
364	285488	const JSResolvingKey *key = (const JSResolvingKey *)ptr;
365
366	285488	return ((JSDHashNumber)JS_PTR_TO_UINT32(key->obj) >> JSVAL_TAGBITS) ^ key->id;
367		}
368
369		JS_PUBLIC_API(JSBool)
370		resolving_MatchEntry(JSDHashTable *table,
371		const JSDHashEntryHdr *hdr,
372		const void *ptr)
373	4976	{
374	4976	const JSResolvingEntry *entry = (const JSResolvingEntry *)hdr;
375	4976	const JSResolvingKey *key = (const JSResolvingKey *)ptr;
376
377	4976	return entry->key.obj == key->obj && entry->key.id == key->id;
378		}
379
380		static const JSDHashTableOps resolving_dhash_ops = {
381		JS_DHashAllocTable,
382		JS_DHashFreeTable,
383		resolving_GetKey,
384		resolving_HashKey,
385		resolving_MatchEntry,
386		JS_DHashMoveEntryStub,
387		JS_DHashClearEntryStub,
388		JS_DHashFinalizeStub,
389		NULL
390		};
391
392		JSBool
393		js_StartResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
394		JSResolvingEntry **entryp)
395	280512	{
396	280512	JSDHashTable *table;
397	280512	JSResolvingEntry *entry;
398
399	280512	table = cx->resolvingTable;
400	280512	if (!table) {
401	16	table = JS_NewDHashTable(&resolving_dhash_ops, NULL,
402		sizeof(JSResolvingEntry),
403		JS_DHASH_MIN_SIZE);
404	16	if (!table)
405	0	goto outofmem;
406	16	cx->resolvingTable = table;
407		}
408
409	280512	entry = (JSResolvingEntry *)
410		JS_DHashTableOperate(table, key, JS_DHASH_ADD);
411	280512	if (!entry)
412	0	goto outofmem;
413
414	280512	if (entry->flags & flag) {
415		/* An entry for (key, flag) exists already -- dampen recursion. */
416	0	entry = NULL;
417		} else {
418		/* Fill in key if we were the first to add entry, then set flag. */
419	280512	if (!entry->key.obj)
420	280512	entry->key = *key;
421	280512	entry->flags |= flag;
422		}
423	280512	*entryp = entry;
424	280512	return JS_TRUE;
425
426		outofmem:
427	0	JS_ReportOutOfMemory(cx);
428	0	return JS_FALSE;
429		}
430
431		void
432		js_StopResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
433		JSResolvingEntry *entry, uint32 generation)
434	280512	{
435	280512	JSDHashTable *table;
436
437		/*
438		* Clear flag from entry->flags and return early if other flags remain.
439		* We must take care to re-lookup entry if the table has changed since
440		* it was found by js_StartResolving.
441		*/
442	280512	table = cx->resolvingTable;
443	280512	if (!entry || table->generation != generation) {
444	0	entry = (JSResolvingEntry *)
445		JS_DHashTableOperate(table, key, JS_DHASH_LOOKUP);
446		}
447	280512	JS_ASSERT(JS_DHASH_ENTRY_IS_BUSY(&entry->hdr));
448	280512	entry->flags &= ~flag;
449	280512	if (entry->flags)
450	0	return;
451
452		/*
453		* Do a raw remove only if fewer entries were removed than would cause
454		* alpha to be less than .5 (alpha is at most .75).  Otherwise, we just
455		* call JS_DHashTableOperate to re-lookup the key and remove its entry,
456		* compressing or shrinking the table as needed.
457		*/
458	280512	if (table->removedCount < JS_DHASH_TABLE_SIZE(table) >> 2)
459	275536	JS_DHashTableRawRemove(table, &entry->hdr);
460		else
461	4976	JS_DHashTableOperate(table, key, JS_DHASH_REMOVE);
462		}
463
464		JSBool
465		js_EnterLocalRootScope(JSContext *cx)
466	16	{
467	16	JSLocalRootStack *lrs;
468	16	int mark;
469
470	16	lrs = cx->localRootStack;
471	16	if (!lrs) {
472	16	lrs = (JSLocalRootStack *) JS_malloc(cx, sizeof *lrs);
473	16	if (!lrs)
474	0	return JS_FALSE;
475	16	lrs->scopeMark = JSLRS_NULL_MARK;
476	16	lrs->rootCount = 0;
477	16	lrs->topChunk = &lrs->firstChunk;
478	16	lrs->firstChunk.down = NULL;
479	16	cx->localRootStack = lrs;
480		}
481
482		/* Push lrs->scopeMark to save it for restore when leaving. */
483	16	mark = js_PushLocalRoot(cx, lrs, INT_TO_JSVAL(lrs->scopeMark));
484	16	if (mark < 0)
485	0	return JS_FALSE;
486	16	lrs->scopeMark = (uint32) mark;
487	16	return JS_TRUE;
488		}
489
490		void
491		js_LeaveLocalRootScope(JSContext *cx)
492	16	{
493	16	JSLocalRootStack *lrs;
494	16	unsigned mark, m, n;
495	16	JSLocalRootChunk *lrc;
496
497		/* Defend against buggy native callers. */
498	16	lrs = cx->localRootStack;
499	16	JS_ASSERT(lrs && lrs->rootCount != 0);
500	16	if (!lrs || lrs->rootCount == 0)
501	0	return;
502
503	16	mark = lrs->scopeMark;
504	16	JS_ASSERT(mark != JSLRS_NULL_MARK);
505	16	if (mark == JSLRS_NULL_MARK)
506	0	return;
507
508		/* Free any chunks being popped by this leave operation. */
509	16	m = mark >> JSLRS_CHUNK_SHIFT;
510	16	n = (lrs->rootCount - 1) >> JSLRS_CHUNK_SHIFT;
511	16	while (n > m) {
512	0	lrc = lrs->topChunk;
513	0	JS_ASSERT(lrc != &lrs->firstChunk);
514	0	lrs->topChunk = lrc->down;
515	0	JS_free(cx, lrc);
516	0	--n;
517		}
518
519		/* Pop the scope, restoring lrs->scopeMark. */
520	16	lrc = lrs->topChunk;
521	16	m = mark & JSLRS_CHUNK_MASK;
522	16	lrs->scopeMark = (uint32) JSVAL_TO_INT(lrc->roots[m]);
523	16	lrc->roots[m] = JSVAL_NULL;
524	16	lrs->rootCount = (uint32) mark;
525
526		/*
527		* Free the stack eagerly, risking malloc churn.  The alternative would
528		* require an lrs->entryCount member, maintained by Enter and Leave, and
529		* tested by the GC in addition to the cx->localRootStack non-null test.
530		*
531		* That approach would risk hoarding 264 bytes (net) per context.  Right
532		* now it seems better to give fresh (dirty in CPU write-back cache, and
533		* the data is no longer needed) memory back to the malloc heap.
534		*/
535	16	if (mark == 0) {
536	16	cx->localRootStack = NULL;
537	16	JS_free(cx, lrs);
538	0	} else if (m == 0) {
539	0	lrs->topChunk = lrc->down;
540	0	JS_free(cx, lrc);
541		}
542		}
543
544		void
545		js_ForgetLocalRoot(JSContext *cx, jsval v)
546	0	{
547	0	JSLocalRootStack *lrs;
548	0	unsigned i, j, m, n, mark;
549	0	JSLocalRootChunk *lrc, *lrc2;
550	0	jsval top;
551
552	0	lrs = cx->localRootStack;
553	0	JS_ASSERT(lrs && lrs->rootCount);
554	0	if (!lrs || lrs->rootCount == 0)
555	0	return;
556
557		/* Prepare to pop the top-most value from the stack. */
558	0	n = lrs->rootCount - 1;
559	0	m = n & JSLRS_CHUNK_MASK;
560	0	lrc = lrs->topChunk;
561	0	top = lrc->roots[m];
562
563		/* Be paranoid about calls on an empty scope. */
564	0	mark = lrs->scopeMark;
565	0	JS_ASSERT(mark < n);
566	0	if (mark >= n)
567	0	return;
568
569		/* If v was not the last root pushed in the top scope, find it. */
570	0	if (top != v) {
571		/* Search downward in case v was recently pushed. */
572	0	i = n;
573	0	j = m;
574	0	lrc2 = lrc;
575	0	while (--i > mark) {
576	0	if (j == 0)
577	0	lrc2 = lrc2->down;
578	0	j = i & JSLRS_CHUNK_MASK;
579	0	if (lrc2->roots[j] == v)
580	0	break;
581		}
582
583		/* If we didn't find v in this scope, assert and bail out. */
584	0	JS_ASSERT(i != mark);
585	0	if (i == mark)
586	0	return;
587
588		/* Swap top and v so common tail code can pop v. */
589	0	lrc2->roots[j] = top;
590		}
591
592		/* Pop the last value from the stack. */
593	0	lrc->roots[m] = JSVAL_NULL;
594	0	lrs->rootCount = n;
595	0	if (m == 0) {
596	0	JS_ASSERT(n != 0);
597	0	JS_ASSERT(lrc != &lrs->firstChunk);
598	0	lrs->topChunk = lrc->down;
599	0	JS_free(cx, lrc);
600		}
601		}
602
603		int
604		js_PushLocalRoot(JSContext *cx, JSLocalRootStack *lrs, jsval v)
605	1152	{
606	1152	unsigned n, m;
607	1152	JSLocalRootChunk *lrc;
608
609	1152	n = lrs->rootCount;
610	1152	m = n & JSLRS_CHUNK_MASK;
611	1152	if (n == 0 || m != 0) {
612		/*
613		* At start of first chunk, or not at start of a non-first top chunk.
614		* Check for lrs->rootCount overflow.
615		*/
616	1152	if ((uint32)(n + 1) == 0) {
617	0	JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
618		JSMSG_TOO_MANY_LOCAL_ROOTS);
619	0	return -1;
620		}
621	1152	lrc = lrs->topChunk;
622	1152	JS_ASSERT(n != 0 || lrc == &lrs->firstChunk);
623		} else {
624		/*
625		* After lrs->firstChunk, trying to index at a power-of-two chunk
626		* boundary: need a new chunk.
627		*/
628	0	lrc = (JSLocalRootChunk *) JS_malloc(cx, sizeof *lrc);
629	0	if (!lrc)
630	0	return -1;
631	0	lrc->down = lrs->topChunk;
632	0	lrs->topChunk = lrc;
633		}
634	1152	lrs->rootCount = n + 1;
635	1152	lrc->roots[m] = v;
636	1152	return (int) n;
637		}
638
639		void
640		js_MarkLocalRoots(JSContext *cx, JSLocalRootStack *lrs)
641	0	{
642	0	unsigned n, m, mark;
643	0	JSLocalRootChunk *lrc;
644
645	0	n = lrs->rootCount;
646	0	if (n == 0)
647	0	return;
648
649	0	mark = lrs->scopeMark;
650	0	lrc = lrs->topChunk;
651	0	do {
652	0	while (--n > mark) {
653		#ifdef GC_MARK_DEBUG
654		char name[22];
655		JS_snprintf(name, sizeof name, "<local root %u>", n);
656		#else
657	0	const char *name = NULL;
658		#endif
659	0	m = n & JSLRS_CHUNK_MASK;
660	0	JS_ASSERT(JSVAL_IS_GCTHING(lrc->roots[m]));
661	0	JS_MarkGCThing(cx, JSVAL_TO_GCTHING(lrc->roots[m]), name, NULL);
662	0	if (m == 0)
663	0	lrc = lrc->down;
664		}
665	0	m = n & JSLRS_CHUNK_MASK;
666	0	mark = JSVAL_TO_INT(lrc->roots[m]);
667	0	if (m == 0)
668	0	lrc = lrc->down;
669	0	} while (n != 0);
670	0	JS_ASSERT(!lrc);
671		}
672
673		static void
674		ReportError(JSContext *cx, const char *message, JSErrorReport *reportp)
675	0	{
676		/*
677		* Check the error report, and set a JavaScript-catchable exception
678		* if the error is defined to have an associated exception.  If an
679		* exception is thrown, then the JSREPORT_EXCEPTION flag will be set
680		* on the error report, and exception-aware hosts should ignore it.
681		*/
682	0	if (reportp && reportp->errorNumber == JSMSG_UNCAUGHT_EXCEPTION)
683	0	reportp->flags |= JSREPORT_EXCEPTION;
684
685		#if JS_HAS_ERROR_EXCEPTIONS
686		/*
687		* Call the error reporter only if an exception wasn't raised.
688		*
689		* If an exception was raised, then we call the debugErrorHook
690		* (if present) to give it a chance to see the error before it
691		* propagates out of scope.  This is needed for compatability
692		* with the old scheme.
693		*/
694	0	if (!js_ErrorToException(cx, message, reportp)) {
695	0	js_ReportErrorAgain(cx, message, reportp);
696	0	} else if (cx->runtime->debugErrorHook && cx->errorReporter) {
697	0	JSDebugErrorHook hook = cx->runtime->debugErrorHook;
698		/* test local in case debugErrorHook changed on another thread */
699	0	if (hook)
700	0	hook(cx, message, reportp, cx->runtime->debugErrorHookData);
701		}
702		#else
703		js_ReportErrorAgain(cx, message, reportp);
704		#endif
705		}
706
707		/*
708		* We don't post an exception in this case, since doing so runs into
709		* complications of pre-allocating an exception object which required
710		* running the Exception class initializer early etc.
711		* Instead we just invoke the errorReporter with an "Out Of Memory"
712		* type message, and then hope the process ends swiftly.
713		*/
714		void
715		js_ReportOutOfMemory(JSContext *cx, JSErrorCallback callback)
716	0	{
717	0	JSStackFrame *fp;
718	0	JSErrorReport report;
719	0	JSErrorReporter onError = cx->errorReporter;
720
721		/* Get the message for this error, but we won't expand any arguments. */
722	0	const JSErrorFormatString *efs = callback(NULL, NULL, JSMSG_OUT_OF_MEMORY);
723	0	const char *msg = efs ? efs->format : "Out of memory";
724
725		/* Fill out the report, but don't do anything that requires allocation. */
726	0	memset(&report, 0, sizeof (struct JSErrorReport));
727	0	report.flags = JSREPORT_ERROR;
728	0	report.errorNumber = JSMSG_OUT_OF_MEMORY;
729
730		/*
731		* Walk stack until we find a frame that is associated with some script
732		* rather than a native frame.
733		*/
734	0	for (fp = cx->fp; fp; fp = fp->down) {
735	0	if (fp->script && fp->pc) {
736	0	report.filename = fp->script->filename;
737	0	report.lineno = js_PCToLineNumber(cx, fp->script, fp->pc);
738	0	break;
739		}
740		}
741
742		/*
743		* If debugErrorHook is present then we give it a chance to veto
744		* sending the error on to the regular ErrorReporter.
745		*/
746	0	if (onError) {
747	0	JSDebugErrorHook hook = cx->runtime->debugErrorHook;
748	0	if (hook &&
749		!hook(cx, msg, &report, cx->runtime->debugErrorHookData)) {
750	0	onError = NULL;
751		}
752		}
753
754	0	if (onError)
755	0	onError(cx, msg, &report);
756		}
757
758		JSBool
759		js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap)
760	0	{
761	0	char *last;
762	0	JSStackFrame *fp;
763	0	JSErrorReport report;
764	0	JSBool warning;
765
766	0	if ((flags & JSREPORT_STRICT) && !JS_HAS_STRICT_OPTION(cx))
767	0	return JS_TRUE;
768
769	0	last = JS_vsmprintf(format, ap);
770	0	if (!last)
771	0	return JS_FALSE;
772
773	0	memset(&report, 0, sizeof (struct JSErrorReport));
774	0	report.flags = flags;
775
776		/* Find the top-most active script frame, for best line number blame. */
777	0	for (fp = cx->fp; fp; fp = fp->down) {
778	0	if (fp->script && fp->pc) {
779	0	report.filename = fp->script->filename;
780	0	report.lineno = js_PCToLineNumber(cx, fp->script, fp->pc);
781	0	break;
782		}
783		}
784
785	0	warning = JSREPORT_IS_WARNING(report.flags);
786	0	if (warning && JS_HAS_WERROR_OPTION(cx)) {
787	0	report.flags &= ~JSREPORT_WARNING;
788	0	warning = JS_FALSE;
789		}
790
791	0	ReportError(cx, last, &report);
792	0	free(last);
793	0	return warning;
794		}
795
796		/*
797		* The arguments from ap need to be packaged up into an array and stored
798		* into the report struct.
799		*
800		* The format string addressed by the error number may contain operands
801		* identified by the format {N}, where N is a decimal digit. Each of these
802		* is to be replaced by the Nth argument from the va_list. The complete
803		* message is placed into reportp->ucmessage converted to a JSString.
804		*
805		* Returns true if the expansion succeeds (can fail if out of memory).
806		*/
807		JSBool
808		js_ExpandErrorArguments(JSContext *cx, JSErrorCallback callback,
809		void *userRef, const uintN errorNumber,
810		char **messagep, JSErrorReport *reportp,
811		JSBool *warningp, JSBool charArgs, va_list ap)
812	0	{
813	0	const JSErrorFormatString *efs;
814	0	int i;
815	0	int argCount;
816
817	0	*warningp = JSREPORT_IS_WARNING(reportp->flags);
818	0	if (*warningp && JS_HAS_WERROR_OPTION(cx)) {
819	0	reportp->flags &= ~JSREPORT_WARNING;
820	0	*warningp = JS_FALSE;
821		}
822
823	0	*messagep = NULL;
824	0	if (callback) {
825	0	efs = callback(userRef, NULL, errorNumber);
826	0	if (efs) {
827	0	size_t totalArgsLength = 0;
828	0	size_t argLengths[10]; /* only {0} thru {9} supported */
829	0	argCount = efs->argCount;
830	0	JS_ASSERT(argCount <= 10);
831	0	if (argCount > 0) {
832		/*
833		* Gather the arguments into an array, and accumulate
834		* their sizes. We allocate 1 more than necessary and
835		* null it out to act as the caboose when we free the
836		* pointers later.
837		*/
838	0	reportp->messageArgs = (const jschar **)
839		JS_malloc(cx, sizeof(jschar *) * (argCount + 1));
840	0	if (!reportp->messageArgs)
841	0	return JS_FALSE;
842	0	reportp->messageArgs[argCount] = NULL;
843	0	for (i = 0; i < argCount; i++) {
844	0	if (charArgs) {
845	0	char *charArg = va_arg(ap, char *);
846	0	size_t charArgLength = strlen(charArg);
847	0	reportp->messageArgs[i]
848		= js_InflateString(cx, charArg, &charArgLength);
849	0	if (!reportp->messageArgs[i])
850	0	goto error;
851		}
852		else
853	0	reportp->messageArgs[i] = va_arg(ap, jschar *);
854	0	argLengths[i] = js_strlen(reportp->messageArgs[i]);
855	0	totalArgsLength += argLengths[i];
856		}
857		/* NULL-terminate for easy copying. */
858	0	reportp->messageArgs[i] = NULL;
859		}
860		/*
861		* Parse the error format, substituting the argument X
862		* for {X} in the format.
863		*/
864	0	if (argCount > 0) {
865	0	if (efs->format) {
866	0	jschar *buffer, *fmt, *out;
867	0	const jschar *arg;
868	0	int expandedArgs = 0;
869	0	size_t expandedLength;
870	0	size_t len = strlen (efs->format);
871	0	buffer = fmt = js_InflateString (cx, efs->format, &len);
872	0	if (!buffer)
873	0	goto error;
874	0	expandedLength
875		= len
876		- (3 * argCount) /* exclude the {n} */
877		+ totalArgsLength;
878		/*
879		* Note - the above calculation assumes that each argument
880		* is used once and only once in the expansion !!!
881		*/
882	0	reportp->ucmessage = out = (jschar *)
883		JS_malloc(cx, (expandedLength + 1) * sizeof(jschar));
884	0	if (!out) {
885	0	JS_free (cx, buffer);
886	0	goto error;
887		}
888	0	while (*fmt) {
889	0	if (*fmt == '{') {
890	0	if (isdigit(fmt[1])) {
891	0	int d = JS7_UNDEC(fmt[1]);
892	0	JS_ASSERT(d < argCount);
893	0	arg = reportp->messageArgs[d];
894	0	js_strncpy(out, arg, argLengths[d]);
895	0	out += argLengths[d];
896	0	fmt += 3;
897	0	expandedArgs++;
898	0	continue;
899		}
900		}
901	0	*out++ = *fmt++;
902		}
903	0	JS_ASSERT(expandedArgs == argCount);
904	0	*out = 0;
905	0	JS_free (cx, buffer);
906	0	*messagep =
907		js_DeflateString(cx, reportp->ucmessage,
908		(size_t)(out - reportp->ucmessage));
909	0	if (!*messagep)
910	0	goto error;
911		}
912		} else {
913		/*
914		* Zero arguments: the format string (if it exists) is the
915		* entire message.
916		*/
917	0	if (efs->format) {
918	0	size_t len;
919	0	*messagep = JS_strdup(cx, efs->format);
920	0	if (!*messagep)
921	0	goto error;
922	0	len = strlen(*messagep);
923	0	reportp->ucmessage
924		= js_InflateString(cx, *messagep, &len);
925	0	if (!reportp->ucmessage)
926	0	goto error;
927		}
928		}
929		}
930		}
931	0	if (*messagep == NULL) {
932		/* where's the right place for this ??? */
933		const char *defaultErrorMessage
934	0	= "No error message available for error number %d";
935	0	size_t nbytes = strlen(defaultErrorMessage) + 16;
936	0	*messagep = (char *)JS_malloc(cx, nbytes);
937	0	if (!*messagep)
938	0	goto error;
939	0	JS_snprintf(*messagep, nbytes, defaultErrorMessage, errorNumber);
940		}
941	0	return JS_TRUE;
942
943		error:
944	0	if (reportp->messageArgs) {
945	0	i = 0;
946	0	while (reportp->messageArgs[i])
947	0	JS_free(cx, (void *)reportp->messageArgs[i++]);
948	0	JS_free(cx, (void *)reportp->messageArgs);
949	0	reportp->messageArgs = NULL;
950		}
951	0	if (reportp->ucmessage) {
952	0	JS_free(cx, (void *)reportp->ucmessage);
953	0	reportp->ucmessage = NULL;
954		}
955	0	if (*messagep) {
956	0	JS_free(cx, (void *)*messagep);
957	0	*messagep = NULL;
958		}
959	0	return JS_FALSE;
960		}
961
962		JSBool
963		js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback,
964		void *userRef, const uintN errorNumber,
965		JSBool charArgs, va_list ap)
966	0	{
967	0	JSStackFrame *fp;
968	0	JSErrorReport report;
969	0	char *message;
970	0	JSBool warning;
971
972	0	if ((flags & JSREPORT_STRICT) && !JS_HAS_STRICT_OPTION(cx))
973	0	return JS_TRUE;
974
975	0	memset(&report, 0, sizeof (struct JSErrorReport));
976	0	report.flags = flags;
977	0	report.errorNumber = errorNumber;
978
979		/*
980		* If we can't find out where the error was based on the current frame,
981		* see if the next frame has a script/pc combo we can use.
982		*/
983	0	for (fp = cx->fp; fp; fp = fp->down) {
984	0	if (fp->script && fp->pc) {
985	0	report.filename = fp->script->filename;
986	0	report.lineno = js_PCToLineNumber(cx, fp->script, fp->pc);
987	0	break;
988		}
989		}
990
991	0	if (!js_ExpandErrorArguments(cx, callback, userRef, errorNumber,
992		&message, &report, &warning, charArgs, ap)) {
993	0	return JS_FALSE;
994		}
995
996	0	ReportError(cx, message, &report);
997
998	0	if (message)
999	0	JS_free(cx, message);
1000	0	if (report.messageArgs) {
1001	0	int i = 0;
1002	0	while (report.messageArgs[i])
1003	0	JS_free(cx, (void *)report.messageArgs[i++]);
1004	0	JS_free(cx, (void *)report.messageArgs);
1005		}
1006	0	if (report.ucmessage)
1007	0	JS_free(cx, (void *)report.ucmessage);
1008
1009	0	return warning;
1010		}
1011
1012		JS_FRIEND_API(void)
1013		js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *reportp)
1014	0	{
1015	0	JSErrorReporter onError;
1016
1017	0	if (!message)
1018	0	return;
1019
1020	0	if (cx->lastMessage)
1021	0	free(cx->lastMessage);
1022	0	cx->lastMessage = JS_strdup(cx, message);
1023	0	if (!cx->lastMessage)
1024	0	return;
1025	0	onError = cx->errorReporter;
1026
1027		/*
1028		* If debugErrorHook is present then we give it a chance to veto
1029		* sending the error on to the regular ErrorReporter.
1030		*/
1031	0	if (onError) {
1032	0	JSDebugErrorHook hook = cx->runtime->debugErrorHook;
1033	0	if (hook &&
1034		!hook(cx, cx->lastMessage, reportp,
1035		cx->runtime->debugErrorHookData)) {
1036	0	onError = NULL;
1037		}
1038		}
1039	0	if (onError)
1040	0	onError(cx, cx->lastMessage, reportp);
1041		}
1042
1043		void
1044		js_ReportIsNotDefined(JSContext *cx, const char *name)
1045	0	{
1046	0	JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NOT_DEFINED, name);
1047		}
1048
1049		#if defined DEBUG && defined XP_UNIX
1050		/* For gdb usage. */
1051		void js_traceon(JSContext *cx)  { cx->tracefp = stderr; }
1052		void js_traceoff(JSContext *cx) { cx->tracefp = NULL; }
1053		#endif
1054
1055		JSErrorFormatString js_ErrorFormatString[JSErr_Limit] = {
1056		#if JS_HAS_DFLT_MSG_STRINGS
1057		#define MSG_DEF(name, number, count, exception, format) \
1058		{ format, count } ,
1059		#else
1060		#define MSG_DEF(name, number, count, exception, format) \
1061		{ NULL, count } ,
1062		#endif
1063		#include "js.msg"
1064		#undef MSG_DEF
1065		};
1066
1067		const JSErrorFormatString *
1068		js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber)
1069	0	{
1070	0	if ((errorNumber > 0) && (errorNumber < JSErr_Limit))
1071	0	return &js_ErrorFormatString[errorNumber];
1072	0	return NULL;