author Matt Brubeck <mbrubeck@mozilla.com>
Thu, 27 Dec 2012 14:52:04 -0800
changeset 126214 f2a500997116e854815a068ea70c6a6b74759d1b
parent 126193 de5db0c4c3ffb5a4e22e5ea4a9c60532e2e78b03
child 126568 e024dfa5a77431f5bd48a4898face9042f9b3055
permissions -rw-r--r--
Back out de5db0c4c3ff and ff14e0b88c10 (bug 820124) because of intermittent xpcshell assertions

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * vim: set ts=4 sw=4 et tw=99 ft=cpp:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef RegExpStatics_h__
#define RegExpStatics_h__

#include "jscntxt.h"

#include "gc/Barrier.h"
#include "gc/Marking.h"
#include "js/Vector.h"

#include "vm/MatchPairs.h"

namespace js {

class RegExpStatics
    /* The latest RegExp output, set after execution. */
    VectorMatchPairs        matches;
    HeapPtr<JSLinearString> matchesInput;

    /* The previous RegExp input, used to resolve lazy state. */
    HeapPtr<RegExpObject>   regexp;
    size_t                  lastIndex;

    /* The latest RegExp input, set before execution. */
    HeapPtr<JSString>       pendingInput;
    RegExpFlag              flags;

     * If true, |matchesInput|, |regexp|, and |lastIndex| may be used
     * to replay the last executed RegExp, and |matches| is invalid.
    bool                    pendingLazyEvaluation;

    /* Linkage for preserving RegExpStatics during nested RegExp execution. */
    RegExpStatics           *bufferLink;
    bool                    copied;

    bool executeLazy(JSContext *cx);

    inline void aboutToWrite();
    inline void copyTo(RegExpStatics &dst);

    inline void restore();
    bool save(JSContext *cx, RegExpStatics *buffer) {
        JS_ASSERT(!buffer->copied && !buffer->bufferLink);
        buffer->bufferLink = bufferLink;
        bufferLink = buffer;
        if (!buffer->matches.allocOrExpandArray(matches.length())) {
            return false;
        return true;

    inline void checkInvariants();

     * Check whether the index at |checkValidIndex| is valid (>= 0).
     * If so, construct a string for it and place it in |*out|.
     * If not, place undefined in |*out|.
    bool makeMatch(JSContext *cx, size_t checkValidIndex, size_t pairNum, Value *out);
    bool createDependent(JSContext *cx, size_t start, size_t end, Value *out);

    void markFlagsSet(JSContext *cx);

    struct InitBuffer {};
    explicit RegExpStatics(InitBuffer) : bufferLink(NULL), copied(false) {}

    friend class PreserveRegExpStatics;

    inline RegExpStatics();

    static JSObject *create(JSContext *cx, GlobalObject *parent);

    /* Mutators. */

    inline void updateLazily(JSContext *cx, JSLinearString *input,
                             RegExpObject *regexp, size_t lastIndex);
    inline bool updateFromMatchPairs(JSContext *cx, JSLinearString *input, MatchPairs &newPairs);
    inline void setMultiline(JSContext *cx, bool enabled);

    inline void clear();

    /* Corresponds to JSAPI functionality to set the pending RegExp input. */
    inline void reset(JSContext *cx, JSString *newInput, bool newMultiline);

    inline void setPendingInput(JSString *newInput);

    /* Default match accessor. */
    const MatchPairs &getMatches() const {
        /* Safe: only used by String methods, which do not set lazy mode. */
        return matches;

    JSString *getPendingInput() const { return pendingInput; }

    RegExpFlag getFlags() const { return flags; }
    bool multiline() const { return flags & MultilineFlag; }

    /* Returns whether results for a non-empty match are present. */
    bool matched() const {
        /* Safe: only used by String methods, which do not set lazy mode. */
        JS_ASSERT(matches.pairCount() > 0);
        return matches[0].limit - matches[0].start > 0;

    void mark(JSTracer *trc) {
        if (regexp)
            gc::MarkObject(trc, &regexp, "res->regexp");
        if (pendingInput)
            MarkString(trc, &pendingInput, "res->pendingInput");
        if (matchesInput)
            MarkString(trc, &matchesInput, "res->matchesInput");

    /* Value creators. */

    bool createPendingInput(JSContext *cx, Value *out);
    bool createLastMatch(JSContext *cx, Value *out);
    bool createLastParen(JSContext *cx, Value *out);
    bool createParen(JSContext *cx, size_t pairNum, Value *out);
    bool createLeftContext(JSContext *cx, Value *out);
    bool createRightContext(JSContext *cx, Value *out);

    /* Infallible substring creators. */

    void getParen(size_t pairNum, JSSubString *out) const;
    void getLastMatch(JSSubString *out) const;
    void getLastParen(JSSubString *out) const;
    void getLeftContext(JSSubString *out) const;
    void getRightContext(JSSubString *out) const;

    /* PreserveRegExpStatics helpers. */

    class AutoRooter : private AutoGCRooter
        explicit AutoRooter(JSContext *cx, RegExpStatics *statics_
          : AutoGCRooter(cx, REGEXPSTATICS), statics(statics_), skip(cx, statics_)

        friend void AutoGCRooter::trace(JSTracer *trc);
        void trace(JSTracer *trc);

        RegExpStatics *statics;
        SkipRoot skip;

class PreserveRegExpStatics
    RegExpStatics * const original;
    RegExpStatics buffer;
    RegExpStatics::AutoRooter bufferRoot;

    explicit PreserveRegExpStatics(JSContext *cx, RegExpStatics *original)
     : original(original),
       bufferRoot(cx, &buffer)

    bool init(JSContext *cx) {
        return original->save(cx, &buffer);

    inline ~PreserveRegExpStatics();

size_t SizeOfRegExpStaticsData(const JSObject *obj, JSMallocSizeOfFun mallocSizeOf);

} /* namespace js */

#endif /* RegExpStatics_h__ */