Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* 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
#ifndef vm_MatchPairs_h
#define vm_MatchPairs_h
#include "js/AllocPolicy.h"
#include "js/Vector.h"
/*
* RegExp match results are succinctly represented by pairs of integer
* indices delimiting (start, limit] segments of the input string.
*
* The pair count for a given RegExp match is the capturing parentheses
* count plus one for the "0 capturing paren" whole text match.
*/
namespace js {
struct MatchPair final {
int32_t start;
int32_t limit;
static constexpr int32_t NoMatch = -1;
MatchPair() : start(NoMatch), limit(NoMatch) {}
MatchPair(int32_t start, int32_t limit) : start(start), limit(limit) {}
size_t length() const {
MOZ_ASSERT(!isUndefined());
return limit - start;
}
bool isUndefined() const { return start < 0; }
inline bool check() const {
MOZ_ASSERT(limit >= start);
MOZ_ASSERT_IF(start < 0, start == NoMatch);
MOZ_ASSERT_IF(limit < 0, limit == NoMatch);
return true;
}
// Note: return int32_t instead of size_t to prevent signed => unsigned
// conversions in caller functions.
static constexpr int32_t offsetOfStart() {
return int32_t(offsetof(MatchPair, start));
}
static constexpr int32_t offsetOfLimit() {
return int32_t(offsetof(MatchPair, limit));
}
};
// MachPairs is used as base class for VectorMatchPairs but can also be
// stack-allocated (without a Vector) in JIT code.
class MatchPairs {
protected:
/* Length of pairs_. */
uint32_t pairCount_;
/* Raw pointer into an allocated MatchPair buffer. */
MatchPair* pairs_;
protected:
/* Not used directly: use VectorMatchPairs. */
MatchPairs() : pairCount_(0), pairs_(nullptr) {}
protected:
/* Functions used by friend classes. */
friend class RegExpShared;
friend class RegExpStatics;
void forgetArray() { pairs_ = nullptr; }
public:
void checkAgainst(size_t inputLength) {
#ifdef DEBUG
for (size_t i = 0; i < pairCount_; i++) {
const MatchPair& p = (*this)[i];
MOZ_ASSERT(p.check());
if (p.isUndefined()) {
continue;
}
MOZ_ASSERT(size_t(p.limit) <= inputLength);
}
#endif
}
/* Querying functions in the style of RegExpStatics. */
bool empty() const { return pairCount_ == 0; }
size_t pairCount() const {
MOZ_ASSERT(pairCount_ > 0);
return pairCount_;
}
// Note: return int32_t instead of size_t to prevent signed => unsigned
// conversions in caller functions.
static constexpr int32_t offsetOfPairs() {
return int32_t(offsetof(MatchPairs, pairs_));
}
static constexpr int32_t offsetOfPairCount() {
return int32_t(offsetof(MatchPairs, pairCount_));
}
int32_t* pairsRaw() { return reinterpret_cast<int32_t*>(pairs_); }
public:
size_t length() const { return pairCount_; }
const MatchPair& operator[](size_t i) const {
MOZ_ASSERT(i < pairCount_);
return pairs_[i];
}
MatchPair& operator[](size_t i) {
MOZ_ASSERT(i < pairCount_);
return pairs_[i];
}
};
class VectorMatchPairs : public MatchPairs {
Vector<MatchPair, 10, SystemAllocPolicy> vec_;
protected:
friend class RegExpShared;
friend class RegExpStatics;
/* MatchPair buffer allocator: set pairs_ and pairCount_. */
bool allocOrExpandArray(size_t pairCount);
bool initArrayFrom(VectorMatchPairs& copyFrom);
size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
return vec_.sizeOfExcludingThis(mallocSizeOf);
}
};
} /* namespace js */
#endif /* vm_MatchPairs_h */