johnson 2.0.0.pre0 → 2.0.0.pre1

data/vendor/tracemonkey/jstypes.h

@@ -55,7 +55,7 @@
 #define jstypes_h___
 
 #include <stddef.h>
-#include "jsstdint.h"
+#include "js-config.h"
 
 /***********************************************************************
 ** MACROS:      JS_EXTERN_API
@@ -92,6 +92,13 @@
 # define JS_EXTERN_DATA(__type) extern __declspec(dllexport) __type
 # define JS_EXPORT_DATA(__type) __declspec(dllexport) __type
 
+#elif defined(__SYMBIAN32__)
+
+# define JS_EXTERN_API(__type) extern EXPORT_C __type
+# define JS_EXPORT_API(__type) EXPORT_C __type
+# define JS_EXTERN_DATA(__type) extern EXPORT_C __type
+# define JS_EXPORT_DATA(__type) EXPORT_C __type
+
 #else /* Unix */
 
 # ifdef HAVE_VISIBILITY_ATTRIBUTE
@@ -117,6 +124,8 @@
 # endif
 #elif defined(XP_OS2) && defined(__declspec)
 # define JS_IMPORT_API(__x)     __declspec(dllimport) __x
+#elif defined(__SYMBIAN32__)
+# define JS_IMPORT_API(__x)     IMPORT_C __x
 #else
 # define JS_IMPORT_API(__x)     JS_EXPORT_API (__x)
 #endif
@@ -125,6 +134,12 @@
 # define JS_IMPORT_DATA(__x)      __declspec(dllimport) __x
 #elif defined(XP_OS2) && defined(__declspec)
 # define JS_IMPORT_DATA(__x)      __declspec(dllimport) __x
+#elif defined(__SYMBIAN32__)
+# if defined(__CW32__)
+#   define JS_IMPORT_DATA(__x)    __declspec(dllimport) __x
+# else
+#   define JS_IMPORT_DATA(__x)    IMPORT_C __x
+# endif
 #else
 # define JS_IMPORT_DATA(__x)     JS_EXPORT_DATA (__x)
 #endif
@@ -198,9 +213,14 @@
  */
 # define JS_REQUIRES_STACK   __attribute__((user("JS_REQUIRES_STACK")))
 # define JS_FORCES_STACK     __attribute__((user("JS_FORCES_STACK")))
+/*
+ * Skip the JS_REQUIRES_STACK analysis within functions with this annotation.
+ */
+# define JS_IGNORE_STACK     __attribute__((user("JS_IGNORE_STACK")))
 #else
 # define JS_REQUIRES_STACK
 # define JS_FORCES_STACK
+# define JS_IGNORE_STACK
 #endif
 
 /***********************************************************************
@@ -275,56 +295,16 @@
 
 #ifdef _MSC_VER
 # include "jscpucfg.h"  /* We can't auto-detect MSVC configuration */
+# if _MSC_VER < 1400
+#  define MOZ_NO_VARADIC_MACROS
+# endif
 #else
 # include "jsautocfg.h" /* Use auto-detected configuration */
 #endif
 
-JS_BEGIN_EXTERN_C
-
-/************************************************************************
-** TYPES:       JSUint8
-**              JSInt8
-** DESCRIPTION:
-**  The int8 types are known to be 8 bits each. There is no type that
-**      is equivalent to a plain "char".
-************************************************************************/
-
-typedef uint8_t JSUint8;
-typedef int8_t JSInt8;
-
-/************************************************************************
-** TYPES:       JSUint16
-**              JSInt16
-** DESCRIPTION:
-**  The int16 types are known to be 16 bits each.
-************************************************************************/
-
-typedef uint16_t JSUint16;
-typedef int16_t JSInt16;
-
-/************************************************************************
-** TYPES:       JSUint32
-**              JSInt32
-** DESCRIPTION:
-**  The int32 types are known to be 32 bits each.
-************************************************************************/
-
-typedef uint32_t JSUint32;
-typedef int32_t JSInt32;
+#include "jsinttypes.h"
 
-/************************************************************************
-** TYPES:       JSUint64
-**              JSInt64
-** DESCRIPTION:
-**  The int64 types are known to be 64 bits each. Care must be used when
-**      declaring variables of type JSUint64 or JSInt64. Different hardware
-**      architectures and even different compilers have varying support for
-**      64 bit values. The only guaranteed portability requires the use of
-**      the JSLL_ macros (see jslong.h).
-************************************************************************/
-
-typedef uint64_t JSUint64;
-typedef int64_t JSInt64;
+JS_BEGIN_EXTERN_C
 
 /************************************************************************
 ** TYPES:       JSUintn
@@ -367,7 +347,7 @@ typedef ptrdiff_t JSPtrdiff;
 **  A type for pointer difference. Variables of this type are suitable
 **      for storing a pointer or pointer sutraction.
 ************************************************************************/
