author | Jeff Walden <jwalden@mit.edu> |
Mon, 10 Oct 2011 23:00:28 -0700 (2011-10-11) | |
changeset 78818 | 88b9a330ff8c6bdbea2adf379abeaa8cb2c08183 |
parent 78817 | b9b9d9f379dbef46572c5fab7ea0682988a34374 |
child 78819 | 6ef8c395b2df1f584c9fe77c26a2856118c6d5fc |
push id | 2697 |
push user | jwalden@mit.edu |
push date | Sun, 16 Oct 2011 01:24:47 +0000 (2011-10-16) |
treeherder | mozilla-inbound@6ef8c395b2df [default view] [failures only] |
perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
reviewers | cjones |
bugs | 693469 |
milestone | 10.0a1 |
first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
--- a/js/src/jsapi-tests/testIndexToString.cpp +++ b/js/src/jsapi-tests/testIndexToString.cpp @@ -6,16 +6,18 @@ #include "jscntxt.h" #include "jscompartment.h" #include "jsnum.h" #include "jsstr.h" #include "vm/String-inl.h" +using namespace mozilla; + template<size_t N> JSFlatString * NewString(JSContext *cx, const jschar (&chars)[N]) { return js_NewStringCopyN(cx, chars, N); } static const struct TestPair { uint32 num; @@ -46,17 +48,17 @@ static const struct TestPair { { 2147483648u, "2147483648" }, { 2147483649u, "2147483649" }, { 4294967294u, "4294967294" }, { 4294967295u, "4294967295" }, }; BEGIN_TEST(testIndexToString) { - for (size_t i = 0, sz = JS_ARRAY_LENGTH(tests); i < sz; i++) { + for (size_t i = 0, sz = ArrayLength(tests); i < sz; i++) { uint32 u = tests[i].num; JSString *str = js::IndexToString(cx, u); CHECK(str); if (!js::StaticStrings::hasUint(u)) CHECK(cx->compartment->dtoaCache.lookup(10, u) == str); JSBool match = JS_FALSE; @@ -65,17 +67,17 @@ BEGIN_TEST(testIndexToString) } return true; } END_TEST(testIndexToString) BEGIN_TEST(testStringIsIndex) { - for (size_t i = 0, sz = JS_ARRAY_LENGTH(tests); i < sz; i++) { + for (size_t i = 0, sz = ArrayLength(tests); i < sz; i++) { uint32 u = tests[i].num; JSFlatString *str = js::IndexToString(cx, u); CHECK(str); uint32 n; CHECK(str->isIndex(&n)); CHECK(u == n); }
--- a/js/src/jsapi-tests/testIntern.cpp +++ b/js/src/jsapi-tests/testIntern.cpp @@ -1,16 +1,18 @@ #include "tests.h" #include "jsatom.h" +using namespace mozilla; + BEGIN_TEST(testAtomizedIsNotInterned) { /* Try to pick a string that won't be interned by other tests in this runtime. */ static const char someChars[] = "blah blah blah? blah blah blah"; - JSAtom *atom = js_Atomize(cx, someChars, JS_ARRAY_LENGTH(someChars)); + JSAtom *atom = js_Atomize(cx, someChars, ArrayLength(someChars)); CHECK(!JS_StringHasBeenInterned(cx, atom)); CHECK(JS_InternJSString(cx, atom)); CHECK(JS_StringHasBeenInterned(cx, atom)); return true; } END_TEST(testAtomizedIsNotInterned) struct StringWrapper
--- a/js/src/jsapi-tests/tests.h +++ b/js/src/jsapi-tests/tests.h @@ -33,16 +33,18 @@ * 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 ***** */ +#include "mozilla/Util.h" + #include "jsapi.h" #include "jsprvtd.h" #include "jsalloc.h" #include "js/Vector.h" #include <errno.h> #include <string.h>
--- a/js/src/jsarray.cpp +++ b/js/src/jsarray.cpp @@ -239,39 +239,39 @@ StringIsArrayIndex(JSLinearString *str, static JSBool BigIndexToId(JSContext *cx, JSObject *obj, jsuint index, JSBool createAtom, jsid *idp) { JS_STATIC_ASSERT((jsuint)-1 == 4294967295U); JS_ASSERT(index > JSID_INT_MAX); jschar buf[10]; - jschar *start = JS_ARRAY_END(buf); + jschar *start = ArrayEnd(buf); do { --start; *start = (jschar)('0' + index % 10); index /= 10; } while (index != 0); /* * Skip the atomization if the class is known to store atoms corresponding * to big indexes together with elements. In such case we know that the * array does not have an element at the given index if its atom does not * exist. Dense arrays don't use atoms for any indexes, though it would be * rare to see them have a big index in any case. */ JSAtom *atom; if (!createAtom && (obj->isSlowArray() || obj->isArguments() || obj->isObject())) { - atom = js_GetExistingStringAtom(cx, start, JS_ARRAY_END(buf) - start); + atom = js_GetExistingStringAtom(cx, start, ArrayEnd(buf) - start); if (!atom) { *idp = JSID_VOID; return JS_TRUE; } } else { - atom = js_AtomizeChars(cx, start, JS_ARRAY_END(buf) - start); + atom = js_AtomizeChars(cx, start, ArrayEnd(buf) - start); if (!atom) return JS_FALSE; } *idp = ATOM_TO_JSID(atom); return JS_TRUE; }
--- a/js/src/jsatom.cpp +++ b/js/src/jsatom.cpp @@ -39,16 +39,17 @@ /* * JS atom table. */ #include <stdlib.h> #include <string.h> #include "mozilla/RangedPtr.h" +#include "mozilla/Util.h" #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jshash.h" #include "jsprf.h" #include "jsapi.h" #include "jsatom.h" @@ -63,16 +64,17 @@ #include "jsxml.h" #include "jsstrinlines.h" #include "jsatominlines.h" #include "jsobjinlines.h" #include "vm/String-inl.h" +using namespace mozilla; using namespace js; using namespace js::gc; const size_t JSAtomState::commonAtomsOffset = offsetof(JSAtomState, emptyAtom); const size_t JSAtomState::lazyAtomsOffset = offsetof(JSAtomState, lazy); /* * ATOM_HASH assumes that JSHashNumber is 32-bit even on 64-bit systems. @@ -358,17 +360,17 @@ js_FinishAtomState(JSRuntime *rt) #endif } bool js_InitCommonAtoms(JSContext *cx) { JSAtomState *state = &cx->runtime->atomState; JSAtom **atoms = state->commonAtomsStart(); - for (size_t i = 0; i < JS_ARRAY_LENGTH(js_common_atom_names); i++, atoms++) { + for (size_t i = 0; i < ArrayLength(js_common_atom_names); i++, atoms++) { JSAtom *atom = js_Atomize(cx, js_common_atom_names[i], strlen(js_common_atom_names[i]), InternAtom); if (!atom) return false; *atoms = atom->asPropertyName(); } state->clearLazyAtoms(); @@ -672,17 +674,17 @@ js_InitAtomMap(JSContext *cx, AtomIndexM namespace js { bool IndexToIdSlow(JSContext *cx, uint32 index, jsid *idp) { JS_ASSERT(index > JSID_INT_MAX); jschar buf[UINT32_CHAR_BUFFER_LENGTH]; - RangedPtr<jschar> end(buf + JS_ARRAY_LENGTH(buf), buf, buf + JS_ARRAY_LENGTH(buf)); + RangedPtr<jschar> end(ArrayEnd(buf), buf, ArrayEnd(buf)); RangedPtr<jschar> start = BackfillIndexInCharBuffer(index, end); JSAtom *atom = js_AtomizeChars(cx, start.get(), end - start); if (!atom) return false; *idp = ATOM_TO_JSID(atom); JS_ASSERT(js_CheckForStringIndex(*idp) == *idp);
--- a/js/src/jscompartment.cpp +++ b/js/src/jscompartment.cpp @@ -59,16 +59,17 @@ #include "jsgcinlines.h" #include "jsscopeinlines.h" #if ENABLE_YARR_JIT #include "assembler/jit/ExecutableAllocator.h" #endif +using namespace mozilla; using namespace js; using namespace js::gc; JSCompartment::JSCompartment(JSRuntime *rt) : rt(rt), principals(NULL), gcBytes(0), gcTriggerBytes(0), @@ -117,17 +118,17 @@ JSCompartment::~JSCompartment() #ifdef JS_TRACER Foreground::delete_(traceMonitor_); #endif Foreground::delete_(mathCache); Foreground::delete_(watchpointMap); #ifdef DEBUG - for (size_t i = 0; i != JS_ARRAY_LENGTH(evalCache); ++i) + for (size_t i = 0; i < ArrayLength(evalCache); ++i) JS_ASSERT(!evalCache[i]); #endif } bool JSCompartment::init(JSContext *cx) { activeAnalysis = activeInference = false; @@ -657,17 +658,17 @@ JSCompartment::purge(JSContext *cx) dtoaCache.purge(); /* * Clear the hash and reset all evalHashLink to null before the GC. This * way MarkChildren(trc, JSScript *) can assume that JSScript::u.object is * not null when we have script owned by an object and not from the eval * cache. */ - for (size_t i = 0; i != JS_ARRAY_LENGTH(evalCache); ++i) { + for (size_t i = 0; i < ArrayLength(evalCache); ++i) { for (JSScript **listHeadp = &evalCache[i]; *listHeadp; ) { JSScript *script = *listHeadp; JS_ASSERT(GetGCThingTraceKind(script) == JSTRACE_SCRIPT); *listHeadp = NULL; listHeadp = &script->u.evalHashLink; } }
--- a/js/src/jsdate.cpp +++ b/js/src/jsdate.cpp @@ -51,16 +51,19 @@ * Frederick Brooks, 'The Second-System Effect'. */ #include <ctype.h> #include <locale.h> #include <math.h> #include <stdlib.h> #include <string.h> + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsprf.h" #include "prmjtime.h" #include "jsutil.h" #include "jsapi.h" #include "jsversion.h" #include "jsbuiltins.h" @@ -74,16 +77,17 @@ #include "vm/GlobalObject.h" #include "jsinferinlines.h" #include "jsobjinlines.h" #include "vm/Stack-inl.h" +using namespace mozilla; using namespace js; using namespace js::types; /* * The JS 'Date' object is patterned after the Java 'Date' object. * Here is an script: * * today = new Date(); @@ -1033,17 +1037,17 @@ date_parseString(JSLinearString *str, js while (i < limit) { c = s[i]; if (!(('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z'))) break; i++; } if (i <= st + 1) goto syntax; - for (k = JS_ARRAY_LENGTH(wtb); --k >= 0;) + for (k = ArrayLength(wtb); --k >= 0;) if (date_regionMatches(wtb[k], 0, s, st, i-st, 1)) { int action = ttb[k]; if (action != 0) { if (action < 0) { /* * AM/PM. Count 12:30 AM as 00:30, 12:30 PM as * 12:30, instead of blindly adding 12 if PM. */
--- a/js/src/jsemit.cpp +++ b/js/src/jsemit.cpp @@ -41,16 +41,17 @@ /* * JS bytecode generation. */ #ifdef HAVE_MEMORY_H #include <memory.h> #endif #include <new> #include <string.h> + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jsprf.h" #include "jsapi.h" #include "jsatom.h" #include "jsbool.h" #include "jscntxt.h"
--- a/js/src/jsexn.cpp +++ b/js/src/jsexn.cpp @@ -38,16 +38,19 @@ * * ***** END LICENSE BLOCK ***** */ /* * JS standard exception implementation. */ #include <stdlib.h> #include <string.h> + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jsprf.h" #include "jsapi.h" #include "jscntxt.h" #include "jsversion.h" #include "jsexn.h" @@ -64,16 +67,17 @@ #include "vm/GlobalObject.h" #include "jsinferinlines.h" #include "jsobjinlines.h" #include "vm/Stack-inl.h" +using namespace mozilla; using namespace js; using namespace js::gc; using namespace js::types; /* Forward declarations for ErrorClass's initializer. */ static JSBool Exception(JSContext *cx, uintN argc, Value *vp); @@ -854,17 +858,17 @@ exn_toSource(JSContext *cx, uintN argc, if (!obj->getProperty(cx, cx->runtime->atomState.nameAtom, vp)) return false; name = js_ValueToString(cx, *vp); if (!name) return false; vp->setString(name); { - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(localroots), localroots); + AutoArrayRooter tvr(cx, ArrayLength(localroots), localroots); #ifdef __GNUC__ message = filename = NULL; #endif if (!JS_GetProperty(cx, obj, js_message_str, &localroots[0]) || !(message = js_ValueToSource(cx, localroots[0]))) { return false; } @@ -1149,17 +1153,17 @@ js_ErrorToException(JSContext *cx, const if (cx->generatingError) return JS_FALSE; MUST_FLOW_THROUGH("out"); cx->generatingError = JS_TRUE; /* Protect the newly-created strings below from nesting GCs. */ PodArrayZero(tv); - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(tv), tv); + AutoArrayRooter tvr(cx, ArrayLength(tv), tv); /* * Try to get an appropriate prototype by looking up the corresponding * exception constructor name in the scope chain of the current context's * top stack frame, or in the global object if no frame is active. */ ok = js_GetClassPrototype(cx, NULL, GetExceptionProtoKey(exn), &errProto); if (!ok) @@ -1214,17 +1218,17 @@ js_ReportUncaughtException(JSContext *cx if (!JS_IsExceptionPending(cx)) return true; if (!JS_GetPendingException(cx, &exn)) return false; PodArrayZero(roots); - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(roots), roots); + AutoArrayRooter tvr(cx, ArrayLength(roots), roots); /* * Because js_ValueToString below could error and an exception object * could become unrooted, we must root exnObject. Later, if exnObject is * non-null, we need to root other intermediates, so allocate an operand * stack segment to protect all of these values. */ if (JSVAL_IS_PRIMITIVE(exn)) {
--- a/js/src/jsfun.cpp +++ b/js/src/jsfun.cpp @@ -37,16 +37,19 @@ * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* * JS function support. */ #include <string.h> + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jsapi.h" #include "jsarray.h" #include "jsatom.h" #include "jsbool.h" #include "jsbuiltins.h" @@ -89,16 +92,17 @@ #include "jsfuninlines.h" #include "jsinferinlines.h" #include "jsobjinlines.h" #include "jsscriptinlines.h" #include "vm/CallObject-inl.h" #include "vm/ArgumentsObject-inl.h" #include "vm/Stack-inl.h" +using namespace mozilla; using namespace js; using namespace js::gc; using namespace js::types; inline JSObject * JSObject::getThrowTypeError() const { return getGlobal()->getThrowTypeError(); @@ -1367,17 +1371,17 @@ fun_getProperty(JSContext *cx, JSObject } JS_NOT_REACHED("fun_getProperty"); return false; } -/* NB: no sentinels at ends -- use JS_ARRAY_LENGTH to bound loops. +/* NB: no sentinels at ends -- use ArrayLength to bound loops. * Properties censored into [[ThrowTypeError]] in strict mode. */ static const uint16 poisonPillProps[] = { ATOM_OFFSET(arguments), ATOM_OFFSET(caller), }; static JSBool fun_enumerate(JSContext *cx, JSObject *obj) @@ -1396,17 +1400,17 @@ fun_enumerate(JSContext *cx, JSObject *o id = ATOM_TO_JSID(cx->runtime->atomState.lengthAtom); if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED)) return false; id = ATOM_TO_JSID(cx->runtime->atomState.nameAtom); if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED)) return false; - for (uintN i = 0; i < JS_ARRAY_LENGTH(poisonPillProps); i++) { + for (uintN i = 0; i < ArrayLength(poisonPillProps); i++) { const uint16 offset = poisonPillProps[i]; id = ATOM_TO_JSID(OFFSET_TO_ATOM(cx->runtime, offset)); if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED)) return false; } return true; } @@ -1502,17 +1506,17 @@ fun_resolve(JSContext *cx, JSObject *obj if (!DefineNativeProperty(cx, obj, id, v, JS_PropertyStub, JS_StrictPropertyStub, JSPROP_PERMANENT | JSPROP_READONLY, 0, 0)) { return false; } *objp = obj; return true; } - for (uintN i = 0; i < JS_ARRAY_LENGTH(poisonPillProps); i++) { + for (uintN i = 0; i < ArrayLength(poisonPillProps); i++) { const uint16 offset = poisonPillProps[i]; if (JSID_IS_ATOM(id, OFFSET_TO_ATOM(cx->runtime, offset))) { JS_ASSERT(!IsInternalFunctionObject(obj)); PropertyOp getter; StrictPropertyOp setter; uintN attrs = JSPROP_PERMANENT;
--- a/js/src/jsgc.cpp +++ b/js/src/jsgc.cpp @@ -45,16 +45,19 @@ * jsgc.h). It allocates from a special GC arena pool with each arena allocated * using malloc. It uses an ideally parallel array of flag bytes to hold the * mark bit, finalizer type index, etc. * * XXX swizzle page to freelist for better locality of reference */ #include <math.h> #include <string.h> /* for memset used when DEBUG */ + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jshash.h" #include "jsclist.h" #include "jsprf.h" #include "jsapi.h" #include "jsatom.h" @@ -96,16 +99,17 @@ #ifdef MOZ_VALGRIND # define JS_VALGRIND #endif #ifdef JS_VALGRIND # include <valgrind/memcheck.h> #endif +using namespace mozilla; using namespace js; using namespace js::gc; namespace js { namespace gc { /* This array should be const, but that doesn't link right under GCC. */ AllocKind slotsToThingKind[] = { @@ -542,17 +546,17 @@ Chunk::release(JSRuntime *rt, Chunk *chu void Chunk::init() { JS_POISON(this, JS_FREE_PATTERN, GC_CHUNK_SIZE); /* Assemble all arenas into a linked list and mark them as not allocated. */ ArenaHeader **prevp = &info.emptyArenaListHead; - Arena *end = &arenas[JS_ARRAY_LENGTH(arenas)]; + Arena *end = &arenas[ArrayLength(arenas)]; for (Arena *a = &arenas[0]; a != end; ++a) { *prevp = &a->aheader; a->aheader.setAsNotAllocated(); prevp = &a->aheader.next; } *prevp = NULL; /* We clear the bitmap to guard against xpc_IsGrayGCThing being called on @@ -934,17 +938,17 @@ MarkThreadDataConservatively(JSTracer *t stackEnd = ctd->nativeStackTop; #else stackMin = ctd->nativeStackTop + 1; stackEnd = td->nativeStackBase; #endif JS_ASSERT(stackMin <= stackEnd); MarkRangeConservatively(trc, stackMin, stackEnd); MarkRangeConservatively(trc, ctd->registerSnapshot.words, - JS_ARRAY_END(ctd->registerSnapshot.words)); + ArrayEnd(ctd->registerSnapshot.words)); } void MarkStackRangeConservatively(JSTracer *trc, Value *beginv, Value *endv) { /* * Normally, the drainMarkStack phase of marking will never trace outside * of the compartment currently being collected. However, conservative
--- a/js/src/jsgc.h +++ b/js/src/jsgc.h @@ -40,16 +40,18 @@ #ifndef jsgc_h___ #define jsgc_h___ /* * JS Garbage Collector. */ #include <setjmp.h> +#include "mozilla/Util.h" + #include "jsalloc.h" #include "jstypes.h" #include "jsprvtd.h" #include "jspubtd.h" #include "jsdhash.h" #include "jsgcchunk.h" #include "jslock.h" #include "jsutil.h" @@ -1106,17 +1108,17 @@ struct ArenaLists { JS_ALWAYS_INLINE void *allocateFromFreeList(AllocKind thingKind, size_t thingSize) { return freeLists[thingKind].allocate(thingSize); } static void *refillFreeList(JSContext *cx, AllocKind thingKind); void checkEmptyFreeLists() { #ifdef DEBUG - for (size_t i = 0; i != JS_ARRAY_LENGTH(freeLists); ++i) + for (size_t i = 0; i < mozilla::ArrayLength(freeLists); ++i) JS_ASSERT(freeLists[i].isEmpty()); #endif } void checkEmptyFreeList(AllocKind kind) { JS_ASSERT(freeLists[kind].isEmpty()); }
--- a/js/src/jsgcstats.cpp +++ b/js/src/jsgcstats.cpp @@ -31,42 +31,45 @@ * 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 ***** */ +#include "mozilla/Util.h" + #include "jstypes.h" #include "jscntxt.h" #include "jsgcstats.h" #include "jsgc.h" #include "jsxml.h" #include "jsbuiltins.h" #include "jscompartment.h" #include "jsgcinlines.h" +using namespace mozilla; using namespace js; using namespace js::gc; #define UL(x) ((unsigned long)(x)) #define PERCENT(x,y) (100.0 * (double) (x) / (double) (y)) namespace js { namespace gc { #if defined(JS_DUMP_CONSERVATIVE_GC_ROOTS) void ConservativeGCStats::dump(FILE *fp) { size_t words = 0; - for (size_t i = 0; i != JS_ARRAY_LENGTH(counter); ++i) + for (size_t i = 0; i < ArrayLength(counter); ++i) words += counter[i]; #define ULSTAT(x) ((unsigned long)(x)) fprintf(fp, "CONSERVATIVE STACK SCANNING:\n"); fprintf(fp, " number of stack words: %lu\n", ULSTAT(words)); fprintf(fp, " excluded, low bit set: %lu\n", ULSTAT(counter[CGCT_LOWBITSET])); fprintf(fp, " not withing a chunk: %lu\n", ULSTAT(counter[CGCT_NOTCHUNK])); fprintf(fp, " not within arena range: %lu\n", ULSTAT(counter[CGCT_NOTARENA]));
--- a/js/src/jsgcstats.h +++ b/js/src/jsgcstats.h @@ -34,16 +34,18 @@ * 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 ***** */ #ifndef jsgcstats_h___ #define jsgcstats_h___ +#include "mozilla/Util.h" + #if !defined JS_DUMP_CONSERVATIVE_GC_ROOTS && defined DEBUG # define JS_DUMP_CONSERVATIVE_GC_ROOTS 1 #endif namespace js { namespace gc { /* * The conservative GC test for a word shows that it is either a valid GC @@ -64,17 +66,17 @@ enum ConservativeGCTest struct ConservativeGCStats { uint32 counter[gc::CGCT_END]; /* ConservativeGCTest classification counters */ uint32 unaligned; /* number of valid but not aligned on thing start pointers */ void add(const ConservativeGCStats &another) { - for (size_t i = 0; i != JS_ARRAY_LENGTH(counter); ++i) + for (size_t i = 0; i < mozilla::ArrayLength(counter); ++i) counter[i] += another.counter[i]; } void dump(FILE *fp); }; } //gc
--- a/js/src/jsiter.cpp +++ b/js/src/jsiter.cpp @@ -37,16 +37,19 @@ * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* * JavaScript iterators. */ #include <string.h> /* for memcpy */ + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jsapi.h" #include "jsarray.h" #include "jsatom.h" #include "jsbool.h" #include "jsbuiltins.h" @@ -74,16 +77,17 @@ #include "vm/GlobalObject.h" #include "jsinferinlines.h" #include "jsobjinlines.h" #include "vm/Stack-inl.h" #include "vm/String-inl.h" +using namespace mozilla; using namespace js; using namespace js::gc; static void iterator_finalize(JSContext *cx, JSObject *obj); static void iterator_trace(JSTracer *trc, JSObject *obj); static JSObject *iterator_iterator(JSContext *cx, JSObject *obj, JSBool keysonly); Class js::IteratorClass = { @@ -155,17 +159,17 @@ struct IdHashPolicy { }; typedef HashSet<jsid, IdHashPolicy> IdSet; static inline bool NewKeyValuePair(JSContext *cx, jsid id, const Value &val, Value *rval) { Value vec[2] = { IdToValue(id), val }; - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(vec), vec); + AutoArrayRooter tvr(cx, ArrayLength(vec), vec); JSObject *aobj = NewDenseCopiedArray(cx, 2, vec); if (!aobj) return false; rval->setObject(*aobj); return true; }
--- a/js/src/jsobj.cpp +++ b/js/src/jsobj.cpp @@ -38,16 +38,19 @@ * * ***** END LICENSE BLOCK ***** */ /* * JS object implementation. */ #include <stdlib.h> #include <string.h> + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jshash.h" #include "jsdhash.h" #include "jsprf.h" #include "jsapi.h" #include "jsarray.h" @@ -102,16 +105,17 @@ #endif #include "jsatominlines.h" #include "jsobjinlines.h" #include "jsscriptinlines.h" #include "jsautooplen.h" +using namespace mozilla; using namespace js; using namespace js::gc; using namespace js::types; JS_FRIEND_DATA(js::Shape) Shape::sharedNonNative(SHAPELESS); Class js::ObjectClass = { js_Object_str, @@ -506,17 +510,17 @@ obj_toSource(JSContext *cx, uintN argc, JSString *gsop[2]; JSString *valstr, *str; JSLinearString *idstr; JS_CHECK_RECURSION(cx, return JS_FALSE); Value localroot[4]; PodArrayZero(localroot); - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(localroot), localroot); + AutoArrayRooter tvr(cx, ArrayLength(localroot), localroot); /* If outermost, we need parentheses to be an expression, not a block. */ JSBool outermost = (cx->sharpObjectMap.depth == 0); JSObject *obj = ToObject(cx, &vp[1]); if (!obj) return false; @@ -1401,17 +1405,17 @@ obj_watch_handler(JSContext *cx, JSObjec } /* Avoid recursion on (obj, id) already being watched on cx. */ AutoResolving resolving(cx, obj, id, AutoResolving::WATCH); if (resolving.alreadyStarted()) return true; Value argv[] = { IdToValue(id), old, *nvp }; - return Invoke(cx, ObjectValue(*obj), ObjectOrNullValue(callable), JS_ARRAY_LENGTH(argv), argv, nvp); + return Invoke(cx, ObjectValue(*obj), ObjectOrNullValue(callable), ArrayLength(argv), argv, nvp); } static JSBool obj_watch(JSContext *cx, uintN argc, Value *vp) { if (argc <= 1) { js_ReportMissingArg(cx, *vp, 1); return JS_FALSE;
--- a/js/src/jsopcode.cpp +++ b/js/src/jsopcode.cpp @@ -43,16 +43,19 @@ */ #ifdef HAVE_MEMORY_H #include <memory.h> #endif #include <stdarg.h> #include <stdio.h> #include <stdlib.h> #include <string.h> + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jsprf.h" #include "jsapi.h" #include "jsarray.h" #include "jsatom.h" #include "jscntxt.h" @@ -74,16 +77,17 @@ #include "jsobjinlines.h" #include "jsopcodeinlines.h" #include "jsscriptinlines.h" #include "jsautooplen.h" #include "vm/RegExpObject-inl.h" +using namespace mozilla; using namespace js; using namespace js::gc; /* * Index limit must stay within 32 bits. */ JS_STATIC_ASSERT(sizeof(uint32) * JS_BITS_PER_BYTE >= INDEX_LIMIT_LOG2 + 1); @@ -2751,17 +2755,17 @@ Decompile(SprintStack *ss, jsbytecode *p break; case JSOP_ENTERBLOCK: { JSAtom **atomv, *smallv[5]; LOAD_OBJECT(0); argc = OBJ_BLOCK_COUNT(cx, obj); - if ((size_t)argc <= JS_ARRAY_LENGTH(smallv)) { + if ((size_t)argc <= ArrayLength(smallv)) { atomv = smallv; } else { atomv = (JSAtom **) cx->malloc_(argc * sizeof(JSAtom *)); if (!atomv) return NULL; } MUST_FLOW_THROUGH("enterblock_out");
--- a/js/src/jsreflect.cpp +++ b/js/src/jsreflect.cpp @@ -37,16 +37,19 @@ * * ***** END LICENSE BLOCK ***** */ /* * JS reflection package. */ #include <stdlib.h> #include <string.h> /* for jsparse.h */ + +#include "mozilla/Util.h" + #include "jspubtd.h" #include "jsatom.h" #include "jsobj.h" #include "jsreflect.h" #include "jscntxt.h" /* for jsparse.h */ #include "jsscript.h" /* for jsparse.h */ #include "jsinterp.h" /* for jsparse.h */ #include "jsparse.h" @@ -61,16 +64,17 @@ #include "jsobj.h" #include "jsarray.h" #include "jsnum.h" #include "vm/RegExpObject.h" #include "jsscriptinlines.h" +using namespace mozilla; using namespace js; namespace js { char const *aopNames[] = { "=", /* AOP_ASSIGN */ "+=", /* AOP_PLUS */ "-=", /* AOP_MINUS */ @@ -225,87 +229,87 @@ class NodeBuilder private: bool callback(Value fun, TokenPos *pos, Value *dst) { if (saveLoc) { Value loc; if (!newNodeLoc(pos, &loc)) return false; Value argv[] = { loc }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } Value argv[] = { NullValue() }; /* no zero-length arrays allowed! */ return Invoke(cx, userv, fun, 0, argv, dst); } bool callback(Value fun, Value v1, TokenPos *pos, Value *dst) { if (saveLoc) { Value loc; if (!newNodeLoc(pos, &loc)) return false; Value argv[] = { v1, loc }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } Value argv[] = { v1 }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } bool callback(Value fun, Value v1, Value v2, TokenPos *pos, Value *dst) { if (saveLoc) { Value loc; if (!newNodeLoc(pos, &loc)) return false; Value argv[] = { v1, v2, loc }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } Value argv[] = { v1, v2 }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } bool callback(Value fun, Value v1, Value v2, Value v3, TokenPos *pos, Value *dst) { if (saveLoc) { Value loc; if (!newNodeLoc(pos, &loc)) return false; Value argv[] = { v1, v2, v3, loc }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } Value argv[] = { v1, v2, v3 }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } bool callback(Value fun, Value v1, Value v2, Value v3, Value v4, TokenPos *pos, Value *dst) { if (saveLoc) { Value loc; if (!newNodeLoc(pos, &loc)) return false; Value argv[] = { v1, v2, v3, v4, loc }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } Value argv[] = { v1, v2, v3, v4 }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } bool callback(Value fun, Value v1, Value v2, Value v3, Value v4, Value v5, TokenPos *pos, Value *dst) { if (saveLoc) { Value loc; if (!newNodeLoc(pos, &loc)) return false; Value argv[] = { v1, v2, v3, v4, v5, loc }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } Value argv[] = { v1, v2, v3, v4, v5 }; - return Invoke(cx, userv, fun, JS_ARRAY_LENGTH(argv), argv, dst); + return Invoke(cx, userv, fun, ArrayLength(argv), argv, dst); } Value opt(Value v) { JS_ASSERT_IF(v.isMagic(), v.whyMagic() == JS_SERIALIZE_NO_NODE); return v.isMagic(JS_SERIALIZE_NO_NODE) ? UndefinedValue() : v; } bool atomValue(const char *s, Value *dst) {
--- a/js/src/jstracer.cpp +++ b/js/src/jstracer.cpp @@ -34,16 +34,18 @@ * 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 ***** */ +#include "mozilla/Util.h" + #include "jsstdint.h" #include "jsprf.h" #include <math.h> // standard headers next #if defined(_MSC_VER) || defined(__MINGW32__) #include <malloc.h> #ifdef _MSC_VER #define alloca _alloca @@ -110,16 +112,18 @@ #include <sys/types.h> #include <sys/stat.h> #include <sys/mman.h> #include <fcntl.h> #include <string.h> #include <elf.h> #endif +using namespace mozilla; + #ifdef DEBUG namespace js { static const char* getExitName(ExitType type) { static const char* exitNames[] = { #define MAKE_EXIT_STRING(x) #x, @@ -13837,23 +13841,23 @@ TraceRecorder::record_JSOP_FUNAPPLY() if (aobj->asArguments()->hasOverriddenLength()) RETURN_STOP_A("can't trace arguments with overridden length"); guardArgsLengthNotAssigned(aobj_ins); length = afp->numActualArgs(); } else { RETURN_STOP_A("arguments parameter of apply is not a dense array or argments object"); } - if (length >= JS_ARRAY_LENGTH(funapply_imacro_table)) + if (length >= ArrayLength(funapply_imacro_table)) RETURN_STOP_A("too many arguments to apply"); return InjectStatus(callImacro(funapply_imacro_table[length])); } - if (argc >= JS_ARRAY_LENGTH(funcall_imacro_table)) + if (argc >= ArrayLength(funcall_imacro_table)) RETURN_STOP_A("too many arguments to call"); return InjectStatus(callImacro(funcall_imacro_table[argc])); } JS_REQUIRES_STACK AbortableRecordingStatus TraceRecorder::record_NativeCallComplete() {
--- a/js/src/jstypedarray.cpp +++ b/js/src/jstypedarray.cpp @@ -34,16 +34,18 @@ * 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 ***** */ #include <string.h> +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jshash.h" #include "jsprf.h" #include "jsapi.h" #include "jsarray.h" #include "jsatom.h" @@ -62,16 +64,17 @@ #include "vm/GlobalObject.h" #include "jsatominlines.h" #include "jsinferinlines.h" #include "jsobjinlines.h" #include "jstypedarrayinlines.h" +using namespace mozilla; using namespace js; using namespace js::gc; using namespace js::types; /* slots can only be upto 255 */ static const uint8 ARRAYBUFFER_RESERVED_SLOTS = 16; static bool @@ -2417,17 +2420,17 @@ js_CreateTypedArrayWithBuffer(JSContext argc++; } if (length >= 0) { vals[argc].setInt32(length); argc++; } - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(vals), vals); + AutoArrayRooter tvr(cx, ArrayLength(vals), vals); return TypedArrayConstruct(cx, atype, argc, &vals[0]); } JSUint32 JS_GetTypedArrayLength(JSObject *obj) { return obj->getSlot(TypedArray::FIELD_LENGTH).toInt32(); }
--- a/js/src/jsxdrapi.cpp +++ b/js/src/jsxdrapi.cpp @@ -32,16 +32,18 @@ * 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 ***** */ +#include "mozilla/Util.h" + #include "jsversion.h" #if JS_HAS_XDR #include <string.h> #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" @@ -53,16 +55,17 @@ #include "jsobj.h" /* js_XDRObject */ #include "jsscript.h" /* js_XDRScript */ #include "jsstr.h" #include "jsxdrapi.h" #include "vm/Debugger.h" #include "jsobjinlines.h" +using namespace mozilla; using namespace js; #ifdef DEBUG #define DBG(x) x #else #define DBG(x) ((void)0) #endif @@ -636,17 +639,17 @@ js_XDRAtom(JSXDRState *xdr, JSAtom **ato /* * Inline JS_XDRString when decoding to avoid JSString allocation * for already existing atoms. See bug 321985. */ if (!JS_XDRUint32(xdr, &nchars)) return JS_FALSE; atom = NULL; cx = xdr->cx; - if (nchars <= JS_ARRAY_LENGTH(stackChars)) { + if (nchars <= ArrayLength(stackChars)) { chars = stackChars; } else { /* * This is very uncommon. Don't use the tempPool arena for this as * most allocations here will be bigger than tempPool's arenasize. */ chars = (jschar *) cx->malloc_(nchars * sizeof(jschar)); if (!chars)
--- a/js/src/jsxml.cpp +++ b/js/src/jsxml.cpp @@ -39,16 +39,19 @@ #include "jsversion.h" #if JS_HAS_XML_SUPPORT #include <math.h> #include <stdlib.h> #include <string.h> + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsprf.h" #include "jsutil.h" #include "jsapi.h" #include "jsarray.h" #include "jsatom.h" #include "jsbool.h" @@ -75,16 +78,17 @@ #include "jsstrinlines.h" #include "vm/Stack-inl.h" #ifdef DEBUG #include <string.h> /* for #ifdef DEBUG memset calls */ #endif +using namespace mozilla; using namespace js; using namespace js::gc; using namespace js::types; /* * NOTES * - in the js shell, you must use the -x command line option, or call * options('xml') before compiling anything that uses XML literals @@ -3757,17 +3761,17 @@ GetProperty(JSContext *cx, JSObject *obj */ nameqn = ToXMLName(cx, IdToJsval(id), &funid); if (!nameqn) return false; if (!JSID_IS_VOID(funid)) return GetXMLFunction(cx, obj, funid, vp); jsval roots[2] = { OBJECT_TO_JSVAL(nameqn), JSVAL_NULL }; - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(roots), roots); + AutoArrayRooter tvr(cx, ArrayLength(roots), roots); listobj = js_NewXMLObject(cx, JSXML_CLASS_LIST); if (!listobj) return false; roots[1] = OBJECT_TO_JSVAL(listobj); list = (JSXML *) listobj->getPrivate(); @@ -3858,17 +3862,17 @@ PutProperty(JSContext *cx, JSObject *obj if (!ok) return JS_FALSE; MUST_FLOW_THROUGH("out"); jsval roots[3]; roots[OBJ_ROOT] = OBJECT_TO_JSVAL(obj); roots[ID_ROOT] = IdToJsval(id); roots[VAL_ROOT] = *vp; - AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(roots), roots); + AutoArrayRooter tvr(cx, ArrayLength(roots), roots); if (js_IdIsIndex(id, &index)) { if (xml->xml_class != JSXML_CLASS_LIST) { /* See NOTE in spec: this variation is reserved for future use. */ ReportBadXMLName(cx, IdToValue(id)); goto bad; }
--- a/js/src/methodjit/MachineRegs.h +++ b/js/src/methodjit/MachineRegs.h @@ -35,16 +35,18 @@ * 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 ***** */ #if !defined jsjaeger_regstate_h__ && defined JS_METHODJIT #define jsjaeger_regstate_h__ +#include "mozilla/Util.h" + #include "assembler/assembler/MacroAssembler.h" namespace js { namespace mjit { /* Common handling for both general purpose and floating point registers. */ @@ -331,18 +333,18 @@ struct Registers { JSC::SparcRegisters::o0, JSC::SparcRegisters::o1, JSC::SparcRegisters::o2, JSC::SparcRegisters::o3, JSC::SparcRegisters::o4, JSC::SparcRegisters::o5 }; #endif - JS_ASSERT(numArgRegs(conv) == JS_ARRAY_LENGTH(regs)); - if (i > JS_ARRAY_LENGTH(regs)) + JS_ASSERT(numArgRegs(conv) == mozilla::ArrayLength(regs)); + if (i > mozilla::ArrayLength(regs)) return false; *reg = regs[i]; return true; } /* Floating point registers. */ typedef JSC::MacroAssembler::FPRegisterID FPRegisterID;
--- a/js/src/shell/js.cpp +++ b/js/src/shell/js.cpp @@ -43,16 +43,19 @@ */ #include <errno.h> #include <math.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <signal.h> #include <locale.h> + +#include "mozilla/Util.h" + #include "jstypes.h" #include "jsstdint.h" #include "jsutil.h" #include "jsprf.h" #include "jswrapper.h" #include "jsapi.h" #include "jsarray.h" #include "jsatom.h" @@ -109,16 +112,17 @@ #if defined(XP_WIN) || defined(XP_OS2) #include <io.h> /* for isatty() */ #endif #ifdef XP_WIN #include "jswin.h" #endif +using namespace mozilla; using namespace js; using namespace js::cli; typedef enum JSShellExitCode { EXITCODE_RUNTIME_ERROR = 3, EXITCODE_FILE_NOT_FOUND = 4, EXITCODE_OUT_OF_MEMORY = 5, EXITCODE_TIMEOUT = 6 @@ -601,17 +605,17 @@ cleanup: fclose(file); return; } /* * JSContext option name to flag map. The option names are in alphabetical * order for better reporting. */ -static const struct { +static const struct JSOption { const char *name; uint32 flag; } js_options[] = { {"atline", JSOPTION_ATLINE}, {"jitprofiling", JSOPTION_PROFILING}, {"tracejit", JSOPTION_JIT}, {"methodjit", JSOPTION_METHODJIT}, {"methodjit_always",JSOPTION_METHODJIT_ALWAYS}, @@ -620,31 +624,31 @@ static const struct { {"typeinfer", JSOPTION_TYPE_INFERENCE}, {"werror", JSOPTION_WERROR}, {"xml", JSOPTION_XML}, }; static uint32 MapContextOptionNameToFlag(JSContext* cx, const char* name) { - for (size_t i = 0; i != JS_ARRAY_LENGTH(js_options); ++i) { + for (size_t i = 0; i < ArrayLength(js_options); ++i) { if (strcmp(name, js_options[i].name) == 0) return js_options[i].flag; } char* msg = JS_sprintf_append(NULL, "unknown option name '%s'." " The valid names are ", name); - for (size_t i = 0; i != JS_ARRAY_LENGTH(js_options); ++i) { + for (size_t i = 0; i < ArrayLength(js_options); ++i) { if (!msg) break; msg = JS_sprintf_append(msg, "%s%s", js_options[i].name, - (i + 2 < JS_ARRAY_LENGTH(js_options) + (i + 2 < ArrayLength(js_options) ? ", " - : i + 2 == JS_ARRAY_LENGTH(js_options) + : i + 2 == ArrayLength(js_options) ? " and " : ".")); } if (!msg) { JS_ReportOutOfMemory(cx); } else { JS_ReportError(cx, msg); free(msg); @@ -736,17 +740,17 @@ Options(JSContext *cx, uintN argc, jsval if (!flag) return JS_FALSE; optset |= flag; } optset = JS_ToggleOptions(cx, optset); names = NULL; found = JS_FALSE; - for (size_t i = 0; i != JS_ARRAY_LENGTH(js_options); i++) { + for (size_t i = 0; i < ArrayLength(js_options); i++) { if (js_options[i].flag & optset) { found = JS_TRUE; names = JS_sprintf_append(names, "%s%s", names ? "," : "", js_options[i].name); if (!names) break; } } @@ -1212,30 +1216,30 @@ GC(JSContext *cx, uintN argc, jsval *vp) #else 0 #endif ); *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, buf)); return true; } +static const struct ParamPair { + const char *name; + JSGCParamKey param; +} paramMap[] = { + {"maxBytes", JSGC_MAX_BYTES }, + {"maxMallocBytes", JSGC_MAX_MALLOC_BYTES}, + {"gcStackpoolLifespan", JSGC_STACKPOOL_LIFESPAN}, + {"gcBytes", JSGC_BYTES}, + {"gcNumber", JSGC_NUMBER}, +}; + static JSBool GCParameter(JSContext *cx, uintN argc, jsval *vp) { - static const struct { - const char *name; - JSGCParamKey param; - } paramMap[] = { - {"maxBytes", JSGC_MAX_BYTES }, - {"maxMallocBytes", JSGC_MAX_MALLOC_BYTES}, - {"gcStackpoolLifespan", JSGC_STACKPOOL_LIFESPAN}, - {"gcBytes", JSGC_BYTES}, - {"gcNumber", JSGC_NUMBER}, - }; - JSString *str; if (argc == 0) { str = JS_ValueToString(cx, JSVAL_VOID); JS_ASSERT(str); } else { str = JS_ValueToString(cx, vp[2]); if (!str) return JS_FALSE; @@ -1243,17 +1247,17 @@ GCParameter(JSContext *cx, uintN argc, j } JSFlatString *flatStr = JS_FlattenString(cx, str); if (!flatStr) return JS_FALSE; size_t paramIndex = 0; for (;; paramIndex++) { - if (paramIndex == JS_ARRAY_LENGTH(paramMap)) { + if (paramIndex == ArrayLength(paramMap)) { JS_ReportError(cx, "the first argument argument must be maxBytes, " "maxMallocBytes, gcStackpoolLifespan, gcBytes or " "gcNumber"); return JS_FALSE; } if (JS_FlatStringEqualsAscii(flatStr, paramMap[paramIndex].name)) break; @@ -1407,40 +1411,40 @@ CountHeapNotify(JSTracer *trc, void *thi } } node->thing = thing; node->kind = kind; node->next = countTracer->traceList; countTracer->traceList = node; } +static const struct TraceKindPair { + const char *name; + int32 kind; +} traceKindNames[] = { + { "all", -1 }, + { "object", JSTRACE_OBJECT }, + { "string", JSTRACE_STRING }, +#if JS_HAS_XML_SUPPORT + { "xml", JSTRACE_XML }, +#endif +}; + static JSBool CountHeap(JSContext *cx, uintN argc, jsval *vp) { void* startThing; JSGCTraceKind startTraceKind; jsval v; - int32 traceKind, i; + int32 traceKind; JSString *str; JSCountHeapTracer countTracer; JSCountHeapNode *node; size_t counter; - static const struct { - const char *name; - int32 kind; - } traceKindNames[] = { - { "all", -1 }, - { "object", JSTRACE_OBJECT }, - { "string", JSTRACE_STRING }, -#if JS_HAS_XML_SUPPORT - { "xml", JSTRACE_XML }, -#endif - }; - startThing = NULL; startTraceKind = JSTRACE_OBJECT; if (argc > 0) { v = JS_ARGV(cx, vp)[0]; if (JSVAL_IS_TRACEABLE(v)) { startThing = JSVAL_TO_TRACEABLE(v); startTraceKind = JSVAL_TRACE_KIND(v); } else if (!JSVAL_IS_NULL(v)) { @@ -1454,22 +1458,22 @@ CountHeap(JSContext *cx, uintN argc, jsv traceKind = -1; if (argc > 1) { str = JS_ValueToString(cx, JS_ARGV(cx, vp)[1]); if (!str) return JS_FALSE; JSFlatString *flatStr = JS_FlattenString(cx, str); if (!flatStr) return JS_FALSE; - for (i = 0; ;) { + for (size_t i = 0; ;) { if (JS_FlatStringEqualsAscii(flatStr, traceKindNames[i].name)) { traceKind = traceKindNames[i].kind; break; } - if (++i == JS_ARRAY_LENGTH(traceKindNames)) { + if (++i == ArrayLength(traceKindNames)) { JSAutoByteString bytes(cx, str); if (!!bytes) JS_ReportError(cx, "trace kind name '%s' is unknown", bytes.ptr()); return JS_FALSE; } } } @@ -1983,17 +1987,17 @@ TryNotes(JSContext *cx, JSScript *script if (!JSScript::isValidOffset(script->trynotesOffset)) return JS_TRUE; tn = script->trynotes()->vector; tnlimit = tn + script->trynotes()->length; Sprint(sp, "\nException table:\nkind stack start end\n"); do { - JS_ASSERT(tn->kind < JS_ARRAY_LENGTH(TryNoteNames)); + JS_ASSERT(tn->kind < ArrayLength(TryNoteNames)); Sprint(sp, " %-7s %6u %8u %8u\n", TryNoteNames[tn->kind], tn->stackDepth, tn->start, tn->start + tn->length); } while (++tn != tnlimit); return JS_TRUE; } static bool @@ -4472,17 +4476,17 @@ JS_STATIC_ASSERT(JS_ARRAY_LENGTH(shell_h #ifdef DEBUG static void CheckHelpMessages() { const char *const *m; const char *lp; /* Messages begin with "function_name(" prefix and don't end with \n. */ - for (m = shell_help_messages; m != JS_ARRAY_END(shell_help_messages) - EXTERNAL_FUNCTION_COUNT; ++m) { + for (m = shell_help_messages; m < ArrayEnd(shell_help_messages) - EXTERNAL_FUNCTION_COUNT; ++m) { lp = strchr(*m, '('); JS_ASSERT(lp); JS_ASSERT(memcmp(shell_functions[m - shell_help_messages].name, *m, lp - *m) == 0); JS_ASSERT((*m)[strlen(*m) - 1] != '\n'); } } #else @@ -4501,17 +4505,17 @@ Help(JSContext *cx, uintN argc, jsval *v int did_header, did_something; JSType type; JSFunction *fun; JSString *str; fprintf(gOutFile, "%s\n", JS_GetImplementationVersion()); if (argc == 0) { fputs(shell_help_header, gOutFile); - for (i = 0; i < JS_ARRAY_LENGTH(shell_help_messages); ++i) + for (i = 0; i < ArrayLength(shell_help_messages); ++i) fprintf(gOutFile, "%s\n", shell_help_messages[i]); } else { did_header = 0; jsval *argv = JS_ARGV(cx, vp); for (i = 0; i < argc; i++) { did_something = 0; type = JS_TypeOfValue(cx, argv[i]); if (type == JSTYPE_FUNCTION) { @@ -4521,17 +4525,17 @@ Help(JSContext *cx, uintN argc, jsval *v str = JSVAL_TO_STRING(argv[i]); } else { str = NULL; } if (str) { JSAutoByteString funcName(cx, str); if (!funcName) return JS_FALSE; - for (j = 0; j < JS_ARRAY_LENGTH(shell_help_messages); ++j) { + for (j = 0; j < ArrayLength(shell_help_messages); ++j) { /* Help messages are required to be formatted "functionName(..." */ const char *msg = shell_help_messages[j]; const char *p = strchr(msg, '('); JS_ASSERT(p); if (size_t(p - msg) != str->length()) continue;
--- a/js/src/vm/RegExpObject-inl.h +++ b/js/src/vm/RegExpObject-inl.h @@ -36,16 +36,18 @@ * 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 ***** */ #ifndef RegExpObject_inl_h___ #define RegExpObject_inl_h___ +#include "mozilla/Util.h" + #include "RegExpObject.h" #include "RegExpStatics.h" #include "jsobjinlines.h" #include "jsstrinlines.h" #include "RegExpStatics-inl.h" inline js::RegExpObject * @@ -278,22 +280,23 @@ RegExpPrivate::compile(JSContext *cx, To /* * The sticky case we implement hackily by prepending a caret onto the front * and relying on |::execute| to pseudo-slice the string when it sees a sticky regexp. */ static const jschar prefix[] = {'^', '(', '?', ':'}; static const jschar postfix[] = {')'}; + using mozilla::ArrayLength; StringBuffer sb(cx); - if (!sb.reserve(JS_ARRAY_LENGTH(prefix) + source->length() + JS_ARRAY_LENGTH(postfix))) + if (!sb.reserve(ArrayLength(prefix) + source->length() + ArrayLength(postfix))) return false; - sb.infallibleAppend(prefix, JS_ARRAY_LENGTH(prefix)); + sb.infallibleAppend(prefix, ArrayLength(prefix)); sb.infallibleAppend(source->chars(), source->length()); - sb.infallibleAppend(postfix, JS_ARRAY_LENGTH(postfix)); + sb.infallibleAppend(postfix, ArrayLength(postfix)); JSLinearString *fakeySource = sb.finishString(); if (!fakeySource) return false; return code.compile(cx, *fakeySource, ts, &parenCount, getFlags()); } inline RegExpRunStatus
--- a/js/src/vm/String.h +++ b/js/src/vm/String.h @@ -36,16 +36,18 @@ * 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 ***** */ #ifndef String_h_ #define String_h_ +#include "mozilla/Util.h" + #include "jsapi.h" #include "jscell.h" class JSString; class JSDependentString; class JSExtensibleString; class JSExternalString; class JSLinearString; @@ -628,17 +630,17 @@ class JSExternalString : public JSFixedS return d.s.u3.externalClosure; } static const uintN TYPE_LIMIT = 8; static JSStringFinalizeOp str_finalizers[TYPE_LIMIT]; static intN changeFinalizer(JSStringFinalizeOp oldop, JSStringFinalizeOp newop) { - for (uintN i = 0; i != JS_ARRAY_LENGTH(str_finalizers); i++) { + for (uintN i = 0; i < mozilla::ArrayLength(str_finalizers); i++) { if (str_finalizers[i] == oldop) { str_finalizers[i] = newop; return intN(i); } } return -1; }
--- a/js/xpconnect/shell/xpcshell.cpp +++ b/js/xpconnect/shell/xpcshell.cpp @@ -41,16 +41,19 @@ * 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 ***** */ /* XPConnect JavaScript interactive shell. */ #include <stdio.h> + +#include "mozilla/Util.h" + #include "jsapi.h" #include "jscntxt.h" #include "jsdbgapi.h" #include "jsfriendapi.h" #include "jsprf.h" #include "nsXULAppAPI.h" #include "nsServiceManagerUtils.h" #include "nsComponentManagerUtils.h" @@ -101,16 +104,18 @@ #endif #include "nsIJSContextStack.h" #ifdef MOZ_CRASHREPORTER #include "nsICrashReporter.h" #endif +using namespace mozilla; + class XPCShellDirProvider : public nsIDirectoryServiceProvider2 { public: NS_DECL_ISUPPORTS_INHERITED NS_DECL_NSIDIRECTORYSERVICEPROVIDER NS_DECL_NSIDIRECTORYSERVICEPROVIDER2 XPCShellDirProvider() { } @@ -707,46 +712,46 @@ GetChildGlobalObject(JSContext* cx, } return JS_FALSE; } /* * JSContext option name to flag map. The option names are in alphabetical * order for better reporting. */ -static const struct { +static const struct JSOption { const char *name; uint32 flag; } js_options[] = { {"atline", JSOPTION_ATLINE}, {"jit", JSOPTION_JIT}, {"relimit", JSOPTION_RELIMIT}, {"strict", JSOPTION_STRICT}, {"werror", JSOPTION_WERROR}, {"xml", JSOPTION_XML}, }; static uint32 MapContextOptionNameToFlag(JSContext* cx, const char* name) { - for (size_t i = 0; i != JS_ARRAY_LENGTH(js_options); ++i) { + for (size_t i = 0; i < ArrayLength(js_options); ++i) { if (strcmp(name, js_options[i].name) == 0) return js_options[i].flag; } char* msg = JS_sprintf_append(NULL, "unknown option name '%s'." " The valid names are ", name); - for (size_t i = 0; i != JS_ARRAY_LENGTH(js_options); ++i) { + for (size_t i = 0; i < ArrayLength(js_options); ++i) { if (!msg) break; msg = JS_sprintf_append(msg, "%s%s", js_options[i].name, - (i + 2 < JS_ARRAY_LENGTH(js_options) + (i + 2 < ArrayLength(js_options) ? ", " - : i + 2 == JS_ARRAY_LENGTH(js_options) + : i + 2 == ArrayLength(js_options) ? " and " : ".")); } if (!msg) { JS_ReportOutOfMemory(cx); } else { JS_ReportError(cx, msg); free(msg); @@ -776,17 +781,17 @@ Options(JSContext *cx, uintN argc, jsval if (!flag) return JS_FALSE; optset |= flag; } optset = JS_ToggleOptions(cx, optset); names = NULL; found = JS_FALSE; - for (size_t i = 0; i != JS_ARRAY_LENGTH(js_options); i++) { + for (size_t i = 0; i < ArrayLength(js_options); i++) { if (js_options[i].flag & optset) { found = JS_TRUE; names = JS_sprintf_append(names, "%s%s", names ? "," : "", js_options[i].name); if (!names) break; } }
--- a/js/xpconnect/src/XPCJSRuntime.cpp +++ b/js/xpconnect/src/XPCJSRuntime.cpp @@ -36,16 +36,18 @@ * 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 ***** */ /* Per JSRuntime object */ +#include "mozilla/Util.h" + #include "xpcprivate.h" #include "xpcpublic.h" #include "WrapperFactory.h" #include "dom_quickstubs.h" #include "jsgcchunk.h" #include "jsscope.h" #include "nsIMemoryReporter.h" @@ -1566,17 +1568,17 @@ CollectCompartmentStatsForRuntime(JSRunt for (PRUint32 index = 0; index < data->compartmentStatsVector.Length(); index++) { CompartmentStats &stats = data->compartmentStatsVector[index]; PRInt64 used = stats.gcHeapArenaHeaders + stats.gcHeapArenaPadding + stats.gcHeapArenaUnused; - for (size_t i = 0; i != JS_ARRAY_LENGTH(stats.gcHeapKinds); ++i) + for (size_t i = 0; i < ArrayLength(stats.gcHeapKinds); ++i) used += stats.gcHeapKinds[i]; data->gcHeapChunkDirtyUnused -= used; data->gcHeapArenaUnused += stats.gcHeapArenaUnused; } size_t numDirtyChunks = (data->gcHeapChunkTotal - data->gcHeapChunkCleanUnused) /
--- a/js/xpconnect/src/XPCQuickStubs.cpp +++ b/js/xpconnect/src/XPCQuickStubs.cpp @@ -32,24 +32,28 @@ * 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 ***** */ +#include "mozilla/Util.h" + #include "jsapi.h" #include "jscntxt.h" /* for error messages */ #include "nsCOMPtr.h" #include "xpcprivate.h" #include "XPCInlines.h" #include "XPCQuickStubs.h" #include "XPCWrapper.h" +using namespace mozilla; + static inline QITableEntry * GetOffsets(nsISupports *identity, XPCWrappedNativeProto* proto) { QITableEntry* offsets = proto ? proto->GetOffsets() : nsnull; if (!offsets) { static NS_DEFINE_IID(kThisPtrOffsetsSID, NS_THISPTROFFSETS_SID); identity->QueryInterface(kThisPtrOffsetsSID, (void**)&offsets); } @@ -210,17 +214,17 @@ GeneratePropertyOp(JSContext *cx, JSObje static JSBool ReifyPropertyOps(JSContext *cx, JSObject *obj, jsid id, uintN orig_attrs, JSPropertyOp getter, JSStrictPropertyOp setter, JSObject **getterobjp, JSObject **setterobjp) { // Generate both getter and setter and stash them in the prototype. jsval roots[2] = { JSVAL_NULL, JSVAL_NULL }; - js::AutoArrayRooter tvr(cx, JS_ARRAY_LENGTH(roots), roots); + js::AutoArrayRooter tvr(cx, ArrayLength(roots), roots); uintN attrs = JSPROP_SHARED | (orig_attrs & JSPROP_ENUMERATE); JSObject *getterobj; if (getter) { getterobj = GeneratePropertyOp(cx, obj, id, 0, getter); if (!getterobj) return JS_FALSE; roots[0] = OBJECT_TO_JSVAL(getterobj);
--- a/js/xpconnect/src/nsXPConnect.cpp +++ b/js/xpconnect/src/nsXPConnect.cpp @@ -806,17 +806,17 @@ nsXPConnect::Traverse(void *p, nsCycleCo static const char trace_types[][11] = { "Object", "String", "Script", "Xml", "Shape", "TypeObject", }; - JS_STATIC_ASSERT(JS_ARRAY_LENGTH(trace_types) == JSTRACE_LAST + 1); + JS_STATIC_ASSERT(NS_ARRAY_LENGTH(trace_types) == JSTRACE_LAST + 1); JS_snprintf(name, sizeof(name), "JS %s", trace_types[traceKind]); } if (traceKind == JSTRACE_OBJECT) { JSObject *global = static_cast<JSObject*>(p), *parent; while ((parent = global->getParent())) global = parent; char fullname[100];