1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/* -*- 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
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef vm_MatchPairs_h
#define vm_MatchPairs_h
#include "ds/LifoAlloc.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;
}
};
// 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_;
}
static size_t offsetOfPairs() { return offsetof(MatchPairs, pairs_); }
static size_t offsetOfPairCount() { return 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);
};
} /* namespace js */
#endif /* vm_MatchPairs_h */
|