-typedef uintptr_t JSUptrdiff;
+typedef JSUintPtr JSUptrdiff;
 
 /************************************************************************
 ** TYPES:       JSBool
@@ -392,8 +372,8 @@ typedef JSUint8 JSPackedBool;
 /*
 ** A JSWord is an integer that is the same size as a void*
 */
-typedef intptr_t JSWord;
-typedef uintptr_t JSUword;
+typedef JSIntPtr JSWord;
+typedef JSUintPtr JSUword;
 
 #include "jsotypes.h"
 

data/vendor/tracemonkey/jsutil.cpp

@@ -1,4 +1,4 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
@@ -41,10 +41,10 @@
 /*
  * PR assertion checker.
  */
-#include "jsstddef.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include "jstypes.h"
+#include "jsstdint.h"
 #include "jsutil.h"
 
 #ifdef WIN32
@@ -297,7 +297,7 @@ CallTree(void **bp)
             return NULL;
 
         /* Create a new callsite record. */
-        site = (JSCallsite *) malloc(sizeof(JSCallsite));
+        site = (JSCallsite *) js_malloc(sizeof(JSCallsite));
         if (!site)
             return NULL;
 

data/vendor/tracemonkey/jsutil.h

@@ -44,6 +44,8 @@
 #ifndef jsutil_h___
 #define jsutil_h___
 
+#include <stdlib.h>
+
 JS_BEGIN_EXTERN_C
 
 /*
@@ -73,7 +75,7 @@ JS_Assert(const char *s, const char *file, JSIntn ln);
 #endif /* defined(DEBUG) */
 
 /*
- * Compile-time assert. "condition" must be a constant expression.
+ * Compile-time assert. "cond" must be a constant expression.
  * The macro can be used only in places where an "extern" declaration is
  * allowed.
  */
@@ -85,10 +87,16 @@ JS_Assert(const char *s, const char *file, JSIntn ln);
  * Turn off this assert for Sun Studio until this bug is fixed.
  */
 #ifdef __SUNPRO_CC
-#define JS_STATIC_ASSERT(condition)
+#define JS_STATIC_ASSERT(cond)
+#else
+#ifdef __COUNTER__
+    #define JS_STATIC_ASSERT_GLUE1(x,y) x##y
+    #define JS_STATIC_ASSERT_GLUE(x,y) JS_STATIC_ASSERT_GLUE1(x,y)
+    #define JS_STATIC_ASSERT(cond)                                            \
+        typedef int JS_STATIC_ASSERT_GLUE(js_static_assert, __COUNTER__)[(cond) ? 1 : -1]
 #else
-#define JS_STATIC_ASSERT(condition)                                           \
-    extern void js_static_assert(int arg[(condition) ? 1 : -1])
+    #define JS_STATIC_ASSERT(cond) extern void js_static_assert(int arg[(cond) ? 1 : -1])
+#endif
 #endif
 
 #define JS_STATIC_ASSERT_IF(cond, expr) JS_STATIC_ASSERT(!(cond) || (expr))
@@ -170,9 +178,123 @@ JS_Backtrace(int skip);
 
 extern JS_FRIEND_API(void)
 JS_DumpBacktrace(JSCallsite *trace);
-
 #endif
 
+static JS_INLINE void* js_malloc(size_t bytes) {
+    if (bytes < sizeof(void*)) /* for asyncFree */
+        bytes = sizeof(void*);
+    return malloc(bytes);
+}
+
+static JS_INLINE void* js_calloc(size_t bytes) {
+    if (bytes < sizeof(void*)) /* for asyncFree */
+        bytes = sizeof(void*);
+    return calloc(bytes, 1);
+}
+
+static JS_INLINE void* js_realloc(void* p, size_t bytes) {
+    if (bytes < sizeof(void*)) /* for asyncFree */
+        bytes = sizeof(void*);
+    return realloc(p, bytes);
+}
+
+static JS_INLINE void js_free(void* p) {
+    free(p);
+}
+
 JS_END_EXTERN_C
 
+#ifdef __cplusplus
+
+/**
+ * The following classes are designed to cause assertions to detect
+ * inadvertent use of guard objects as temporaries.  In other words,
+ * when we have a guard object whose only purpose is its constructor and
+ * destructor (and is never otherwise referenced), the intended use
+ * might be:
+ *     JSAutoTempValueRooter tvr(cx, 1, &val);
+ * but is is easy to accidentally write:
+ *     JSAutoTempValueRooter(cx, 1, &val);
+ * which compiles just fine, but runs the destructor well before the
+ * intended time.
+ *
+ * They work by adding (#ifdef DEBUG) an additional parameter to the
+ * guard object's constructor, with a default value, so that users of
+ * the guard object's API do not need to do anything.  The default value
+ * of this parameter is a temporary object.  C++ (ISO/IEC 14882:1998),
+ * section 12.2 [class.temporary], clauses 4 and 5 seem to assume a
+ * guarantee that temporaries are destroyed in the reverse of their
+ * construction order, but I actually can't find a statement that that
+ * is true in the general case (beyond the two specific cases mentioned
+ * there).  However, it seems to be true.
+ *
+ * These classes are intended to be used only via the macros immediately
+ * below them:
+ *   JS_DECL_USE_GUARD_OBJECT_NOTIFIER declares (ifdef DEBUG) a member
+ *     variable, and should be put where a declaration of a private
+ *     member variable would be placed.
+ *   JS_GUARD_OBJECT_NOTIFIER_PARAM should be placed at the end of the
+ *     parameters to each constructor of the guard object; it declares
+ *     (ifdef DEBUG) an additional parameter.
+ *   JS_GUARD_OBJECT_NOTIFIER_INIT is a statement that belongs in each
+ *     constructor.  It uses the parameter declared by
+ *     JS_GUARD_OBJECT_NOTIFIER_PARAM.
+ */
+#ifdef DEBUG
+class JSGuardObjectNotifier
+{
+private:
+    bool* mStatementDone;
+public:
+    JSGuardObjectNotifier() : mStatementDone(NULL) {}
+
+    ~JSGuardObjectNotifier() {
+        *mStatementDone = true;
+    }
+
+    void SetStatementDone(bool *aStatementDone) {
+        mStatementDone = aStatementDone;
+    }
+};
+
+class JSGuardObjectNotificationReceiver
+{
+private:
+    bool mStatementDone;
+public:
+    JSGuardObjectNotificationReceiver() : mStatementDone(false) {}
+
+    ~JSGuardObjectNotificationReceiver() {
+        // Assert that the guard object was not used as a temporary.
+        // (Note that this assert might also fire if Init is not called
+        // because the guard object's implementation is not using the
+        // above macros correctly.)
+        JS_ASSERT(mStatementDone);
+    }
+
+    void Init(const JSGuardObjectNotifier &aNotifier) {
+       // aNotifier is passed as a const reference so that we can pass a
+       // temporary, but we really intend it as non-const
+       const_cast<JSGuardObjectNotifier&>(aNotifier).
+           SetStatementDone(&mStatementDone);
+    }
+};
+
+#define JS_DECL_USE_GUARD_OBJECT_NOTIFIER \
+    JSGuardObjectNotificationReceiver _mCheckNotUsedAsTemporary;
+#define JS_GUARD_OBJECT_NOTIFIER_PARAM \
+    , const JSGuardObjectNotifier& _notifier = JSGuardObjectNotifier()
+#define JS_GUARD_OBJECT_NOTIFIER_INIT \
+    JS_BEGIN_MACRO _mCheckNotUsedAsTemporary.Init(_notifier); JS_END_MACRO
+
+#else /* defined(DEBUG) */
+
+#define JS_DECL_USE_GUARD_OBJECT_NOTIFIER
+#define JS_GUARD_OBJECT_NOTIFIER_PARAM
+#define JS_GUARD_OBJECT_NOTIFIER_INIT JS_BEGIN_MACRO JS_END_MACRO
+
+#endif /* !defined(DEBUG) */
+
+#endif /* defined(__cplusplus) */
+
 #endif /* jsutil_h___ */

data/vendor/tracemonkey/jsvector.h

@@ -0,0 +1,775 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sw=4 et tw=99 ft=cpp:
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla SpiderMonkey JavaScript 1.9 code, released
+ * June 12, 2009.
+ *
+ * The Initial Developer of the Original Code is
+ *   the Mozilla Corporation.
+ *
+ * Contributor(s):
+ *   Luke Wagner <lw@mozilla.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef jsvector_h_
+#define jsvector_h_
+
+#include <new>
+
+#include "jstl.h"
+
+namespace js {
+
+/*
+ * This template class provides a default implementation for vector operations
+ * when the element type is not known to be a POD, as judged by IsPodType.
+ */
+template <class T, size_t N, class AP, bool IsPod>
+struct VectorImpl
+{
+    /* Destroys constructed objects in the range [begin, end). */
+    static inline void destroy(T *begin, T *end) {
+        for (T *p = begin; p != end; ++p)
+            p->~T();
+    }
+
+    /* Constructs objects in the uninitialized range [begin, end). */
+    static inline void initialize(T *begin, T *end) {
+        for (T *p = begin; p != end; ++p)
+            new(p) T();
+    }
+
+    /*
+     * Copy-constructs objects in the uninitialized range
+     * [dst, dst+(srcend-srcbeg)) from the range [srcbeg, srcend).
+     */
+    template <class U>
+    static inline void copyConstruct(T *dst, const U *srcbeg, const U *srcend) {
+        for (const U *p = srcbeg; p != srcend; ++p, ++dst)
+            new(dst) T(*p);
+    }
+
+    /*
+     * Copy-constructs objects in the uninitialized range [dst, dst+n) from the
+     * same object u.
+     */
+    template <class U>
+    static inline void copyConstructN(T *dst, size_t n, const U &u) {
+        for (T *end = dst + n; dst != end; ++dst)
+            new(dst) T(u);
+    }
+
+    /*
+     * Grows the given buffer to have capacity newcap, preserving the objects
+     * constructed in the range [begin, end) and updating v. Assumes that (1)
+     * newcap has not overflowed, and (2) multiplying newcap by sizeof(T) will
+     * not overflow.
+     */
+    static inline bool growTo(Vector<T,N,AP> &v, size_t newcap) {
+        JS_ASSERT(!v.usingInlineStorage());
+        T *newbuf = reinterpret_cast<T *>(v.malloc(newcap * sizeof(T)));
+        if (!newbuf)
+            return false;
+        for (T *dst = newbuf, *src = v.heapBegin(); src != v.heapEnd(); ++dst, ++src)
+            new(dst) T(*src);
+        VectorImpl::destroy(v.heapBegin(), v.heapEnd());
+        v.free(v.heapBegin());
+        v.heapEnd() = newbuf + v.heapLength();
+        v.heapBegin() = newbuf;
+        v.heapCapacity() = newcap;
+        return true;
+    }
+};
+
+/*
+ * This partial template specialization provides a default implementation for
+ * vector operations when the element type is known to be a POD, as judged by
+ * IsPodType.
+ */
+template <class T, size_t N, class AP>
+struct VectorImpl<T, N, AP, true>
+{
+    static inline void destroy(T *, T *) {}
+
+    static inline void initialize(T *begin, T *end) {
+        /*
+         * You would think that memset would be a big win (or even break even)
+         * when we know T is a POD. But currently it's not. This is probably
+         * because |append| tends to be given small ranges and memset requires
+         * a function call that doesn't get inlined.
+         *
+         * memset(begin, 0, sizeof(T) * (end-begin));
+         */
+        for (T *p = begin; p != end; ++p)
+            new(p) T();
+    }
+
+    template <class U>
+    static inline void copyConstruct(T *dst, const U *srcbeg, const U *srcend) {
+        /*
+         * See above memset comment. Also, notice that copyConstruct is
+         * currently templated (T != U), so memcpy won't work without
+         * requiring T == U.
+         *
+         * memcpy(dst, srcbeg, sizeof(T) * (srcend - srcbeg));
+         */
+        for (const U *p = srcbeg; p != srcend; ++p, ++dst)
+            *dst = *p;
+    }
+
+    static inline void copyConstructN(T *dst, size_t n, const T &t) {
+        for (T *end = dst + n; dst != end; ++dst)
+            *dst = t;
+    }
+
+    static inline bool growTo(Vector<T,N,AP> &v, size_t newcap) {
+        JS_ASSERT(!v.usingInlineStorage());
+        size_t bytes = sizeof(T) * newcap;
+        T *newbuf = reinterpret_cast<T *>(v.realloc(v.heapBegin(), bytes));
+        if (!newbuf)
+            return false;
+        v.heapEnd() = newbuf + v.heapLength();
+        v.heapBegin() = newbuf;
+        v.heapCapacity() = newcap;
+        return true;
+    }
+};
+
+/*
+ * JS-friendly, STL-like container providing a short-lived, dynamic buffer.
+ * Vector calls the constructors/destructors of all elements stored in
+ * its internal buffer, so non-PODs may be safely used. Additionally,
+ * Vector will store the first N elements in-place before resorting to
+ * dynamic allocation.
+ *
+ * T requirements:
+ *  - default and copy constructible, assignable, destructible
+ *  - operations do not throw
+ * N requirements:
+ *  - any value, however, N is clamped to min/max values
+ * AllocPolicy:
+ *  - see "Allocation policies" in jstl.h (default ContextAllocPolicy)
+ *
+ * N.B: Vector is not reentrant: T member functions called during Vector member
+ *      functions must not call back into the same object.
+ */
+template <class T, size_t N, class AllocPolicy>
+class Vector : AllocPolicy
+{
+    /* utilities */
+
+    static const bool sElemIsPod = tl::IsPodType<T>::result;
+    typedef VectorImpl<T, N, AllocPolicy, sElemIsPod> Impl;
+    friend struct VectorImpl<T, N, AllocPolicy, sElemIsPod>;
+
+    bool calculateNewCapacity(size_t curLength, size_t lengthInc, size_t &newCap);
+    bool growHeapStorageBy(size_t lengthInc);
+    bool convertToHeapStorage(size_t lengthInc);
+
+    /* magic constants */
+
+    static const int sMaxInlineBytes = 1024;
+
+    /* compute constants */
+
+    /*
+     * Pointers to the heap-allocated buffer. Only [heapBegin(), heapEnd())
+     * hold valid constructed T objects. The range [heapEnd(), heapBegin() +
+     * heapCapacity()) holds uninitialized memory.
+     */
+    struct BufferPtrs {
+        T *mBegin, *mEnd;
+    };
+
+    /*
+     * Since a vector either stores elements inline or in a heap-allocated
+     * buffer, reuse the storage. mLengthOrCapacity serves as the union
+     * discriminator. In inline mode (when elements are stored in u.mBuf),
+     * mLengthOrCapacity holds the vector's length. In heap mode (when elements
+     * are stored in [u.ptrs.mBegin, u.ptrs.mEnd)), mLengthOrCapacity holds the
+     * vector's capacity.
+     */
+    static const size_t sInlineCapacity =
+        tl::Clamp<N, sizeof(BufferPtrs) / sizeof(T),
+                          sMaxInlineBytes / sizeof(T)>::result;
+
+    /* Calculate inline buffer size; avoid 0-sized array. */
+    static const size_t sInlineBytes =
+        tl::Max<1, sInlineCapacity * sizeof(T)>::result;
+
+    /* member data */
+
+    size_t mLengthOrCapacity;
+    bool usingInlineStorage() const { return mLengthOrCapacity <= sInlineCapacity; }
+
+    union {
+        BufferPtrs ptrs;
+        char mBuf[sInlineBytes];
+    } u;
+
+    /* Only valid when usingInlineStorage() */
+    size_t &inlineLength() {
+        JS_ASSERT(usingInlineStorage());
+        return mLengthOrCapacity;
+    }
+
+    size_t inlineLength() const {
+        JS_ASSERT(usingInlineStorage());
+        return mLengthOrCapacity;
+    }
+
+    T *inlineBegin() const {
+        JS_ASSERT(usingInlineStorage());
+        return (T *)u.mBuf;
+    }
+
+    T *inlineEnd() const {
+        JS_ASSERT(usingInlineStorage());
+        return ((T *)u.mBuf) + mLengthOrCapacity;
+    }
+
+    /* Only valid when !usingInlineStorage() */
+    size_t heapLength() const {
+        JS_ASSERT(!usingInlineStorage());
+        /* Guaranteed by calculateNewCapacity. */
+        JS_ASSERT(size_t(u.ptrs.mEnd - u.ptrs.mBegin) ==
+                  ((size_t(u.ptrs.mEnd) - size_t(u.ptrs.mBegin)) / sizeof(T)));
+        return u.ptrs.mEnd - u.ptrs.mBegin;
+    }
+
+    size_t &heapCapacity() {
+        JS_ASSERT(!usingInlineStorage());
+        return mLengthOrCapacity;
+    }
+
+    T *&heapBegin() {
+        JS_ASSERT(!usingInlineStorage());
+        return u.ptrs.mBegin;
+    }
+
+    T *&heapEnd() {
+        JS_ASSERT(!usingInlineStorage());
+        return u.ptrs.mEnd;
+    }
+
+    size_t heapCapacity() const {
+        JS_ASSERT(!usingInlineStorage());
+        return mLengthOrCapacity;
+    }
+
+    T *heapBegin() const {
+        JS_ASSERT(!usingInlineStorage());
+        return u.ptrs.mBegin;
+    }
+
+    T *heapEnd() const {
+        JS_ASSERT(!usingInlineStorage());
+        return u.ptrs.mEnd;
+    }
+
+#ifdef DEBUG
+    friend class ReentrancyGuard;
+    bool mEntered;
+#endif
+
+    Vector(const Vector &);
+    Vector &operator=(const Vector &);
+
+  public:
+    Vector(AllocPolicy = AllocPolicy());
+    ~Vector();
+
+    /* accessors */
+
+    size_t length() const {
+        return usingInlineStorage() ? inlineLength() : heapLength();
+    }
+
+    bool empty() const {
+        return usingInlineStorage() ? inlineLength() == 0 : heapBegin() == heapEnd();
+    }
+
+    size_t capacity() const {
+        return usingInlineStorage() ? sInlineCapacity : heapCapacity();
+    }
+
+    T *begin() {
+        JS_ASSERT(!mEntered);
+        return usingInlineStorage() ? inlineBegin() : heapBegin();
+    }
+
+    const T *begin() const {
+        JS_ASSERT(!mEntered);
+        return usingInlineStorage() ? inlineBegin() : heapBegin();
+    }
+
+    T *end() {
+        JS_ASSERT(!mEntered);
+        return usingInlineStorage() ? inlineEnd() : heapEnd();
+    }
+
+    const T *end() const {
+        JS_ASSERT(!mEntered);
+        return usingInlineStorage() ? inlineEnd() : heapEnd();
+    }
+
+    T &operator[](size_t i) {
+        JS_ASSERT(!mEntered && i < length());
+        return begin()[i];
+    }
+
+    const T &operator[](size_t i) const {
+        JS_ASSERT(!mEntered && i < length());
+        return begin()[i];
+    }
+
+    T &back() {
+        JS_ASSERT(!mEntered && !empty());
+        return *(end() - 1);
+    }
+
+    const T &back() const {
+        JS_ASSERT(!mEntered && !empty());
+        return *(end() - 1);
+    }
+
+    /* mutators */
+
+    /* If reserve(N) succeeds, the N next appends are guaranteed to succeed. */
+    bool reserve(size_t capacity);
+
+    /* Destroy elements in the range [begin() + incr, end()). */
+    void shrinkBy(size_t incr);
+
+    /*
+     * Grow the vector by incr elements.  If T is a POD (as judged by
+     * tl::IsPodType), leave as uninitialized memory.  Otherwise, default
+     * construct each element.
+     */
+    bool growBy(size_t incr);
+
+    /* Call shrinkBy or growBy based on whether newSize > length(). */
+    bool resize(size_t newLength);
+
+    void clear();
+
+    bool append(const T &t);
+    bool appendN(const T &t, size_t n);
+    template <class U> bool append(const U *begin, const U *end);
+    template <class U> bool append(const U *begin, size_t length);
+
+    void popBack();
+
+    /*
+     * Transfers ownership of the internal buffer used by Vector to the caller.
+     * After this call, the Vector is empty. Since the returned buffer may need
+     * to be allocated (if the elements are currently stored in-place), the
+     * call can fail, returning NULL.
+     *
+     * N.B. Although a T*, only the range [0, length()) is constructed.
+     */
+    T *extractRawBuffer();
+
+    /*
+     * Transfer ownership of an array of objects into the Vector.
+     * N.B. This call assumes that there are no uninitialized elements in the
+     *      passed array.
+     */
+    void replaceRawBuffer(T *p, size_t length);
+};
+
+/* Helper functions */
+
+/*
+ * This helper function is specialized for appending the characters of a string
+ * literal to a vector. This could not be done generically since one must take
+ * care not to append the terminating '\0'.
+ */
+template <class T, size_t N, class AP, size_t ArrayLength>
+bool
+js_AppendLiteral(Vector<T,N,AP> &v, const char (&array)[ArrayLength])
+{
+    return v.append(array, array + ArrayLength - 1);
+}
+
+
+/* Vector Implementation */
+
+template <class T, size_t N, class AP>
+inline
+Vector<T,N,AP>::Vector(AP ap)
+  : AP(ap), mLengthOrCapacity(0)
+#ifdef DEBUG
+    , mEntered(false)
+#endif
+{}
+
+template <class T, size_t N, class AP>
+inline
+Vector<T,N,AP>::~Vector()
+{
+    ReentrancyGuard g(*this);
+    if (usingInlineStorage()) {
+        Impl::destroy(inlineBegin(), inlineEnd());
+    } else {
+        Impl::destroy(heapBegin(), heapEnd());
+        this->free(heapBegin());
+    }
+}
+
+/*
+ * Calculate a new capacity that is at least lengthInc greater than
+ * curLength and check for overflow.
+ */
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::calculateNewCapacity(size_t curLength, size_t lengthInc,
+                                     size_t &newCap)
+{
+    size_t newMinCap = curLength + lengthInc;
+
+    /*
+     * Check for overflow in the above addition, below CEILING_LOG2, and later
+     * multiplication by sizeof(T).
+     */
+    if (newMinCap < curLength ||
+        newMinCap & tl::MulOverflowMask<2 * sizeof(T)>::result) {
+        this->reportAllocOverflow();
+        return false;
+    }
+
+    /* Round up to next power of 2. */
+    newCap = RoundUpPow2(newMinCap);
+
+    /*
+     * Do not allow a buffer large enough that the expression ((char *)end() -
+     * (char *)begin()) overflows ptrdiff_t. See Bug 510319.
+     */
+    if (newCap & tl::UnsafeRangeSizeMask<T>::result) {
+        this->reportAllocOverflow();
+        return false;
+    }
+    return true;
+}
+
+/*
+ * This function will grow the current heap capacity to have capacity
+ * (heapLength() + lengthInc) and fail on OOM or integer overflow.
+ */
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::growHeapStorageBy(size_t lengthInc)
+{
+    size_t newCap;
+    return calculateNewCapacity(heapLength(), lengthInc, newCap) &&
+           Impl::growTo(*this, newCap);
+}
+
+/*
+ * This function will create a new heap buffer with capacity (inlineLength() +
+ * lengthInc()), move all elements in the inline buffer to this new buffer,
+ * and fail on OOM or integer overflow.
+ */
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::convertToHeapStorage(size_t lengthInc)
+{
+    size_t newCap;
+    if (!calculateNewCapacity(inlineLength(), lengthInc, newCap))
+        return false;
+
+    /* Allocate buffer. */
+    T *newBuf = reinterpret_cast<T *>(this->malloc(newCap * sizeof(T)));
+    if (!newBuf)
+        return false;
+
+    /* Copy inline elements into heap buffer. */
+    size_t length = inlineLength();
+    Impl::copyConstruct(newBuf, inlineBegin(), inlineEnd());
+    Impl::destroy(inlineBegin(), inlineEnd());
+
+    /* Switch in heap buffer. */
+    mLengthOrCapacity = newCap;  /* marks us as !usingInlineStorage() */
+    heapBegin() = newBuf;
+    heapEnd() = newBuf + length;
+    return true;
+}
+
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::reserve(size_t request)
+{
+    ReentrancyGuard g(*this);
+    if (usingInlineStorage()) {
+        if (request > sInlineCapacity)
+            return convertToHeapStorage(request - inlineLength());
+    } else {
+        if (request > heapCapacity())
+            return growHeapStorageBy(request - heapLength());
+    }
+    return true;
+}
+
+template <class T, size_t N, class AP>
+inline void
+Vector<T,N,AP>::shrinkBy(size_t incr)
+{
+    ReentrancyGuard g(*this);
+    JS_ASSERT(incr <= length());
+    if (usingInlineStorage()) {
+        Impl::destroy(inlineEnd() - incr, inlineEnd());
+        inlineLength() -= incr;
+    } else {
+        Impl::destroy(heapEnd() - incr, heapEnd());
+        heapEnd() -= incr;
+    }
+}
+
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::growBy(size_t incr)
+{
+    ReentrancyGuard g(*this);
+    if (usingInlineStorage()) {
+        size_t freespace = sInlineCapacity - inlineLength();
+        if (incr <= freespace) {
+            T *newend = inlineEnd() + incr;
+            if (!tl::IsPodType<T>::result)
+                Impl::initialize(inlineEnd(), newend);
+            inlineLength() += incr;
+            JS_ASSERT(usingInlineStorage());
+            return true;
+        }
+        if (!convertToHeapStorage(incr))
+            return false;
+    }
+    else {
+        /* grow if needed */
+        size_t freespace = heapCapacity() - heapLength();
+        if (incr > freespace) {
+            if (!growHeapStorageBy(incr))
+                return false;
+        }
+    }
+
+    /* We are !usingInlineStorage(). Initialize new elements. */
+    JS_ASSERT(heapCapacity() - heapLength() >= incr);
+    T *newend = heapEnd() + incr;
+    if (!tl::IsPodType<T>::result)
+        Impl::initialize(heapEnd(), newend);
+    heapEnd() = newend;
+    return true;
+}
+
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::resize(size_t newLength)
+{
+    size_t curLength = length();
+    if (newLength > curLength)
+        return growBy(newLength - curLength);
+    shrinkBy(curLength - newLength);
+    return true;
+}
+
+template <class T, size_t N, class AP>
+inline void
+Vector<T,N,AP>::clear()
+{
+    ReentrancyGuard g(*this);
+    if (usingInlineStorage()) {
+        Impl::destroy(inlineBegin(), inlineEnd());
+        inlineLength() = 0;
+    }
+    else {
+        Impl::destroy(heapBegin(), heapEnd());
+        heapEnd() = heapBegin();
+    }
+}
+
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::append(const T &t)
+{
+    ReentrancyGuard g(*this);
+    if (usingInlineStorage()) {
+        if (inlineLength() < sInlineCapacity) {
+            new(inlineEnd()) T(t);
+            ++inlineLength();
+            JS_ASSERT(usingInlineStorage());
+            return true;
+        }
+        if (!convertToHeapStorage(1))
+            return false;
+    } else {
+        if (heapLength() == heapCapacity() && !growHeapStorageBy(1))
+            return false;
+    }
+
+    /* We are !usingInlineStorage(). Initialize new elements. */
+    JS_ASSERT(heapLength() <= heapCapacity() && heapCapacity() - heapLength() >= 1);
+    new(heapEnd()++) T(t);
+    return true;
+}
+
+template <class T, size_t N, class AP>
+inline bool
+Vector<T,N,AP>::appendN(const T &t, size_t needed)
+{
+    ReentrancyGuard g(*this);
+    if (usingInlineStorage()) {
+        size_t freespace = sInlineCapacity - inlineLength();
+        if (needed <= freespace) {
+            Impl::copyConstructN(inlineEnd(), needed, t);
+            inlineLength() += needed;
+            JS_ASSERT(usingInlineStorage());
+            return true;
+        }
+        if (!convertToHeapStorage(needed))
+            return false;
+    } else {
+        size_t freespace = heapCapacity() - heapLength();
+        if (needed > freespace && !growHeapStorageBy(needed))
+            return false;
+    }
+
+    /* We are !usingInlineStorage(). Initialize new elements. */
+    JS_ASSERT(heapLength() <= heapCapacity() && heapCapacity() - heapLength() >= needed);
+    Impl::copyConstructN(heapEnd(), needed, t);
+    heapEnd() += needed;
+    return true;
+}
+
+template <class T, size_t N, class AP>
+template <class U>
+inline bool
+Vector<T,N,AP>::append(const U *insBegin, const U *insEnd)
+{
+    ReentrancyGuard g(*this);
+    size_t needed = PointerRangeSize(insBegin, insEnd);
+    if (usingInlineStorage()) {
+        size_t freespace = sInlineCapacity - inlineLength();
+        if (needed <= freespace) {
+            Impl::copyConstruct(inlineEnd(), insBegin, insEnd);
+            inlineLength() += needed;
+            JS_ASSERT(usingInlineStorage());
+            return true;
+        }
+        if (!convertToHeapStorage(needed))
+            return false;
+    } else {
+        size_t freespace = heapCapacity() - heapLength();
+        if (needed > freespace && !growHeapStorageBy(needed))
+            return false;
+    }
+
+    /* We are !usingInlineStorage(). Initialize new elements. */
+    JS_ASSERT(heapLength() <= heapCapacity() && heapCapacity() - heapLength() >= needed);
+    Impl::copyConstruct(heapEnd(), insBegin, insEnd);
+    heapEnd() += needed;
+    return true;
+}
+
+template <class T, size_t N, class AP>
+template <class U>
+inline bool
+Vector<T,N,AP>::append(const U *insBegin, size_t length)
+{
+    return this->append(insBegin, insBegin + length);
+}
+
+template <class T, size_t N, class AP>
+inline void
+Vector<T,N,AP>::popBack()
+{
+    ReentrancyGuard g(*this);
+    JS_ASSERT(!empty());
+    if (usingInlineStorage()) {
+        --inlineLength();
+        inlineEnd()->~T();
+    } else {
+        --heapEnd();
+        heapEnd()->~T();
+    }
+}
+
+template <class T, size_t N, class AP>
+inline T *
+Vector<T,N,AP>::extractRawBuffer()
+{
+    if (usingInlineStorage()) {
+        T *ret = reinterpret_cast<T *>(this->malloc(inlineLength() * sizeof(T)));
+        if (!ret)
+            return NULL;
+        Impl::copyConstruct(ret, inlineBegin(), inlineEnd());
+        Impl::destroy(inlineBegin(), inlineEnd());
+        inlineLength() = 0;
+        return ret;
+    }
+
+    T *ret = heapBegin();
+    mLengthOrCapacity = 0;  /* marks us as !usingInlineStorage() */
+    return ret;
+}
+
+template <class T, size_t N, class AP>
+inline void
+Vector<T,N,AP>::replaceRawBuffer(T *p, size_t length)
+{
+    ReentrancyGuard g(*this);
+
+    /* Destroy what we have. */
+    if (usingInlineStorage()) {
+        Impl::destroy(inlineBegin(), inlineEnd());
+        inlineLength() = 0;
+    } else {
+        Impl::destroy(heapBegin(), heapEnd());
+        this->free(heapBegin());
+    }
+
+    /* Take in the new buffer. */
+    if (length <= sInlineCapacity) {
+        /*
+         * (mLengthOrCapacity <= sInlineCapacity) means inline storage, so we
+         * MUST use inline storage, even though p might otherwise be acceptable.
+         */
+        mLengthOrCapacity = length;  /* marks us as usingInlineStorage() */
+        Impl::copyConstruct(inlineBegin(), p, p + length);
+        Impl::destroy(p, p + length);
+        this->free(p);
+    } else {
+        mLengthOrCapacity = length;  /* marks us as !usingInlineStorage() */
+        heapBegin() = p;
+        heapEnd() = heapBegin() + length;
+    }
+}
+
+}  /* namespace js */
+
+#endif /* jsvector_h_ */