1	/*
2	* Copyright (C) 2009, 2013-2017 Apple Inc. All rights reserved.
3	* Copyright (C) 2010 Peter Varga (pvarga@inf.u-szeged.hu), University of Szeged
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
18	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25	*/
26
27	#include "config.h"
28	#include "YarrInterpreter.h"
29
30	#include "Options.h"
31	#include "SuperSampler.h"
32	#include "Yarr.h"
33	#include "YarrCanonicalize.h"
34	#include <wtf/BumpPointerAllocator.h>
35	#include <wtf/CheckedArithmetic.h>
36	#include <wtf/DataLog.h>
37	#include <wtf/StdLibExtras.h>
38	#include <wtf/text/CString.h>
39	#include <wtf/text/WTFString.h>
40
41	namespace JSC { namespace Yarr {
42
43	template<typename CharType>
44	class Interpreter {
45	public:
46	struct ParenthesesDisjunctionContext;
47
48	struct BackTrackInfoParentheses {
49	uintptr_t matchAmount;
50	ParenthesesDisjunctionContext* lastContext;
51	};
52
53	static inline void appendParenthesesDisjunctionContext(BackTrackInfoParentheses* backTrack, ParenthesesDisjunctionContext* context)
54	{
55	context->next = backTrack->lastContext;
56	backTrack->lastContext = context;
57	++backTrack->matchAmount;
58	}
59
60	static inline void popParenthesesDisjunctionContext(BackTrackInfoParentheses* backTrack)
61	{
62	RELEASE_ASSERT(backTrack->matchAmount);
63	RELEASE_ASSERT(backTrack->lastContext);
64	backTrack->lastContext = backTrack->lastContext->next;
65	--backTrack->matchAmount;
66	}
67
68	struct DisjunctionContext
69	{
70	DisjunctionContext() = default;
71
72	void* operator new(size_t, void* where)
73	{
74	return where;
75	}
76
77	static size_t allocationSize(unsigned numberOfFrames)
78	{
79	static_assert(alignof(DisjunctionContext) <= sizeof(void*), "");
80	size_t rawSize = (sizeof(DisjunctionContext) - sizeof(uintptr_t) + Checked<size_t>(numberOfFrames) * sizeof(uintptr_t)).unsafeGet();
81	size_t roundedSize = WTF::roundUpToMultipleOf<sizeof(void*)>(x: rawSize);
82	RELEASE_ASSERT(roundedSize >= rawSize);
83	return roundedSize;
84	}
85
86	int term { 0 };
87	unsigned matchBegin;
88	unsigned matchEnd;
89	uintptr_t frame[1];
90	};
91
92	DisjunctionContext* allocDisjunctionContext(ByteDisjunction* disjunction)
93	{
94	size_t size = DisjunctionContext::allocationSize(disjunction->m_frameSize);
95	allocatorPool = allocatorPool->ensureCapacity(size);
96	RELEASE_ASSERT(allocatorPool);
97	return new (allocatorPool->alloc(size)) DisjunctionContext();
98	}
99
100	void freeDisjunctionContext(DisjunctionContext* context)
101	{
102	allocatorPool = allocatorPool->dealloc(position: context);
103	}
104
105	struct ParenthesesDisjunctionContext
106	{
107	ParenthesesDisjunctionContext(unsigned* output, ByteTerm& term)
108	{
109	unsigned firstSubpatternId = term.atom.subpatternId;
110	unsigned numNestedSubpatterns = term.atom.parenthesesDisjunction->m_numSubpatterns;
111
112	for (unsigned i = 0; i < (numNestedSubpatterns << 1); ++i) {
113	subpatternBackup[i] = output[(firstSubpatternId << 1) + i];
114	output[(firstSubpatternId << 1) + i] = offsetNoMatch;
115	}
116
117	new (getDisjunctionContext(term)) DisjunctionContext();
118	}
119
120	void* operator new(size_t, void* where)
121	{
122	return where;
123	}
124
125	void restoreOutput(unsigned* output, unsigned firstSubpatternId, unsigned numNestedSubpatterns)
126	{
127	for (unsigned i = 0; i < (numNestedSubpatterns << 1); ++i)
128	output[(firstSubpatternId << 1) + i] = subpatternBackup[i];
129	}
130
131	DisjunctionContext* getDisjunctionContext(ByteTerm& term)
132	{
133	return bitwise_cast<DisjunctionContext*>(bitwise_cast<uintptr_t>(this) + allocationSize(numberOfSubpatterns: term.atom.parenthesesDisjunction->m_numSubpatterns));
134	}
135
136	static size_t allocationSize(unsigned numberOfSubpatterns)
137	{
138	static_assert(alignof(ParenthesesDisjunctionContext) <= sizeof(void*), "");
139	size_t rawSize = (sizeof(ParenthesesDisjunctionContext) - sizeof(unsigned) + (Checked<size_t>(numberOfSubpatterns) * 2U) * sizeof(unsigned)).unsafeGet();
140	size_t roundedSize = WTF::roundUpToMultipleOf<sizeof(void*)>(x: rawSize);
141	RELEASE_ASSERT(roundedSize >= rawSize);
142	return roundedSize;
143	}
144
145	ParenthesesDisjunctionContext* next { nullptr };
146	unsigned subpatternBackup[1];
147	};
148
149	ParenthesesDisjunctionContext* allocParenthesesDisjunctionContext(ByteDisjunction* disjunction, unsigned* output, ByteTerm& term)
150	{
151	size_t size = (Checked<size_t>(ParenthesesDisjunctionContext::allocationSize(term.atom.parenthesesDisjunction->m_numSubpatterns)) + DisjunctionContext::allocationSize(disjunction->m_frameSize)).unsafeGet();
152	allocatorPool = allocatorPool->ensureCapacity(size);
153	RELEASE_ASSERT(allocatorPool);
154	return new (allocatorPool->alloc(size)) ParenthesesDisjunctionContext(output, term);
155	}
156
157	void freeParenthesesDisjunctionContext(ParenthesesDisjunctionContext* context)
158	{
159	allocatorPool = allocatorPool->dealloc(position: context);
160	}
161
162	class InputStream {
163	public:
164	InputStream(const CharType* input, unsigned start, unsigned length, bool decodeSurrogatePairs)
165	: input(input)
166	, pos(start)
167	, length(length)
168	, decodeSurrogatePairs(decodeSurrogatePairs)
169	{
170	}
171
172	void next()
173	{
174	++pos;
175	}
176
177	void rewind(unsigned amount)
178	{
179	ASSERT(pos >= amount);
180	pos -= amount;
181	}
182
183	int read()
184	{
185	ASSERT(pos < length);
186	if (pos < length)
187	return input[pos];
188	return -1;
189	}
190
191	int readPair()
192	{
193	ASSERT(pos + 1 < length);
194	return input[pos] | input[pos + 1] << 16;
195	}
196
197	int readChecked(unsigned negativePositionOffest)
198	{
199	RELEASE_ASSERT(pos >= negativePositionOffest);
200	unsigned p = pos - negativePositionOffest;
201	ASSERT(p < length);
202	int result = input[p];
203	if (U16_IS_LEAD(result) && decodeSurrogatePairs && p + 1 < length && U16_IS_TRAIL(input[p + 1])) {
204	if (atEnd())
205	return -1;
206
207	result = U16_GET_SUPPLEMENTARY(result, input[p + 1]);
208	next();
209	}
210	return result;
211	}
212
213	int readSurrogatePairChecked(unsigned negativePositionOffset)
214	{
215	RELEASE_ASSERT(pos >= negativePositionOffset);
216	unsigned p = pos - negativePositionOffset;
217	ASSERT(p < length);
218	if (p + 1 >= length)
219	return -1;
220
221	int first = input[p];
222	int second = input[p + 1];
223	if (U16_IS_LEAD(first) && U16_IS_TRAIL(second))
224	return U16_GET_SUPPLEMENTARY(first, second);
225
226	return -1;
227	}
228
229	int reread(unsigned from)
230	{
231	ASSERT(from < length);
232	int result = input[from];
233	if (U16_IS_LEAD(result) && decodeSurrogatePairs && from + 1 < length && U16_IS_TRAIL(input[from + 1]))
234	result = U16_GET_SUPPLEMENTARY(result, input[from + 1]);
235	return result;
236	}
237
238	int prev()
239	{
240	ASSERT(!(pos > length));
241	if (pos && length)
242	return input[pos - 1];
243	return -1;
244	}
245
246	unsigned getPos()
247	{
248	return pos;
249	}
250
251	void setPos(unsigned p)
252	{
253	pos = p;
254	}
255
256	bool atStart()
257	{
258	return pos == 0;
259	}
260
261	bool atEnd()
262	{
263	return pos == length;
264	}
265
266	unsigned end()
267	{
268	return length;
269	}
270
271	bool checkInput(unsigned count)
272	{
273	if (((pos + count) <= length) && ((pos + count) >= pos)) {
274	pos += count;
275	return true;
276	}
277	return false;
278	}
279
280	void uncheckInput(unsigned count)
281	{
282	RELEASE_ASSERT(pos >= count);
283	pos -= count;
284	}
285
286	bool atStart(unsigned negativePositionOffset)
287	{
288	return pos == negativePositionOffset;
289	}
290
291	bool atEnd(unsigned negativePositionOffest)
292	{
293	RELEASE_ASSERT(pos >= negativePositionOffest);
294	return (pos - negativePositionOffest) == length;
295	}
296
297	bool isAvailableInput(unsigned offset)
298	{
299	return (((pos + offset) <= length) && ((pos + offset) >= pos));
300	}
301
302	private:
303	const CharType* input;
304	unsigned pos;
305	unsigned length;
306	bool decodeSurrogatePairs;
307	};
308
309	bool testCharacterClass(CharacterClass* characterClass, int ch)
310	{
311	auto linearSearchMatches = [&ch](const Vector<UChar32>& matches) {
312	for (unsigned i = 0; i < matches.size(); ++i) {
313	if (ch == matches[i])
314	return true;
315	}
316
317	return false;
318	};
319
320	auto binarySearchMatches = [&ch](const Vector<UChar32>& matches) {
321	size_t low = 0;
322	size_t high = matches.size() - 1;
323
324	while (low <= high) {
325	size_t mid = low + (high - low) / 2;
326	int diff = ch - matches[mid];
327	if (!diff)
328	return true;
329
330	if (diff < 0) {
331	if (mid == low)
332	return false;
333	high = mid - 1;
334	} else
335	low = mid + 1;
336	}
337	return false;
338	};
339
340	auto linearSearchRanges = [&ch](const Vector<CharacterRange>& ranges) {
341	for (unsigned i = 0; i < ranges.size(); ++i) {
342	if ((ch >= ranges[i].begin) && (ch <= ranges[i].end))
343	return true;
344	}
345
346	return false;
347	};
348
349	auto binarySearchRanges = [&ch](const Vector<CharacterRange>& ranges) {
350	size_t low = 0;
351	size_t high = ranges.size() - 1;
352
353	while (low <= high) {
354	size_t mid = low + (high - low) / 2;
355	int rangeBeginDiff = ch - ranges[mid].begin;
356	if (rangeBeginDiff >= 0 && ch <= ranges[mid].end)
357	return true;
358
359	if (rangeBeginDiff < 0) {
360	if (mid == low)
361	return false;
362	high = mid - 1;
363	} else
364	low = mid + 1;
365	}
366	return false;
367	};
368
369	if (characterClass->m_anyCharacter)
370	return true;
371
372	const size_t thresholdForBinarySearch = 6;
373
374	if (!isASCII(c: ch)) {
375	if (characterClass->m_matchesUnicode.size()) {
376	if (characterClass->m_matchesUnicode.size() > thresholdForBinarySearch) {
377	if (binarySearchMatches(characterClass->m_matchesUnicode))
378	return true;
379	} else if (linearSearchMatches(characterClass->m_matchesUnicode))
380	return true;
381	}
382
383	if (characterClass->m_rangesUnicode.size()) {
384	if (characterClass->m_rangesUnicode.size() > thresholdForBinarySearch) {
385	if (binarySearchRanges(characterClass->m_rangesUnicode))
386	return true;
387	} else if (linearSearchRanges(characterClass->m_rangesUnicode))
388	return true;
389	}
390	} else {
391	if (characterClass->m_matches.size()) {
392	if (characterClass->m_matches.size() > thresholdForBinarySearch) {
393	if (binarySearchMatches(characterClass->m_matches))
394	return true;
395	} else if (linearSearchMatches(characterClass->m_matches))
396	return true;
397	}
398
399	if (characterClass->m_ranges.size()) {
400	if (characterClass->m_ranges.size() > thresholdForBinarySearch) {
401	if (binarySearchRanges(characterClass->m_ranges))
402	return true;
403	} else if (linearSearchRanges(characterClass->m_ranges))
404	return true;
405	}
406	}
407
408	return false;
409	}
410
411	bool checkCharacter(int testChar, unsigned negativeInputOffset)
412	{
413	return testChar == input.readChecked(negativeInputOffset);
414	}
415
416	bool checkSurrogatePair(int testUnicodeChar, unsigned negativeInputOffset)
417	{
418	return testUnicodeChar == input.readSurrogatePairChecked(negativeInputOffset);
419	}
420
421	bool checkCasedCharacter(int loChar, int hiChar, unsigned negativeInputOffset)
422	{
423	int ch = input.readChecked(negativeInputOffset);
424	return (loChar == ch) || (hiChar == ch);
425	}
426
427	bool checkCharacterClass(CharacterClass* characterClass, bool invert, unsigned negativeInputOffset)
428	{
429	bool match = testCharacterClass(characterClass, ch: input.readChecked(negativeInputOffset));
430	return invert ? !match : match;
431	}
432
433	bool tryConsumeBackReference(int matchBegin, int matchEnd, unsigned negativeInputOffset)
434	{
435	unsigned matchSize = (unsigned)(matchEnd - matchBegin);
436
437	if (!input.checkInput(matchSize))
438	return false;
439
440	for (unsigned i = 0; i < matchSize; ++i) {
441	int oldCh = input.reread(matchBegin + i);
442	int ch;
443	if (!U_IS_BMP(oldCh)) {
444	ch = input.readSurrogatePairChecked(negativeInputOffset + matchSize - i);
445	++i;
446	} else
447	ch = input.readChecked(negativeInputOffset + matchSize - i);
448
449	if (oldCh == ch)
450	continue;
451
452	if (pattern->ignoreCase()) {
453	// See ES 6.0, 21.2.2.8.2 for the definition of Canonicalize(). For non-Unicode
454	// patterns, Unicode values are never allowed to match against ASCII ones.
455	// For Unicode, we need to check all canonical equivalents of a character.
456	if (!unicode && (isASCII(c: oldCh) || isASCII(c: ch))) {
457	if (toASCIIUpper(c: oldCh) == toASCIIUpper(c: ch))
458	continue;
459	} else if (areCanonicallyEquivalent(a: oldCh, b: ch, canonicalMode: unicode ? CanonicalMode::Unicode : CanonicalMode::UCS2))
460	continue;
461	}
462
463	input.uncheckInput(matchSize);
464	return false;
465	}
466
467	return true;
468	}
469
470	bool matchAssertionBOL(ByteTerm& term)
471	{
472	return (input.atStart(term.inputPosition)) || (pattern->multiline() && testCharacterClass(characterClass: pattern->newlineCharacterClass, ch: input.readChecked(term.inputPosition + 1)));
473	}
474
475	bool matchAssertionEOL(ByteTerm& term)
476	{
477	if (term.inputPosition)
478	return (input.atEnd(term.inputPosition)) || (pattern->multiline() && testCharacterClass(characterClass: pattern->newlineCharacterClass, ch: input.readChecked(term.inputPosition)));
479
480	return (input.atEnd()) || (pattern->multiline() && testCharacterClass(characterClass: pattern->newlineCharacterClass, ch: input.read()));
481	}
482
483	bool matchAssertionWordBoundary(ByteTerm& term)
484	{
485	bool prevIsWordchar = !input.atStart(term.inputPosition) && testCharacterClass(characterClass: pattern->wordcharCharacterClass, ch: input.readChecked(term.inputPosition + 1));
486	bool readIsWordchar;
487	if (term.inputPosition)
488	readIsWordchar = !input.atEnd(term.inputPosition) && testCharacterClass(characterClass: pattern->wordcharCharacterClass, ch: input.readChecked(term.inputPosition));
489	else
490	readIsWordchar = !input.atEnd() && testCharacterClass(characterClass: pattern->wordcharCharacterClass, ch: input.read());
491
492	bool wordBoundary = prevIsWordchar != readIsWordchar;
493	return term.invert() ? !wordBoundary : wordBoundary;
494	}
495
496	bool backtrackPatternCharacter(ByteTerm& term, DisjunctionContext* context)
497	{
498	BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + term.frameLocation);
499
500	switch (term.atom.quantityType) {
501	case QuantifierFixedCount:
502	break;
503
504	case QuantifierGreedy:
505	if (backTrack->matchAmount) {
506	--backTrack->matchAmount;
507	input.uncheckInput(U16_LENGTH(term.atom.patternCharacter));
508	return true;
509	}
510	break;
511
512	case QuantifierNonGreedy:
513	if ((backTrack->matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {
514	++backTrack->matchAmount;
515	if (checkCharacter(testChar: term.atom.patternCharacter, negativeInputOffset: term.inputPosition + 1))
516	return true;
517	}
518	input.setPos(backTrack->begin);
519	break;
520	}
521
522	return false;
523	}
524
525	bool backtrackPatternCasedCharacter(ByteTerm& term, DisjunctionContext* context)
526	{
527	BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + term.frameLocation);
528
529	switch (term.atom.quantityType) {
530	case QuantifierFixedCount:
531	break;
532
533	case QuantifierGreedy:
534	if (backTrack->matchAmount) {
535	--backTrack->matchAmount;
536	input.uncheckInput(1);
537	return true;
538	}
539	break;
540
541	case QuantifierNonGreedy:
542	if ((backTrack->matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {
543	++backTrack->matchAmount;
544	if (checkCasedCharacter(loChar: term.atom.casedCharacter.lo, hiChar: term.atom.casedCharacter.hi, negativeInputOffset: term.inputPosition + 1))
545	return true;
546	}
547	input.uncheckInput(backTrack->matchAmount);
548	break;
549	}
550
551	return false;
552	}
553
554	bool matchCharacterClass(ByteTerm& term, DisjunctionContext* context)
555	{
556	ASSERT(term.type == ByteTerm::TypeCharacterClass);
557	BackTrackInfoCharacterClass* backTrack = reinterpret_cast<BackTrackInfoCharacterClass*>(context->frame + term.frameLocation);
558
559	switch (term.atom.quantityType) {
560	case QuantifierFixedCount: {
561	if (unicode) {
562	backTrack->begin = input.getPos();
563	unsigned matchAmount = 0;
564	for (matchAmount = 0; matchAmount < term.atom.quantityMaxCount; ++matchAmount) {
565	if (!checkCharacterClass(characterClass: term.atom.characterClass, invert: term.invert(), negativeInputOffset: term.inputPosition - matchAmount)) {
566	input.setPos(backTrack->begin);
567	return false;
568	}
569	}
570
571	return true;
572	}
573
574	for (unsigned matchAmount = 0; matchAmount < term.atom.quantityMaxCount; ++matchAmount) {
575	if (!checkCharacterClass(characterClass: term.atom.characterClass, invert: term.invert(), negativeInputOffset: term.inputPosition - matchAmount))
576	return false;
577	}
578	return true;
579	}
580
581	case QuantifierGreedy: {
582	unsigned position = input.getPos();
583	backTrack->begin = position;
584	unsigned matchAmount = 0;
585	while ((matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {
586	if (!checkCharacterClass(characterClass: term.atom.characterClass, invert: term.invert(), negativeInputOffset: term.inputPosition + 1)) {
587	input.setPos(position);
588	break;
589	}
590	++matchAmount;
591	position = input.getPos();
592	}
593	backTrack->matchAmount = matchAmount;
594
595	return true;
596	}
597
598	case QuantifierNonGreedy:
599	backTrack->begin = input.getPos();
600	backTrack->matchAmount = 0;
601	return true;
602	}
603
604	RELEASE_ASSERT_NOT_REACHED();
605	return false;
606	}
607
608	bool backtrackCharacterClass(ByteTerm& term, DisjunctionContext* context)
609	{
610	ASSERT(term.type == ByteTerm::TypeCharacterClass);
611	BackTrackInfoCharacterClass* backTrack = reinterpret_cast<BackTrackInfoCharacterClass*>(context->frame + term.frameLocation);
612
613	switch (term.atom.quantityType) {
614	case QuantifierFixedCount:
615	if (unicode)
616	input.setPos(backTrack->begin);
617	break;
618
619	case QuantifierGreedy:
620	if (backTrack->matchAmount) {
621	if (unicode) {
622	// Rematch one less match
623	input.setPos(backTrack->begin);
624	--backTrack->matchAmount;
625	for (unsigned matchAmount = 0; (matchAmount < backTrack->matchAmount) && input.checkInput(1); ++matchAmount) {
626	if (!checkCharacterClass(characterClass: term.atom.characterClass, invert: term.invert(), negativeInputOffset: term.inputPosition + 1)) {
627	input.uncheckInput(1);
628	break;
629	}
630	}
631	return true;
632	}
633	--backTrack->matchAmount;
634	input.uncheckInput(1);
635	return true;
636	}
637	break;
638
639	case QuantifierNonGreedy:
640	if ((backTrack->matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {
641	++backTrack->matchAmount;
642	if (checkCharacterClass(characterClass: term.atom.characterClass, invert: term.invert(), negativeInputOffset: term.inputPosition + 1))
643	return true;
644	}
645	input.setPos(backTrack->begin);
646	break;
647	}
648
649	return false;
650	}
651
652	bool matchBackReference(ByteTerm& term, DisjunctionContext* context)
653	{
654	ASSERT(term.type == ByteTerm::TypeBackReference);
655	BackTrackInfoBackReference* backTrack = reinterpret_cast<BackTrackInfoBackReference*>(context->frame + term.frameLocation);
656
657	unsigned matchBegin = output[(term.atom.subpatternId << 1)];
658	unsigned matchEnd = output[(term.atom.subpatternId << 1) + 1];
659
660	// If the end position of the referenced match hasn't set yet then the backreference in the same parentheses where it references to that.
661	// In this case the result of match is empty string like when it references to a parentheses with zero-width match.
662	// Eg.: /(a\1)/
663	if (matchEnd == offsetNoMatch)
664	return true;
665
666	if (matchBegin == offsetNoMatch)
667	return true;
668
669	ASSERT(matchBegin <= matchEnd);
670
671	if (matchBegin == matchEnd)
672	return true;
673
674	switch (term.atom.quantityType) {
675	case QuantifierFixedCount: {
676	backTrack->begin = input.getPos();
677	for (unsigned matchAmount = 0; matchAmount < term.atom.quantityMaxCount; ++matchAmount) {
678	if (!tryConsumeBackReference(matchBegin, matchEnd, negativeInputOffset: term.inputPosition)) {
679	input.setPos(backTrack->begin);
680	return false;
681	}
682	}
683	return true;
684	}
685
686	case QuantifierGreedy: {
687	unsigned matchAmount = 0;
688	while ((matchAmount < term.atom.quantityMaxCount) && tryConsumeBackReference(matchBegin, matchEnd, negativeInputOffset: term.inputPosition))
689	++matchAmount;
690	backTrack->matchAmount = matchAmount;
691	return true;
692	}
693
694	case QuantifierNonGreedy:
695	backTrack->begin = input.getPos();
696	backTrack->matchAmount = 0;
697	return true;
698	}
699
700	RELEASE_ASSERT_NOT_REACHED();
701	return false;
702	}
703
704	bool backtrackBackReference(ByteTerm& term, DisjunctionContext* context)
705	{
706	ASSERT(term.type == ByteTerm::TypeBackReference);
707	BackTrackInfoBackReference* backTrack = reinterpret_cast<BackTrackInfoBackReference*>(context->frame + term.frameLocation);
708
709	unsigned matchBegin = output[(term.atom.subpatternId << 1)];
710	unsigned matchEnd = output[(term.atom.subpatternId << 1) + 1];
711
712	if (matchBegin == offsetNoMatch)
713	return false;
714
715	ASSERT(matchBegin <= matchEnd);
716
717	if (matchBegin == matchEnd)
718	return false;
719
720	switch (term.atom.quantityType) {
721	case QuantifierFixedCount:
722	// for quantityMaxCount == 1, could rewind.
723	input.setPos(backTrack->begin);
724	break;
725
726	case QuantifierGreedy:
727	if (backTrack->matchAmount) {
728	--backTrack->matchAmount;
729	input.rewind(matchEnd - matchBegin);
730	return true;
731	}
732	break;
733
734	case QuantifierNonGreedy:
735	if ((backTrack->matchAmount < term.atom.quantityMaxCount) && tryConsumeBackReference(matchBegin, matchEnd, negativeInputOffset: term.inputPosition)) {
736	++backTrack->matchAmount;
737	return true;
738	}
739	input.setPos(backTrack->begin);
740	break;
741	}
742
743	return false;
744	}
745
746	void recordParenthesesMatch(ByteTerm& term, ParenthesesDisjunctionContext* context)
747	{
748	if (term.capture()) {
749	unsigned subpatternId = term.atom.subpatternId;
750	output[(subpatternId << 1)] = context->getDisjunctionContext(term)->matchBegin - term.inputPosition;
751	output[(subpatternId << 1) + 1] = context->getDisjunctionContext(term)->matchEnd - term.inputPosition;
752	}
753	}
754	void resetMatches(ByteTerm& term, ParenthesesDisjunctionContext* context)
755	{
756	unsigned firstSubpatternId = term.atom.subpatternId;
757	unsigned count = term.atom.parenthesesDisjunction->m_numSubpatterns;
758	context->restoreOutput(output, firstSubpatternId, count);
759	}
760	JSRegExpResult parenthesesDoBacktrack(ByteTerm& term, BackTrackInfoParentheses* backTrack)
761	{
762	while (backTrack->matchAmount) {
763	ParenthesesDisjunctionContext* context = backTrack->lastContext;
764
765	JSRegExpResult result = matchDisjunction(disjunction: term.atom.parenthesesDisjunction, context: context->getDisjunctionContext(term), btrack: true);
766	if (result == JSRegExpMatch)
767	return JSRegExpMatch;
768
769	resetMatches(term, context);
770	popParenthesesDisjunctionContext(backTrack);
771	freeParenthesesDisjunctionContext(context);
772
773	if (result != JSRegExpNoMatch)
774	return result;
775	}
776
777	return JSRegExpNoMatch;
778	}
779
780	bool matchParenthesesOnceBegin(ByteTerm& term, DisjunctionContext* context)
781	{
782	ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceBegin);
783	ASSERT(term.atom.quantityMaxCount == 1);
784
785	BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);
786
787	switch (term.atom.quantityType) {
788	case QuantifierGreedy: {
789	// set this speculatively; if we get to the parens end this will be true.
790	backTrack->begin = input.getPos();
791	break;
792	}
793	case QuantifierNonGreedy: {
794	backTrack->begin = notFound;
795	context->term += term.atom.parenthesesWidth;
796	return true;
797	}
798	case QuantifierFixedCount:
799	break;
800	}
801
802	if (term.capture()) {
803	unsigned subpatternId = term.atom.subpatternId;
804	output[(subpatternId << 1)] = input.getPos() - term.inputPosition;
805	}
806
807	return true;
808	}
809
810	bool matchParenthesesOnceEnd(ByteTerm& term, DisjunctionContext* context)
811	{
812	ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceEnd);
813	ASSERT(term.atom.quantityMaxCount == 1);
814
815	if (term.capture()) {
816	unsigned subpatternId = term.atom.subpatternId;
817	output[(subpatternId << 1) + 1] = input.getPos() - term.inputPosition;
818	}
819
820	if (term.atom.quantityType == QuantifierFixedCount)
821	return true;
822
823	BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);
824	return backTrack->begin != input.getPos();
825	}
826
827	bool backtrackParenthesesOnceBegin(ByteTerm& term, DisjunctionContext* context)
828	{
829	ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceBegin);
830	ASSERT(term.atom.quantityMaxCount == 1);
831
832	BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);
833
834	if (term.capture()) {
835	unsigned subpatternId = term.atom.subpatternId;
836	output[(subpatternId << 1)] = offsetNoMatch;
837	output[(subpatternId << 1) + 1] = offsetNoMatch;
838	}
839
840	switch (term.atom.quantityType) {
841	case QuantifierGreedy:
842	// if we backtrack to this point, there is another chance - try matching nothing.
843	ASSERT(backTrack->begin != notFound);
844	backTrack->begin = notFound;
845	context->term += term.atom.parenthesesWidth;
846	return true;
847	case QuantifierNonGreedy:
848	ASSERT(backTrack->begin != notFound);
849	FALLTHROUGH;
850	case QuantifierFixedCount:
851	break;
852	}
853
854	return false;
855	}
856
857	bool backtrackParenthesesOnceEnd(ByteTerm& term, DisjunctionContext* context)
858	{
859	ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceEnd);
860	ASSERT(term.atom.quantityMaxCount == 1);
861
862	BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);
863
864	switch (term.atom.quantityType) {
865	case QuantifierGreedy:
866	if (backTrack->begin == notFound) {
867	context->term -= term.atom.parenthesesWidth;
868	return false;
869	}
870	FALLTHROUGH;
871	case QuantifierNonGreedy:
872	if (backTrack->begin == notFound) {
873	backTrack->begin = input.getPos();
874	if (term.capture()) {
875	// Technically this access to inputPosition should be accessing the begin term's
876	// inputPosition, but for repeats other than fixed these values should be
877	// the same anyway! (We don't pre-check for greedy or non-greedy matches.)
878	ASSERT((&term - term.atom.parenthesesWidth)->type == ByteTerm::TypeParenthesesSubpatternOnceBegin);
879	ASSERT((&term - term.atom.parenthesesWidth)->inputPosition == term.inputPosition);
880	unsigned subpatternId = term.atom.subpatternId;
881	output[subpatternId << 1] = input.getPos() - term.inputPosition;
882	}
883	context->term -= term.atom.parenthesesWidth;
884	return true;
885	}
886	FALLTHROUGH;
887	case QuantifierFixedCount:
888	break;
889	}
890
891	return false;
892	}
893
894	bool matchParenthesesTerminalBegin(ByteTerm& term, DisjunctionContext* context)
895	{
896	ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternTerminalBegin);
897	ASSERT(term.atom.quantityType == QuantifierGreedy);
898	ASSERT(term.atom.quantityMaxCount == quantifyInfinite);
899	ASSERT(!term.capture());
900
901	BackTrackInfoParenthesesTerminal* backTrack = reinterpret_cast<BackTrackInfoParenthesesTerminal*>(context->frame + term.frameLocation);
902	backTrack->begin = input.getPos();
903	return true;
904	}
905
906	bool matchParenthesesTerminalEnd(ByteTerm& term, DisjunctionContext* context)
907	{
908	ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternTerminalEnd);
909
910	BackTrackInfoParenthesesTerminal* backTrack = reinterpret_cast<BackTrackInfoParenthesesTerminal*>(context->frame + term.frameLocation);
911	// Empty match is a failed match.
912	if (backTrack->begin == input.getPos())
913	return false;
914
915	// Successful match! Okay, what's next? - loop around and try to match more!
916	context->term -= (term.atom.parenthesesWidth + 1);
917	return true;
918	}
919
920	bool backtrackParenthesesTerminalBegin(ByteTerm& term, DisjunctionContext* context)
921	{
922	ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternTerminalBegin);
923	ASSERT(term.atom.quantityType == QuantifierGreedy);
924	ASSERT(term.atom.quantityMaxCount == quantifyInfinite);
925	ASSERT(!term.capture());
926
927	// If we backtrack to this point, we have failed to match this iteration of the parens.
928	// Since this is greedy / zero minimum a failed is also accepted as a match!
929	context->term += term.atom.parenthesesWidth;
930	return true;
931	}
932
933	bool backtrackParenthesesTerminalEnd(ByteTerm&, DisjunctionContext*)
934	{
935	// 'Terminal' parentheses are at the end of the regex, and as such a match past end
936	// should always be returned as a successful match - we should never backtrack to here.
937	RELEASE_ASSERT_NOT_REACHED();
938	return false;
939	}
940
941	bool matchParentheticalAssertionBegin(ByteTerm& term, DisjunctionContext* context)
942	{
943	ASSERT(term.type == ByteTerm::TypeParentheticalAssertionBegin);
944	ASSERT(term.atom.quantityMaxCount == 1);
945
946	BackTrackInfoParentheticalAssertion* backTrack = reinterpret_cast<BackTrackInfoParentheticalAssertion*>(context->frame + term.frameLocation);
947
948	backTrack->begin = input.getPos();
949	return true;
950	}
951
952	bool matchParentheticalAssertionEnd(ByteTerm& term, DisjunctionContext* context)
953	{
954	ASSERT(term.type == ByteTerm::TypeParentheticalAssertionEnd);
955	ASSERT(term.atom.quantityMaxCount == 1);
956
957	BackTrackInfoParentheticalAssertion* backTrack = reinterpret_cast<BackTrackInfoParentheticalAssertion*>(context->frame + term.frameLocation);
958
959	input.setPos(backTrack->begin);
960
961	// We've reached the end of the parens; if they are inverted, this is failure.
962	if (term.invert()) {
963	context->term -= term.atom.parenthesesWidth;
964	return false;
965	}
966
967	return true;
968	}
969
970	bool backtrackParentheticalAssertionBegin(ByteTerm& term, DisjunctionContext* context)
971	{
972	ASSERT(term.type == ByteTerm::TypeParentheticalAssertionBegin);
973	ASSERT(term.atom.quantityMaxCount == 1);
974
975	// We've failed to match parens; if they are inverted, this is win!
976	if (term.invert()) {
977	context->term += term.atom.parenthesesWidth;
978	return true;
979	}
980
981	return false;
982	}
983
984	bool backtrackParentheticalAssertionEnd(ByteTerm& term, DisjunctionContext* context)
985	{
986	ASSERT(term.type == ByteTerm::TypeParentheticalAssertionEnd);
987	ASSERT(term.atom.quantityMaxCount == 1);
988
989	BackTrackInfoParentheticalAssertion* backTrack = reinterpret_cast<BackTrackInfoParentheticalAssertion*>(context->frame + term.frameLocation);
990
991	input.setPos(backTrack->begin);
992
993	context->term -= term.atom.parenthesesWidth;
994	return false;
995	}
996
997	JSRegExpResult matchParentheses(ByteTerm& term, DisjunctionContext* context)
998	{
999	ASSERT(term.type == ByteTerm::TypeParenthesesSubpattern);
1000
1001	BackTrackInfoParentheses* backTrack = reinterpret_cast<BackTrackInfoParentheses*>(context->frame + term.frameLocation);
1002	ByteDisjunction* disjunctionBody = term.atom.parenthesesDisjunction;
1003
1004	backTrack->matchAmount = 0;
1005	backTrack->lastContext = 0;
1006
1007	ASSERT(term.atom.quantityType != QuantifierFixedCount || term.atom.quantityMinCount == term.atom.quantityMaxCount);
1008
1009	unsigned minimumMatchCount = term.atom.quantityMinCount;
1010	JSRegExpResult fixedMatchResult;
1011
1012	// Handle fixed matches and the minimum part of a variable length match.
1013	if (minimumMatchCount) {
1014	// While we haven't yet reached our fixed limit,
1015	while (backTrack->matchAmount < minimumMatchCount) {
1016	// Try to do a match, and it it succeeds, add it to the list.
1017	ParenthesesDisjunctionContext* context = allocParenthesesDisjunctionContext(disjunction: disjunctionBody, output, term);
1018	fixedMatchResult = matchDisjunction(disjunction: disjunctionBody, context: context->getDisjunctionContext(term));
1019	if (fixedMatchResult == JSRegExpMatch)
1020	appendParenthesesDisjunctionContext(backTrack, context);
1021	else {
1022	// The match failed; try to find an alternate point to carry on from.
1023	resetMatches(term, context);
1024	freeParenthesesDisjunctionContext(context);
1025
1026	if (fixedMatchResult != JSRegExpNoMatch)
1027	return fixedMatchResult;
1028	JSRegExpResult backtrackResult = parenthesesDoBacktrack(term, backTrack);
1029	if (backtrackResult != JSRegExpMatch)
1030	return backtrackResult;
1031	}
1032	}
1033
1034	ParenthesesDisjunctionContext* context = backTrack->lastContext;
1035	recordParenthesesMatch(term, context);
1036	}
1037
1038	switch (term.atom.quantityType) {
1039	case QuantifierFixedCount: {
1040	ASSERT(backTrack->matchAmount == term.atom.quantityMaxCount);
1041	return JSRegExpMatch;
1042	}
1043
1044	case QuantifierGreedy: {
1045	while (backTrack->matchAmount < term.atom.quantityMaxCount) {
1046	ParenthesesDisjunctionContext* context = allocParenthesesDisjunctionContext(disjunction: disjunctionBody, output, term);
1047	JSRegExpResult result = matchNonZeroDisjunction(disjunction: disjunctionBody, context: context->getDisjunctionContext(term));
1048	if (result == JSRegExpMatch)
1049	appendParenthesesDisjunctionContext(backTrack, context);
1050	else {
1051	resetMatches(term, context);
1052	freeParenthesesDisjunctionContext(context);
1053
1054	if (result != JSRegExpNoMatch)
1055	return result;
1056
1057	break;
1058	}
1059	}
1060
1061	if (backTrack->matchAmount) {
1062	ParenthesesDisjunctionContext* context = backTrack->lastContext;
1063	recordParenthesesMatch(term, context);
1064	}
1065	return JSRegExpMatch;
1066	}
1067
1068	case QuantifierNonGreedy:
1069	return JSRegExpMatch;
1070	}
1071
1072	RELEASE_ASSERT_NOT_REACHED();
1073	return JSRegExpErrorNoMatch;
1074	}
1075
1076	// Rules for backtracking differ depending on whether this is greedy or non-greedy.
1077	//
1078	// Greedy matches never should try just adding more - you should already have done
1079	// the 'more' cases. Always backtrack, at least a leetle bit. However cases where
1080	// you backtrack an item off the list needs checking, since we'll never have matched
1081	// the one less case. Tracking forwards, still add as much as possible.
1082	//
1083	// Non-greedy, we've already done the one less case, so don't match on popping.
1084	// We haven't done the one more case, so always try to add that.
1085	//
1086	JSRegExpResult backtrackParentheses(ByteTerm& term, DisjunctionContext* context)
1087	{
1088	ASSERT(term.type == ByteTerm::TypeParenthesesSubpattern);
1089
1090	BackTrackInfoParentheses* backTrack = reinterpret_cast<BackTrackInfoParentheses*>(context->frame + term.frameLocation);
1091	ByteDisjunction* disjunctionBody = term.atom.parenthesesDisjunction;
1092
1093	switch (term.atom.quantityType) {
1094	case QuantifierFixedCount: {
1095	ASSERT(backTrack->matchAmount == term.atom.quantityMaxCount);
1096
1097	ParenthesesDisjunctionContext* context = 0;
1098	JSRegExpResult result = parenthesesDoBacktrack(term, backTrack);
1099
1100	if (result != JSRegExpMatch)
1101	return result;
1102
1103	// While we haven't yet reached our fixed limit,
1104	while (backTrack->matchAmount < term.atom.quantityMaxCount) {
1105	// Try to do a match, and it it succeeds, add it to the list.
1106	context = allocParenthesesDisjunctionContext(disjunction: disjunctionBody, output, term);
1107	result = matchDisjunction(disjunction: disjunctionBody, context: context->getDisjunctionContext(term));
1108
1109	if (result == JSRegExpMatch)
1110	appendParenthesesDisjunctionContext(backTrack, context);
1111	else {
1112	// The match failed; try to find an alternate point to carry on from.
1113	resetMatches(term, context);
1114	freeParenthesesDisjunctionContext(context);
1115
1116	if (result != JSRegExpNoMatch)
1117	return result;
1118	JSRegExpResult backtrackResult = parenthesesDoBacktrack(term, backTrack);
1119	if (backtrackResult != JSRegExpMatch)
1120	return backtrackResult;
1121	}
1122	}
1123
1124	ASSERT(backTrack->matchAmount == term.atom.quantityMaxCount);
1125	context = backTrack->lastContext;
1126	recordParenthesesMatch(term, context);
1127	return JSRegExpMatch;
1128	}
1129
1130	case QuantifierGreedy: {
1131	if (!backTrack->matchAmount)
1132	return JSRegExpNoMatch;
1133
1134	ParenthesesDisjunctionContext* context = backTrack->lastContext;
1135	JSRegExpResult result = matchNonZeroDisjunction(disjunction: disjunctionBody, context: context->getDisjunctionContext(term), btrack: true);
1136	if (result == JSRegExpMatch) {
1137	while (backTrack->matchAmount < term.atom.quantityMaxCount) {
1138	ParenthesesDisjunctionContext* context = allocParenthesesDisjunctionContext(disjunction: disjunctionBody, output, term);
1139	JSRegExpResult parenthesesResult = matchNonZeroDisjunction(disjunction: disjunctionBody, context: context->getDisjunctionContext(term));
1140	if (parenthesesResult == JSRegExpMatch)
1141	appendParenthesesDisjunctionContext(backTrack, context);
1142	else {
1143	resetMatches(term, context);
1144	freeParenthesesDisjunctionContext(context);
1145
1146	if (parenthesesResult != JSRegExpNoMatch)
1147	return parenthesesResult;
1148
1149	break;
1150	}
1151	}
1152	} else {
1153	resetMatches(term, context);
1154	popParenthesesDisjunctionContext(backTrack);
1155	freeParenthesesDisjunctionContext(context);
1156
1157	if (result != JSRegExpNoMatch || backTrack->matchAmount < term.atom.quantityMinCount)
1158	return result;
1159	}
1160
1161	if (backTrack->matchAmount) {
1162	ParenthesesDisjunctionContext* context = backTrack->lastContext;
1163	recordParenthesesMatch(term, context);
1164	}
1165	return JSRegExpMatch;
1166	}
1167
1168	case QuantifierNonGreedy: {
1169	// If we've not reached the limit, try to add one more match.
1170	if (backTrack->matchAmount < term.atom.quantityMaxCount) {
1171	ParenthesesDisjunctionContext* context = allocParenthesesDisjunctionContext(disjunction: disjunctionBody, output, term);
1172	JSRegExpResult result = matchNonZeroDisjunction(disjunction: disjunctionBody, context: context->getDisjunctionContext(term));
1173	if (result == JSRegExpMatch) {
1174	appendParenthesesDisjunctionContext(backTrack, context);
1175	recordParenthesesMatch(term, context);
1176	return JSRegExpMatch;
1177	}
1178
1179	resetMatches(term, context);
1180	freeParenthesesDisjunctionContext(context);
1181
1182	if (result != JSRegExpNoMatch)
1183	return result;
1184	}
1185
1186	// Nope - okay backtrack looking for an alternative.
1187	while (backTrack->matchAmount) {
1188	ParenthesesDisjunctionContext* context = backTrack->lastContext;
1189	JSRegExpResult result = matchNonZeroDisjunction(disjunction: disjunctionBody, context: context->getDisjunctionContext(term), btrack: true);
1190	if (result == JSRegExpMatch) {
1191	// successful backtrack! we're back in the game!
1192	if (backTrack->matchAmount) {
1193	context = backTrack->lastContext;
1194	recordParenthesesMatch(term, context);
1195	}
1196	return JSRegExpMatch;
1197	}
1198
1199	// pop a match off the stack
1200	resetMatches(term, context);
1201	popParenthesesDisjunctionContext(backTrack);
1202	freeParenthesesDisjunctionContext(context);
1203
1204	if (result != JSRegExpNoMatch)
1205	return result;
1206	}
1207
1208	return JSRegExpNoMatch;
1209	}
1210	}
1211
1212	RELEASE_ASSERT_NOT_REACHED();
1213	return JSRegExpErrorNoMatch;
1214	}
1215
1216	bool matchDotStarEnclosure(ByteTerm& term, DisjunctionContext* context)
1217	{
1218	UNUSED_PARAM(term);
1219
1220	if (pattern->dotAll()) {
1221	context->matchBegin = startOffset;
1222	context->matchEnd = input.end();
1223	return true;
1224	}
1225
1226	unsigned matchBegin = context->matchBegin;
1227
1228	if (matchBegin > startOffset) {
1229	for (matchBegin--; true; matchBegin--) {
1230	if (testCharacterClass(characterClass: pattern->newlineCharacterClass, ch: input.reread(matchBegin))) {
1231	++matchBegin;
1232	break;
1233	}
1234
1235	if (matchBegin == startOffset)
1236	break;
1237	}
1238	}
1239
1240	unsigned matchEnd = input.getPos();
1241
1242	for (; (matchEnd != input.end())
1243	&& (!testCharacterClass(characterClass: pattern->newlineCharacterClass, ch: input.reread(matchEnd))); matchEnd++) { }
1244
1245	if (((matchBegin && term.anchors.m_bol)
1246	|| ((matchEnd != input.end()) && term.anchors.m_eol))
1247	&& !pattern->multiline())
1248	return false;
1249
1250	context->matchBegin = matchBegin;
1251	context->matchEnd = matchEnd;
1252	return true;
1253	}
1254
1255	#define MATCH_NEXT() { ++context->term; goto matchAgain; }
1256	#define BACKTRACK() { --context->term; goto backtrack; }
1257	#define currentTerm() (disjunction->terms[context->term])
1258	JSRegExpResult matchDisjunction(ByteDisjunction* disjunction, DisjunctionContext* context, bool btrack = false)
1259	{
1260	if (!--remainingMatchCount)
1261	return JSRegExpErrorHitLimit;
1262
1263	if (btrack)
1264	BACKTRACK();
1265
1266	context->matchBegin = input.getPos();
1267	context->term = 0;
1268
1269	matchAgain:
1270	ASSERT(context->term < static_cast<int>(disjunction->terms.size()));
1271
1272	switch (currentTerm().type) {
1273	case ByteTerm::TypeSubpatternBegin:
1274	MATCH_NEXT();
1275	case ByteTerm::TypeSubpatternEnd:
1276	context->matchEnd = input.getPos();
1277	return JSRegExpMatch;
1278
1279	case ByteTerm::TypeBodyAlternativeBegin:
1280	MATCH_NEXT();
1281	case ByteTerm::TypeBodyAlternativeDisjunction:
1282	case ByteTerm::TypeBodyAlternativeEnd:
1283	context->matchEnd = input.getPos();
1284	return JSRegExpMatch;
1285
1286	case ByteTerm::TypeAlternativeBegin:
1287	MATCH_NEXT();
1288	case ByteTerm::TypeAlternativeDisjunction:
1289	case ByteTerm::TypeAlternativeEnd: {
1290	int offset = currentTerm().alternative.end;
1291	BackTrackInfoAlternative* backTrack = reinterpret_cast<BackTrackInfoAlternative*>(context->frame + currentTerm().frameLocation);
1292	backTrack->offset = offset;
1293	context->term += offset;
1294	MATCH_NEXT();
1295	}
1296
1297	case ByteTerm::TypeAssertionBOL:
1298	if (matchAssertionBOL(currentTerm()))
1299	MATCH_NEXT();
1300	BACKTRACK();
1301	case ByteTerm::TypeAssertionEOL:
1302	if (matchAssertionEOL(currentTerm()))
1303	MATCH_NEXT();
1304	BACKTRACK();
1305	case ByteTerm::TypeAssertionWordBoundary:
1306	if (matchAssertionWordBoundary(currentTerm()))
1307	MATCH_NEXT();
1308	BACKTRACK();
1309
1310	case ByteTerm::TypePatternCharacterOnce:
1311	case ByteTerm::TypePatternCharacterFixed: {
1312	if (unicode) {
1313	if (!U_IS_BMP(currentTerm().atom.patternCharacter)) {
1314	for (unsigned matchAmount = 0; matchAmount < currentTerm().atom.quantityMaxCount; ++matchAmount) {
1315	if (!checkSurrogatePair(currentTerm().atom.patternCharacter, currentTerm().inputPosition - 2 * matchAmount)) {
1316	BACKTRACK();
1317	}
1318	}
1319	MATCH_NEXT();
1320	}
1321	}
1322	unsigned position = input.getPos(); // May need to back out reading a surrogate pair.
1323
1324	for (unsigned matchAmount = 0; matchAmount < currentTerm().atom.quantityMaxCount; ++matchAmount) {
1325	if (!checkCharacter(currentTerm().atom.patternCharacter, currentTerm().inputPosition - matchAmount)) {
1326	input.setPos(position);
1327	BACKTRACK();
1328	}
1329	}
1330	MATCH_NEXT();
1331	}
1332	case ByteTerm::TypePatternCharacterGreedy: {
1333	BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + currentTerm().frameLocation);
1334	unsigned matchAmount = 0;
1335	unsigned position = input.getPos(); // May need to back out reading a surrogate pair.
1336	while ((matchAmount < currentTerm().atom.quantityMaxCount) && input.checkInput(1)) {
1337	if (!checkCharacter(currentTerm().atom.patternCharacter, currentTerm().inputPosition + 1)) {
1338	input.setPos(position);
1339	break;
1340	}
1341	++matchAmount;
1342	position = input.getPos();
1343	}
1344	backTrack->matchAmount = matchAmount;
1345
1346	MATCH_NEXT();
1347	}
1348	case ByteTerm::TypePatternCharacterNonGreedy: {
1349	BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + currentTerm().frameLocation);
1350	backTrack->begin = input.getPos();
1351	backTrack->matchAmount = 0;
1352	MATCH_NEXT();
1353	}
1354
1355	case ByteTerm::TypePatternCasedCharacterOnce:
1356	case ByteTerm::TypePatternCasedCharacterFixed: {
1357	if (unicode) {
1358	// Case insensitive matching of unicode characters is handled as TypeCharacterClass.
1359	ASSERT(U_IS_BMP(currentTerm().atom.patternCharacter));
1360
1361	unsigned position = input.getPos(); // May need to back out reading a surrogate pair.
1362
1363	for (unsigned matchAmount = 0; matchAmount < currentTerm().atom.quantityMaxCount; ++matchAmount) {
1364	if (!checkCasedCharacter(currentTerm().atom.casedCharacter.lo, currentTerm().atom.casedCharacter.hi, currentTerm().inputPosition - matchAmount)) {
1365	input.setPos(position);
1366	BACKTRACK();
1367	}
1368	}
1369	MATCH_NEXT();
1370	}
1371
1372	for (unsigned matchAmount = 0; matchAmount < currentTerm().atom.quantityMaxCount; ++matchAmount) {
1373	if (!checkCasedCharacter(currentTerm().atom.casedCharacter.lo, currentTerm().atom.casedCharacter.hi, currentTerm().inputPosition - matchAmount))
1374	BACKTRACK();
1375	}
1376	MATCH_NEXT();
1377	}
1378	case ByteTerm::TypePatternCasedCharacterGreedy: {
1379	BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + currentTerm().frameLocation);
1380
1381	// Case insensitive matching of unicode characters is handled as TypeCharacterClass.
1382	ASSERT(!unicode || U_IS_BMP(currentTerm().atom.patternCharacter));
1383
1384	unsigned matchAmount = 0;
1385	while ((matchAmount < currentTerm().atom.quantityMaxCount) && input.checkInput(1)) {
1386	if (!checkCasedCharacter(currentTerm().atom.casedCharacter.lo, currentTerm().atom.casedCharacter.hi, currentTerm().inputPosition + 1)) {
1387	input.uncheckInput(1);
1388	break;
1389	}
1390	++matchAmount;
1391	}
1392	backTrack->matchAmount = matchAmount;
1393
1394	MATCH_NEXT();
1395	}
1396	case ByteTerm::TypePatternCasedCharacterNonGreedy: {
1397	BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + currentTerm().frameLocation);
1398
1399	// Case insensitive matching of unicode characters is handled as TypeCharacterClass.
1400	ASSERT(!unicode || U_IS_BMP(currentTerm().atom.patternCharacter));
1401
1402	backTrack->matchAmount = 0;
1403	MATCH_NEXT();
1404	}
1405
1406	case ByteTerm::TypeCharacterClass:
1407	if (matchCharacterClass(currentTerm(), context))
1408	MATCH_NEXT();
1409	BACKTRACK();
1410	case ByteTerm::TypeBackReference:
1411	if (matchBackReference(currentTerm(), context))
1412	MATCH_NEXT();
1413	BACKTRACK();
1414	case ByteTerm::TypeParenthesesSubpattern: {
1415	JSRegExpResult result = matchParentheses(currentTerm(), context);
1416
1417	if (result == JSRegExpMatch) {
1418	MATCH_NEXT();
1419	} else if (result != JSRegExpNoMatch)
1420	return result;
1421
1422	BACKTRACK();
1423	}
1424	case ByteTerm::TypeParenthesesSubpatternOnceBegin:
1425	if (matchParenthesesOnceBegin(currentTerm(), context))
1426	MATCH_NEXT();
1427	BACKTRACK();
1428	case ByteTerm::TypeParenthesesSubpatternOnceEnd:
1429	if (matchParenthesesOnceEnd(currentTerm(), context))
1430	MATCH_NEXT();
1431	BACKTRACK();
1432	case ByteTerm::TypeParenthesesSubpatternTerminalBegin:
1433	if (matchParenthesesTerminalBegin(currentTerm(), context))
1434	MATCH_NEXT();
1435	BACKTRACK();
1436	case ByteTerm::TypeParenthesesSubpatternTerminalEnd:
1437	if (matchParenthesesTerminalEnd(currentTerm(), context))
1438	MATCH_NEXT();
1439	BACKTRACK();
1440	case ByteTerm::TypeParentheticalAssertionBegin:
1441	if (matchParentheticalAssertionBegin(currentTerm(), context))
1442	MATCH_NEXT();
1443	BACKTRACK();
1444	case ByteTerm::TypeParentheticalAssertionEnd:
1445	if (matchParentheticalAssertionEnd(currentTerm(), context))
1446	MATCH_NEXT();
1447	BACKTRACK();
1448
1449	case ByteTerm::TypeCheckInput:
1450	if (input.checkInput(currentTerm().checkInputCount))
1451	MATCH_NEXT();
1452	BACKTRACK();
1453
1454	case ByteTerm::TypeUncheckInput:
1455	input.uncheckInput(currentTerm().checkInputCount);
1456	MATCH_NEXT();
1457
1458	case ByteTerm::TypeDotStarEnclosure:
1459	if (matchDotStarEnclosure(currentTerm(), context))
1460	return JSRegExpMatch;
1461	BACKTRACK();
1462	}
1463
1464	// We should never fall-through to here.
1465	RELEASE_ASSERT_NOT_REACHED();
1466
1467	backtrack:
1468	ASSERT(context->term < static_cast<int>(disjunction->terms.size()));
1469
1470	switch (currentTerm().type) {
1471	case ByteTerm::TypeSubpatternBegin:
1472	return JSRegExpNoMatch;
1473	case ByteTerm::TypeSubpatternEnd:
1474	RELEASE_ASSERT_NOT_REACHED();
1475
1476	case ByteTerm::TypeBodyAlternativeBegin:
1477	case ByteTerm::TypeBodyAlternativeDisjunction: {
1478	int offset = currentTerm().alternative.next;
1479	context->term += offset;
1480	if (offset > 0)
1481	MATCH_NEXT();
1482
1483	if (input.atEnd() || pattern->sticky())
1484	return JSRegExpNoMatch;
1485
1486	input.next();
1487
1488	context->matchBegin = input.getPos();
1489
1490	if (currentTerm().alternative.onceThrough)
1491	context->term += currentTerm().alternative.next;
1492
1493	MATCH_NEXT();
1494	}
1495	case ByteTerm::TypeBodyAlternativeEnd:
1496	RELEASE_ASSERT_NOT_REACHED();
1497
1498	case ByteTerm::TypeAlternativeBegin:
1499	case ByteTerm::TypeAlternativeDisjunction: {
1500	int offset = currentTerm().alternative.next;
1501	context->term += offset;
1502	if (offset > 0)
1503	MATCH_NEXT();
1504	BACKTRACK();
1505	}
1506	case ByteTerm::TypeAlternativeEnd: {
1507	// We should never backtrack back into an alternative of the main body of the regex.
1508	BackTrackInfoAlternative* backTrack = reinterpret_cast<BackTrackInfoAlternative*>(context->frame + currentTerm().frameLocation);
1509	unsigned offset = backTrack->offset;
1510	context->term -= offset;
1511	BACKTRACK();
1512	}
1513
1514	case ByteTerm::TypeAssertionBOL:
1515	case ByteTerm::TypeAssertionEOL:
1516	case ByteTerm::TypeAssertionWordBoundary:
1517	BACKTRACK();
1518
1519	case ByteTerm::TypePatternCharacterOnce:
1520	case ByteTerm::TypePatternCharacterFixed:
1521	case ByteTerm::TypePatternCharacterGreedy:
1522	case ByteTerm::TypePatternCharacterNonGreedy:
1523	if (backtrackPatternCharacter(currentTerm(), context))
1524	MATCH_NEXT();
1525	BACKTRACK();
1526	case ByteTerm::TypePatternCasedCharacterOnce:
1527	case ByteTerm::TypePatternCasedCharacterFixed:
1528	case ByteTerm::TypePatternCasedCharacterGreedy:
1529	case ByteTerm::TypePatternCasedCharacterNonGreedy:
1530	if (backtrackPatternCasedCharacter(currentTerm(), context))
1531	MATCH_NEXT();
1532	BACKTRACK();
1533	case ByteTerm::TypeCharacterClass:
1534	if (backtrackCharacterClass(currentTerm(), context))
1535	MATCH_NEXT();
1536	BACKTRACK();
1537	case ByteTerm::TypeBackReference:
1538	if (backtrackBackReference(currentTerm(), context))
1539	MATCH_NEXT();
1540	BACKTRACK();
1541	case ByteTerm::TypeParenthesesSubpattern: {
1542	JSRegExpResult result = backtrackParentheses(currentTerm(), context);
1543
1544	if (result == JSRegExpMatch) {
1545	MATCH_NEXT();
1546	} else if (result != JSRegExpNoMatch)
1547	return result;
1548
1549	BACKTRACK();
1550	}
1551	case ByteTerm::TypeParenthesesSubpatternOnceBegin:
1552	if (backtrackParenthesesOnceBegin(currentTerm(), context))
1553	MATCH_NEXT();
1554	BACKTRACK();
1555	case ByteTerm::TypeParenthesesSubpatternOnceEnd:
1556	if (backtrackParenthesesOnceEnd(currentTerm(), context))
1557	MATCH_NEXT();
1558	BACKTRACK();
1559	case ByteTerm::TypeParenthesesSubpatternTerminalBegin:
1560	if (backtrackParenthesesTerminalBegin(currentTerm(), context))
1561	MATCH_NEXT();
1562	BACKTRACK();
1563	case ByteTerm::TypeParenthesesSubpatternTerminalEnd:
1564	if (backtrackParenthesesTerminalEnd(currentTerm(), context))
1565	MATCH_NEXT();
1566	BACKTRACK();
1567	case ByteTerm::TypeParentheticalAssertionBegin:
1568	if (backtrackParentheticalAssertionBegin(currentTerm(), context))
1569	MATCH_NEXT();
1570	BACKTRACK();
1571	case ByteTerm::TypeParentheticalAssertionEnd:
1572	if (backtrackParentheticalAssertionEnd(currentTerm(), context))
1573	MATCH_NEXT();
1574	BACKTRACK();
1575
1576	case ByteTerm::TypeCheckInput:
1577	input.uncheckInput(currentTerm().checkInputCount);
1578	BACKTRACK();
1579
1580	case ByteTerm::TypeUncheckInput:
1581	input.checkInput(currentTerm().checkInputCount);
1582	BACKTRACK();
1583
1584	case ByteTerm::TypeDotStarEnclosure:
1585	RELEASE_ASSERT_NOT_REACHED();
1586	}
1587
1588	RELEASE_ASSERT_NOT_REACHED();
1589	return JSRegExpErrorNoMatch;
1590	}
1591
1592	JSRegExpResult matchNonZeroDisjunction(ByteDisjunction* disjunction, DisjunctionContext* context, bool btrack = false)
1593	{
1594	JSRegExpResult result = matchDisjunction(disjunction, context, btrack);
1595
1596	if (result == JSRegExpMatch) {
1597	while (context->matchBegin == context->matchEnd) {
1598	result = matchDisjunction(disjunction, context, btrack: true);
1599	if (result != JSRegExpMatch)
1600	return result;
1601	}
1602	return JSRegExpMatch;
1603	}
1604
1605	return result;
1606	}
1607
1608	unsigned interpret()
1609	{
1610	if (!input.isAvailableInput(0))
1611	return offsetNoMatch;
1612
1613	if (pattern->m_lock)
1614	pattern->m_lock->lock();
1615
1616	for (unsigned i = 0; i < pattern->m_body->m_numSubpatterns + 1; ++i)
1617	output[i << 1] = offsetNoMatch;
1618
1619	allocatorPool = pattern->m_allocator->startAllocator();
1620	RELEASE_ASSERT(allocatorPool);
1621
1622	DisjunctionContext* context = allocDisjunctionContext(disjunction: pattern->m_body.get());
1623
1624	JSRegExpResult result = matchDisjunction(disjunction: pattern->m_body.get(), context, btrack: false);
1625	if (result == JSRegExpMatch) {
1626	output[0] = context->matchBegin;
1627	output[1] = context->matchEnd;
1628	}
1629
1630	freeDisjunctionContext(context);
1631
1632	pattern->m_allocator->stopAllocator();
1633
1634	ASSERT((result == JSRegExpMatch) == (output[0] != offsetNoMatch));
1635
1636	if (pattern->m_lock)
1637	pattern->m_lock->unlock();
1638
1639	return output[0];
1640	}
1641
1642	Interpreter(BytecodePattern* pattern, unsigned* output, const CharType* input, unsigned length, unsigned start)
1643	: pattern(pattern)
1644	, unicode(pattern->unicode())
1645	, output(output)
1646	, input(input, start, length, pattern->unicode())
1647	, startOffset(start)
1648	, remainingMatchCount(matchLimit)
1649	{
1650	}
1651
1652	private:
1653	BytecodePattern* pattern;
1654	bool unicode;
1655	unsigned* output;
1656	InputStream input;
1657	WTF::BumpPointerPool* allocatorPool { nullptr };
1658	unsigned startOffset;
1659	unsigned remainingMatchCount;
1660	};
1661
1662	class ByteCompiler {
1663	struct ParenthesesStackEntry {
1664	unsigned beginTerm;
1665	unsigned savedAlternativeIndex;
1666	ParenthesesStackEntry(unsigned beginTerm, unsigned savedAlternativeIndex/*, unsigned subpatternId, bool capture = false*/)
1667	: beginTerm(beginTerm)
1668	, savedAlternativeIndex(savedAlternativeIndex)
1669	{
1670	}
1671	};
1672
1673	public:
1674	ByteCompiler(YarrPattern& pattern)
1675	: m_pattern(pattern)
1676	{
1677	m_currentAlternativeIndex = 0;
1678	}
1679
1680	std::unique_ptr<BytecodePattern> compile(BumpPointerAllocator* allocator, ConcurrentJSLock* lock)
1681	{
1682	regexBegin(numSubpatterns: m_pattern.m_numSubpatterns, callFrameSize: m_pattern.m_body->m_callFrameSize, onceThrough: m_pattern.m_body->m_alternatives[0]->onceThrough());
1683	emitDisjunction(disjunction: m_pattern.m_body);
1684	regexEnd();
1685
1686	#ifndef NDEBUG
1687	if (Options::dumpCompiledRegExpPatterns())
1688	dumpDisjunction(disjunction: m_bodyDisjunction.get());
1689	#endif
1690
1691	return std::make_unique<BytecodePattern>(WTFMove(m_bodyDisjunction), args&: m_allParenthesesInfo, args&: m_pattern, args&: allocator, args&: lock);
1692	}
1693
1694	void checkInput(unsigned count)
1695	{
1696	m_bodyDisjunction->terms.append(other: ByteTerm::CheckInput(count));
1697	}
1698
1699	void uncheckInput(unsigned count)
1700	{
1701	m_bodyDisjunction->terms.append(other: ByteTerm::UncheckInput(count));
1702	}
1703
1704	void assertionBOL(unsigned inputPosition)
1705	{
1706	m_bodyDisjunction->terms.append(other: ByteTerm::BOL(inputPos: inputPosition));
1707	}
1708
1709	void assertionEOL(unsigned inputPosition)
1710	{
1711	m_bodyDisjunction->terms.append(other: ByteTerm::EOL(inputPos: inputPosition));
1712	}
1713
1714	void assertionWordBoundary(bool invert, unsigned inputPosition)
1715	{
1716	m_bodyDisjunction->terms.append(other: ByteTerm::WordBoundary(invert, inputPos: inputPosition));
1717	}
1718
1719	void atomPatternCharacter(UChar32 ch, unsigned inputPosition, unsigned frameLocation, Checked<unsigned> quantityMaxCount, QuantifierType quantityType)
1720	{
1721	if (m_pattern.ignoreCase()) {
1722	UChar32 lo = u_tolower(ch);
1723	UChar32 hi = u_toupper(ch);
1724
1725	if (lo != hi) {
1726	m_bodyDisjunction->terms.append(other: ByteTerm(lo, hi, inputPosition, frameLocation, quantityMaxCount, quantityType));
1727	return;
1728	}
1729	}
1730
1731	m_bodyDisjunction->terms.append(other: ByteTerm(ch, inputPosition, frameLocation, quantityMaxCount, quantityType));
1732	}
1733
1734	void atomCharacterClass(CharacterClass* characterClass, bool invert, unsigned inputPosition, unsigned frameLocation, Checked<unsigned> quantityMaxCount, QuantifierType quantityType)
1735	{
1736	m_bodyDisjunction->terms.append(other: ByteTerm(characterClass, invert, inputPosition));
1737
1738	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1739	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].atom.quantityType = quantityType;
1740	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = frameLocation;
1741	}
1742
1743	void atomBackReference(unsigned subpatternId, unsigned inputPosition, unsigned frameLocation, Checked<unsigned> quantityMaxCount, QuantifierType quantityType)
1744	{
1745	ASSERT(subpatternId);
1746
1747	m_bodyDisjunction->terms.append(other: ByteTerm::BackReference(subpatternId, inputPos: inputPosition));
1748
1749	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1750	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].atom.quantityType = quantityType;
1751	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = frameLocation;
1752	}
1753
1754	void atomParenthesesOnceBegin(unsigned subpatternId, bool capture, unsigned inputPosition, unsigned frameLocation, unsigned alternativeFrameLocation)
1755	{
1756	int beginTerm = m_bodyDisjunction->terms.size();
1757
1758	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParenthesesSubpatternOnceBegin, subpatternId, capture, false, inputPosition));
1759	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = frameLocation;
1760	m_bodyDisjunction->terms.append(other: ByteTerm::AlternativeBegin());
1761	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = alternativeFrameLocation;
1762
1763	m_parenthesesStack.append(other: ParenthesesStackEntry(beginTerm, m_currentAlternativeIndex));
1764	m_currentAlternativeIndex = beginTerm + 1;
1765	}
1766
1767	void atomParenthesesTerminalBegin(unsigned subpatternId, bool capture, unsigned inputPosition, unsigned frameLocation, unsigned alternativeFrameLocation)
1768	{
1769	int beginTerm = m_bodyDisjunction->terms.size();
1770
1771	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParenthesesSubpatternTerminalBegin, subpatternId, capture, false, inputPosition));
1772	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = frameLocation;
1773	m_bodyDisjunction->terms.append(other: ByteTerm::AlternativeBegin());
1774	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = alternativeFrameLocation;
1775
1776	m_parenthesesStack.append(other: ParenthesesStackEntry(beginTerm, m_currentAlternativeIndex));
1777	m_currentAlternativeIndex = beginTerm + 1;
1778	}
1779
1780	void atomParenthesesSubpatternBegin(unsigned subpatternId, bool capture, unsigned inputPosition, unsigned frameLocation, unsigned alternativeFrameLocation)
1781	{
1782	// Errrk! - this is a little crazy, we initially generate as a TypeParenthesesSubpatternOnceBegin,
1783	// then fix this up at the end! - simplifying this should make it much clearer.
1784	// https://bugs.webkit.org/show_bug.cgi?id=50136
1785
1786	int beginTerm = m_bodyDisjunction->terms.size();
1787
1788	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParenthesesSubpatternOnceBegin, subpatternId, capture, false, inputPosition));
1789	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = frameLocation;
1790	m_bodyDisjunction->terms.append(other: ByteTerm::AlternativeBegin());
1791	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = alternativeFrameLocation;
1792
1793	m_parenthesesStack.append(other: ParenthesesStackEntry(beginTerm, m_currentAlternativeIndex));
1794	m_currentAlternativeIndex = beginTerm + 1;
1795	}
1796
1797	void atomParentheticalAssertionBegin(unsigned subpatternId, bool invert, unsigned frameLocation, unsigned alternativeFrameLocation)
1798	{
1799	int beginTerm = m_bodyDisjunction->terms.size();
1800
1801	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParentheticalAssertionBegin, subpatternId, false, invert, 0));
1802	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = frameLocation;
1803	m_bodyDisjunction->terms.append(other: ByteTerm::AlternativeBegin());
1804	m_bodyDisjunction->terms[m_bodyDisjunction->terms.size() - 1].frameLocation = alternativeFrameLocation;
1805
1806	m_parenthesesStack.append(other: ParenthesesStackEntry(beginTerm, m_currentAlternativeIndex));
1807	m_currentAlternativeIndex = beginTerm + 1;
1808	}
1809
1810	void atomParentheticalAssertionEnd(unsigned inputPosition, unsigned frameLocation, Checked<unsigned> quantityMaxCount, QuantifierType quantityType)
1811	{
1812	unsigned beginTerm = popParenthesesStack();
1813	closeAlternative(beginTerm: beginTerm + 1);
1814	unsigned endTerm = m_bodyDisjunction->terms.size();
1815
1816	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeParentheticalAssertionBegin);
1817
1818	bool invert = m_bodyDisjunction->terms[beginTerm].invert();
1819	unsigned subpatternId = m_bodyDisjunction->terms[beginTerm].atom.subpatternId;
1820
1821	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParentheticalAssertionEnd, subpatternId, false, invert, inputPosition));
1822	m_bodyDisjunction->terms[beginTerm].atom.parenthesesWidth = endTerm - beginTerm;
1823	m_bodyDisjunction->terms[endTerm].atom.parenthesesWidth = endTerm - beginTerm;
1824	m_bodyDisjunction->terms[endTerm].frameLocation = frameLocation;
1825
1826	m_bodyDisjunction->terms[beginTerm].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1827	m_bodyDisjunction->terms[beginTerm].atom.quantityType = quantityType;
1828	m_bodyDisjunction->terms[endTerm].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1829	m_bodyDisjunction->terms[endTerm].atom.quantityType = quantityType;
1830	}
1831
1832	void assertionDotStarEnclosure(bool bolAnchored, bool eolAnchored)
1833	{
1834	m_bodyDisjunction->terms.append(other: ByteTerm::DotStarEnclosure(bolAnchor: bolAnchored, eolAnchor: eolAnchored));
1835	}
1836
1837	unsigned popParenthesesStack()
1838	{
1839	ASSERT(m_parenthesesStack.size());
1840	int stackEnd = m_parenthesesStack.size() - 1;
1841	unsigned beginTerm = m_parenthesesStack[stackEnd].beginTerm;
1842	m_currentAlternativeIndex = m_parenthesesStack[stackEnd].savedAlternativeIndex;
1843	m_parenthesesStack.shrink(size: stackEnd);
1844
1845	ASSERT(beginTerm < m_bodyDisjunction->terms.size());
1846	ASSERT(m_currentAlternativeIndex < m_bodyDisjunction->terms.size());
1847
1848	return beginTerm;
1849	}
1850
1851	void closeAlternative(int beginTerm)
1852	{
1853	int origBeginTerm = beginTerm;
1854	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeAlternativeBegin);
1855	int endIndex = m_bodyDisjunction->terms.size();
1856
1857	unsigned frameLocation = m_bodyDisjunction->terms[beginTerm].frameLocation;
1858
1859	if (!m_bodyDisjunction->terms[beginTerm].alternative.next)
1860	m_bodyDisjunction->terms.remove(position: beginTerm);
1861	else {
1862	while (m_bodyDisjunction->terms[beginTerm].alternative.next) {
1863	beginTerm += m_bodyDisjunction->terms[beginTerm].alternative.next;
1864	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeAlternativeDisjunction);
1865	m_bodyDisjunction->terms[beginTerm].alternative.end = endIndex - beginTerm;
1866	m_bodyDisjunction->terms[beginTerm].frameLocation = frameLocation;
1867	}
1868
1869	m_bodyDisjunction->terms[beginTerm].alternative.next = origBeginTerm - beginTerm;
1870
1871	m_bodyDisjunction->terms.append(other: ByteTerm::AlternativeEnd());
1872	m_bodyDisjunction->terms[endIndex].frameLocation = frameLocation;
1873	}
1874	}
1875
1876	void closeBodyAlternative()
1877	{
1878	int beginTerm = 0;
1879	int origBeginTerm = 0;
1880	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeBodyAlternativeBegin);
1881	int endIndex = m_bodyDisjunction->terms.size();
1882
1883	unsigned frameLocation = m_bodyDisjunction->terms[beginTerm].frameLocation;
1884
1885	while (m_bodyDisjunction->terms[beginTerm].alternative.next) {
1886	beginTerm += m_bodyDisjunction->terms[beginTerm].alternative.next;
1887	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeBodyAlternativeDisjunction);
1888	m_bodyDisjunction->terms[beginTerm].alternative.end = endIndex - beginTerm;
1889	m_bodyDisjunction->terms[beginTerm].frameLocation = frameLocation;
1890	}
1891
1892	m_bodyDisjunction->terms[beginTerm].alternative.next = origBeginTerm - beginTerm;
1893
1894	m_bodyDisjunction->terms.append(other: ByteTerm::BodyAlternativeEnd());
1895	m_bodyDisjunction->terms[endIndex].frameLocation = frameLocation;
1896	}
1897
1898	void atomParenthesesSubpatternEnd(unsigned lastSubpatternId, unsigned inputPosition, unsigned frameLocation, Checked<unsigned> quantityMinCount, Checked<unsigned> quantityMaxCount, QuantifierType quantityType, unsigned callFrameSize = 0)
1899	{
1900	unsigned beginTerm = popParenthesesStack();
1901	closeAlternative(beginTerm: beginTerm + 1);
1902	unsigned endTerm = m_bodyDisjunction->terms.size();
1903
1904	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeParenthesesSubpatternOnceBegin);
1905
1906	ByteTerm& parenthesesBegin = m_bodyDisjunction->terms[beginTerm];
1907
1908	bool capture = parenthesesBegin.capture();
1909	unsigned subpatternId = parenthesesBegin.atom.subpatternId;
1910
1911	unsigned numSubpatterns = lastSubpatternId - subpatternId + 1;
1912	auto parenthesesDisjunction = std::make_unique<ByteDisjunction>(args&: numSubpatterns, args&: callFrameSize);
1913
1914	unsigned firstTermInParentheses = beginTerm + 1;
1915	parenthesesDisjunction->terms.reserveInitialCapacity(size: endTerm - firstTermInParentheses + 2);
1916
1917	parenthesesDisjunction->terms.append(other: ByteTerm::SubpatternBegin());
1918	for (unsigned termInParentheses = firstTermInParentheses; termInParentheses < endTerm; ++termInParentheses)
1919	parenthesesDisjunction->terms.append(value: m_bodyDisjunction->terms[termInParentheses]);
1920	parenthesesDisjunction->terms.append(other: ByteTerm::SubpatternEnd());
1921
1922	m_bodyDisjunction->terms.shrink(size: beginTerm);
1923
1924	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction.get(), capture, inputPosition));
1925	m_allParenthesesInfo.append(WTFMove(parenthesesDisjunction));
1926
1927	m_bodyDisjunction->terms[beginTerm].atom.quantityMinCount = quantityMinCount.unsafeGet();
1928	m_bodyDisjunction->terms[beginTerm].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1929	m_bodyDisjunction->terms[beginTerm].atom.quantityType = quantityType;
1930	m_bodyDisjunction->terms[beginTerm].frameLocation = frameLocation;
1931	}
1932
1933	void atomParenthesesOnceEnd(unsigned inputPosition, unsigned frameLocation, Checked<unsigned> quantityMinCount, Checked<unsigned> quantityMaxCount, QuantifierType quantityType)
1934	{
1935	unsigned beginTerm = popParenthesesStack();
1936	closeAlternative(beginTerm: beginTerm + 1);
1937	unsigned endTerm = m_bodyDisjunction->terms.size();
1938
1939	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeParenthesesSubpatternOnceBegin);
1940
1941	bool capture = m_bodyDisjunction->terms[beginTerm].capture();
1942	unsigned subpatternId = m_bodyDisjunction->terms[beginTerm].atom.subpatternId;
1943
1944	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParenthesesSubpatternOnceEnd, subpatternId, capture, false, inputPosition));
1945	m_bodyDisjunction->terms[beginTerm].atom.parenthesesWidth = endTerm - beginTerm;
1946	m_bodyDisjunction->terms[endTerm].atom.parenthesesWidth = endTerm - beginTerm;
1947	m_bodyDisjunction->terms[endTerm].frameLocation = frameLocation;
1948
1949	m_bodyDisjunction->terms[beginTerm].atom.quantityMinCount = quantityMinCount.unsafeGet();
1950	m_bodyDisjunction->terms[beginTerm].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1951	m_bodyDisjunction->terms[beginTerm].atom.quantityType = quantityType;
1952	m_bodyDisjunction->terms[endTerm].atom.quantityMinCount = quantityMinCount.unsafeGet();
1953	m_bodyDisjunction->terms[endTerm].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1954	m_bodyDisjunction->terms[endTerm].atom.quantityType = quantityType;
1955	}
1956
1957	void atomParenthesesTerminalEnd(unsigned inputPosition, unsigned frameLocation, Checked<unsigned> quantityMinCount, Checked<unsigned> quantityMaxCount, QuantifierType quantityType)
1958	{
1959	unsigned beginTerm = popParenthesesStack();
1960	closeAlternative(beginTerm: beginTerm + 1);
1961	unsigned endTerm = m_bodyDisjunction->terms.size();
1962
1963	ASSERT(m_bodyDisjunction->terms[beginTerm].type == ByteTerm::TypeParenthesesSubpatternTerminalBegin);
1964
1965	bool capture = m_bodyDisjunction->terms[beginTerm].capture();
1966	unsigned subpatternId = m_bodyDisjunction->terms[beginTerm].atom.subpatternId;
1967
1968	m_bodyDisjunction->terms.append(other: ByteTerm(ByteTerm::TypeParenthesesSubpatternTerminalEnd, subpatternId, capture, false, inputPosition));
1969	m_bodyDisjunction->terms[beginTerm].atom.parenthesesWidth = endTerm - beginTerm;
1970	m_bodyDisjunction->terms[endTerm].atom.parenthesesWidth = endTerm - beginTerm;
1971	m_bodyDisjunction->terms[endTerm].frameLocation = frameLocation;
1972
1973	m_bodyDisjunction->terms[beginTerm].atom.quantityMinCount = quantityMinCount.unsafeGet();
1974	m_bodyDisjunction->terms[beginTerm].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1975	m_bodyDisjunction->terms[beginTerm].atom.quantityType = quantityType;
1976	m_bodyDisjunction->terms[endTerm].atom.quantityMinCount = quantityMinCount.unsafeGet();
1977	m_bodyDisjunction->terms[endTerm].atom.quantityMaxCount = quantityMaxCount.unsafeGet();
1978	m_bodyDisjunction->terms[endTerm].atom.quantityType = quantityType;
1979	}
1980
1981	void regexBegin(unsigned numSubpatterns, unsigned callFrameSize, bool onceThrough)
1982	{
1983	m_bodyDisjunction = std::make_unique<ByteDisjunction>(args&: numSubpatterns, args&: callFrameSize);
1984	m_bodyDisjunction->terms.append(other: ByteTerm::BodyAlternativeBegin(onceThrough));
1985	m_bodyDisjunction->terms[0].frameLocation = 0;
1986	m_currentAlternativeIndex = 0;
1987	}
1988
1989	void regexEnd()
1990	{
1991	closeBodyAlternative();
1992	}
1993
1994	void alternativeBodyDisjunction(bool onceThrough)
1995	{
1996	int newAlternativeIndex = m_bodyDisjunction->terms.size();
1997	m_bodyDisjunction->terms[m_currentAlternativeIndex].alternative.next = newAlternativeIndex - m_currentAlternativeIndex;
1998	m_bodyDisjunction->terms.append(other: ByteTerm::BodyAlternativeDisjunction(onceThrough));
1999
2000	m_currentAlternativeIndex = newAlternativeIndex;
2001	}
2002
2003	void alternativeDisjunction()
2004	{
2005	int newAlternativeIndex = m_bodyDisjunction->terms.size();
2006	m_bodyDisjunction->terms[m_currentAlternativeIndex].alternative.next = newAlternativeIndex - m_currentAlternativeIndex;
2007	m_bodyDisjunction->terms.append(other: ByteTerm::AlternativeDisjunction());
2008
2009	m_currentAlternativeIndex = newAlternativeIndex;
2010	}
2011
2012	void emitDisjunction(PatternDisjunction* disjunction, unsigned inputCountAlreadyChecked = 0, unsigned parenthesesInputCountAlreadyChecked = 0)
2013	{
2014	for (unsigned alt = 0; alt < disjunction->m_alternatives.size(); ++alt) {
2015	unsigned currentCountAlreadyChecked = inputCountAlreadyChecked;
2016
2017	PatternAlternative* alternative = disjunction->m_alternatives[alt].get();
2018
2019	if (alt) {
2020	if (disjunction == m_pattern.m_body)
2021	alternativeBodyDisjunction(onceThrough: alternative->onceThrough());
2022	else
2023	alternativeDisjunction();
2024	}
2025
2026	unsigned minimumSize = alternative->m_minimumSize;
2027	ASSERT(minimumSize >= parenthesesInputCountAlreadyChecked);
2028	unsigned countToCheck = minimumSize - parenthesesInputCountAlreadyChecked;
2029
2030	if (countToCheck) {
2031	checkInput(count: countToCheck);
2032	currentCountAlreadyChecked += countToCheck;
2033	}
2034
2035	for (auto& term : alternative->m_terms) {
2036	switch (term.type) {
2037	case PatternTerm::TypeAssertionBOL:
2038	assertionBOL(inputPosition: currentCountAlreadyChecked - term.inputPosition);
2039	break;
2040
2041	case PatternTerm::TypeAssertionEOL:
2042	assertionEOL(inputPosition: currentCountAlreadyChecked - term.inputPosition);
2043	break;
2044
2045	case PatternTerm::TypeAssertionWordBoundary:
2046	assertionWordBoundary(invert: term.invert(), inputPosition: currentCountAlreadyChecked - term.inputPosition);
2047	break;
2048
2049	case PatternTerm::TypePatternCharacter:
2050	atomPatternCharacter(ch: term.patternCharacter, inputPosition: currentCountAlreadyChecked - term.inputPosition, frameLocation: term.frameLocation, quantityMaxCount: term.quantityMaxCount, quantityType: term.quantityType);
2051	break;
2052
2053	case PatternTerm::TypeCharacterClass:
2054	atomCharacterClass(characterClass: term.characterClass, invert: term.invert(), inputPosition: currentCountAlreadyChecked- term.inputPosition, frameLocation: term.frameLocation, quantityMaxCount: term.quantityMaxCount, quantityType: term.quantityType);
2055	break;
2056
2057	case PatternTerm::TypeBackReference:
2058	atomBackReference(subpatternId: term.backReferenceSubpatternId, inputPosition: currentCountAlreadyChecked - term.inputPosition, frameLocation: term.frameLocation, quantityMaxCount: term.quantityMaxCount, quantityType: term.quantityType);
2059	break;
2060
2061	case PatternTerm::TypeForwardReference:
2062	break;
2063
2064	case PatternTerm::TypeParenthesesSubpattern: {
2065	unsigned disjunctionAlreadyCheckedCount = 0;
2066	if (term.quantityMaxCount == 1 && !term.parentheses.isCopy) {
2067	unsigned alternativeFrameLocation = term.frameLocation;
2068	// For QuantifierFixedCount we pre-check the minimum size; for greedy/non-greedy we reserve a slot in the frame.
2069	if (term.quantityType == QuantifierFixedCount)
2070	disjunctionAlreadyCheckedCount = term.parentheses.disjunction->m_minimumSize;
2071	else
2072	alternativeFrameLocation += YarrStackSpaceForBackTrackInfoParenthesesOnce;
2073	ASSERT(currentCountAlreadyChecked >= term.inputPosition);
2074	unsigned delegateEndInputOffset = currentCountAlreadyChecked - term.inputPosition;
2075	atomParenthesesOnceBegin(subpatternId: term.parentheses.subpatternId, capture: term.capture(), inputPosition: disjunctionAlreadyCheckedCount + delegateEndInputOffset, frameLocation: term.frameLocation, alternativeFrameLocation);
2076	emitDisjunction(disjunction: term.parentheses.disjunction, inputCountAlreadyChecked: currentCountAlreadyChecked, parenthesesInputCountAlreadyChecked: disjunctionAlreadyCheckedCount);
2077	atomParenthesesOnceEnd(inputPosition: delegateEndInputOffset, frameLocation: term.frameLocation, quantityMinCount: term.quantityMinCount, quantityMaxCount: term.quantityMaxCount, quantityType: term.quantityType);
2078	} else if (term.parentheses.isTerminal) {
2079	ASSERT(currentCountAlreadyChecked >= term.inputPosition);
2080	unsigned delegateEndInputOffset = currentCountAlreadyChecked - term.inputPosition;
2081	atomParenthesesTerminalBegin(subpatternId: term.parentheses.subpatternId, capture: term.capture(), inputPosition: disjunctionAlreadyCheckedCount + delegateEndInputOffset, frameLocation: term.frameLocation, alternativeFrameLocation: term.frameLocation + YarrStackSpaceForBackTrackInfoParenthesesTerminal);
2082	emitDisjunction(disjunction: term.parentheses.disjunction, inputCountAlreadyChecked: currentCountAlreadyChecked, parenthesesInputCountAlreadyChecked: disjunctionAlreadyCheckedCount);
2083	atomParenthesesTerminalEnd(inputPosition: delegateEndInputOffset, frameLocation: term.frameLocation, quantityMinCount: term.quantityMinCount, quantityMaxCount: term.quantityMaxCount, quantityType: term.quantityType);
2084	} else {
2085	ASSERT(currentCountAlreadyChecked >= term.inputPosition);
2086	unsigned delegateEndInputOffset = currentCountAlreadyChecked - term.inputPosition;
2087	atomParenthesesSubpatternBegin(subpatternId: term.parentheses.subpatternId, capture: term.capture(), inputPosition: disjunctionAlreadyCheckedCount + delegateEndInputOffset, frameLocation: term.frameLocation, alternativeFrameLocation: 0);
2088	emitDisjunction(disjunction: term.parentheses.disjunction, inputCountAlreadyChecked: currentCountAlreadyChecked, parenthesesInputCountAlreadyChecked: 0);
2089	atomParenthesesSubpatternEnd(lastSubpatternId: term.parentheses.lastSubpatternId, inputPosition: delegateEndInputOffset, frameLocation: term.frameLocation, quantityMinCount: term.quantityMinCount, quantityMaxCount: term.quantityMaxCount, quantityType: term.quantityType, callFrameSize: term.parentheses.disjunction->m_callFrameSize);
2090	}
2091	break;
2092	}
2093
2094	case PatternTerm::TypeParentheticalAssertion: {
2095	unsigned alternativeFrameLocation = term.frameLocation + YarrStackSpaceForBackTrackInfoParentheticalAssertion;
2096
2097	ASSERT(currentCountAlreadyChecked >= term.inputPosition);
2098	unsigned positiveInputOffset = currentCountAlreadyChecked - term.inputPosition;
2099	unsigned uncheckAmount = 0;
2100	if (positiveInputOffset > term.parentheses.disjunction->m_minimumSize) {
2101	uncheckAmount = positiveInputOffset - term.parentheses.disjunction->m_minimumSize;
2102	uncheckInput(count: uncheckAmount);
2103	currentCountAlreadyChecked -= uncheckAmount;
2104	}
2105
2106	atomParentheticalAssertionBegin(subpatternId: term.parentheses.subpatternId, invert: term.invert(), frameLocation: term.frameLocation, alternativeFrameLocation);
2107	emitDisjunction(disjunction: term.parentheses.disjunction, inputCountAlreadyChecked: currentCountAlreadyChecked, parenthesesInputCountAlreadyChecked: positiveInputOffset - uncheckAmount);
2108	atomParentheticalAssertionEnd(inputPosition: 0, frameLocation: term.frameLocation, quantityMaxCount: term.quantityMaxCount, quantityType: term.quantityType);
2109	if (uncheckAmount) {
2110	checkInput(count: uncheckAmount);
2111	currentCountAlreadyChecked += uncheckAmount;
2112	}
2113	break;
2114	}
2115
2116	case PatternTerm::TypeDotStarEnclosure:
2117	assertionDotStarEnclosure(bolAnchored: term.anchors.bolAnchor, eolAnchored: term.anchors.eolAnchor);
2118	break;
2119	}
2120	}
2121	}
2122	}
2123	#ifndef NDEBUG
2124	void dumpDisjunction(ByteDisjunction* disjunction, unsigned nesting = 0)
2125	{
2126	PrintStream& out = WTF::dataFile();
2127
2128	unsigned termIndexNest = 0;
2129
2130	if (!nesting) {
2131	out.printf(format: "ByteDisjunction(%p):\n", disjunction);
2132	nesting = 1;
2133	} else {
2134	termIndexNest = nesting - 1;
2135	nesting = 2;
2136	}
2137
2138	auto outputTermIndexAndNest = [&](size_t index, unsigned termNesting) {
2139	for (unsigned nestingDepth = 0; nestingDepth < termIndexNest; nestingDepth++)
2140	out.print(value: " ");
2141	#if defined(WIN32) && defined(__MINGW32__)
2142	# if __SIZEOF_POINTER__ == 8
2143	out.printf("%4I64u", index);
2144	# else
2145	out.printf("%4I32u", index);
2146	# endif
2147	#else
2148	out.printf(format: "%4zu", index);
2149	#endif
2150	for (unsigned nestingDepth = 0; nestingDepth < termNesting; nestingDepth++)
2151	out.print(value: " ");
2152	};
2153
2154	auto dumpQuantity = [&](ByteTerm& term) {
2155	if (term.atom.quantityType == QuantifierFixedCount && term.atom.quantityMinCount == 1 && term.atom.quantityMaxCount == 1)
2156	return;
2157
2158	out.print(value1: " {", value2: term.atom.quantityMinCount);
2159	if (term.atom.quantityMinCount != term.atom.quantityMaxCount) {
2160	if (term.atom.quantityMaxCount == UINT_MAX)
2161	out.print(value: ",inf");
2162	else
2163	out.print(value1: ",", value2: term.atom.quantityMaxCount);
2164	}
2165	out.print(value: "}");
2166	if (term.atom.quantityType == QuantifierGreedy)
2167	out.print(value: " greedy");
2168	else if (term.atom.quantityType == QuantifierNonGreedy)
2169	out.print(value: " non-greedy");
2170	};
2171
2172	auto dumpCaptured = [&](ByteTerm& term) {
2173	if (term.capture())
2174	out.print(value1: " captured (#", value2: term.atom.subpatternId, value3: ")");
2175	};
2176
2177	auto dumpInverted = [&](ByteTerm& term) {
2178	if (term.invert())
2179	out.print(value: " inverted");
2180	};
2181
2182	auto dumpInputPosition = [&](ByteTerm& term) {
2183	out.printf(format: " inputPosition %u", term.inputPosition);
2184	};
2185
2186	auto dumpFrameLocation = [&](ByteTerm& term) {
2187	out.printf(format: " frameLocation %u", term.frameLocation);
2188	};
2189
2190	auto dumpCharacter = [&](ByteTerm& term) {
2191	out.print(value: " ");
2192	dumpUChar32(out, term.atom.patternCharacter);
2193	};
2194
2195	auto dumpCharClass = [&](ByteTerm& term) {
2196	out.print(value: " ");
2197	dumpCharacterClass(out, &m_pattern, term.atom.characterClass);
2198	};
2199
2200	for (size_t idx = 0; idx < disjunction->terms.size(); ++idx) {
2201	ByteTerm term = disjunction->terms[idx];
2202
2203	bool outputNewline = true;
2204
2205	switch (term.type) {
2206	case ByteTerm::TypeBodyAlternativeBegin:
2207	outputTermIndexAndNest(idx, nesting++);
2208	out.print(value: "BodyAlternativeBegin");
2209	if (term.alternative.onceThrough)
2210	out.print(value: " onceThrough");
2211	dumpFrameLocation(term);
2212	break;
2213	case ByteTerm::TypeBodyAlternativeDisjunction:
2214	outputTermIndexAndNest(idx, nesting - 1);
2215	out.print(value: "BodyAlternativeDisjunction");
2216	dumpFrameLocation(term);
2217	break;
2218	case ByteTerm::TypeBodyAlternativeEnd:
2219	outputTermIndexAndNest(idx, --nesting);
2220	out.print(value: "BodyAlternativeEnd");
2221	dumpFrameLocation(term);
2222	break;
2223	case ByteTerm::TypeAlternativeBegin:
2224	outputTermIndexAndNest(idx, nesting++);
2225	out.print(value: "AlternativeBegin");
2226	dumpFrameLocation(term);
2227	break;
2228	case ByteTerm::TypeAlternativeDisjunction:
2229	outputTermIndexAndNest(idx, nesting - 1);
2230	out.print(value: "AlternativeDisjunction");
2231	dumpFrameLocation(term);
2232	break;
2233	case ByteTerm::TypeAlternativeEnd:
2234	outputTermIndexAndNest(idx, --nesting);
2235	out.print(value: "AlternativeEnd");
2236	dumpFrameLocation(term);
2237	break;
2238	case ByteTerm::TypeSubpatternBegin:
2239	outputTermIndexAndNest(idx, nesting++);
2240	out.print(value: "SubpatternBegin");
2241	break;
2242	case ByteTerm::TypeSubpatternEnd:
2243	outputTermIndexAndNest(idx, --nesting);
2244	out.print(value: "SubpatternEnd");
2245	break;
2246	case ByteTerm::TypeAssertionBOL:
2247	outputTermIndexAndNest(idx, nesting);
2248	out.print(value: "AssertionBOL");
2249	break;
2250	case ByteTerm::TypeAssertionEOL:
2251	outputTermIndexAndNest(idx, nesting);
2252	out.print(value: "AssertionEOL");
2253	break;
2254	case ByteTerm::TypeAssertionWordBoundary:
2255	outputTermIndexAndNest(idx, nesting);
2256	out.print(value: "AssertionWordBoundary");
2257	break;
2258	case ByteTerm::TypePatternCharacterOnce:
2259	outputTermIndexAndNest(idx, nesting);
2260	out.print(value: "PatternCharacterOnce");
2261	dumpInverted(term);
2262	dumpInputPosition(term);
2263	dumpFrameLocation(term);
2264	dumpCharacter(term);
2265	dumpQuantity(term);
2266	break;
2267	case ByteTerm::TypePatternCharacterFixed:
2268	outputTermIndexAndNest(idx, nesting);
2269	out.print(value: "PatternCharacterFixed");
2270	dumpInverted(term);
2271	dumpInputPosition(term);
2272	dumpFrameLocation(term);
2273	dumpCharacter(term);
2274	out.print(value1: " {", value2: term.atom.quantityMinCount, value3: "}");
2275	break;
2276	case ByteTerm::TypePatternCharacterGreedy:
2277	outputTermIndexAndNest(idx, nesting);
2278	out.print(value: "PatternCharacterGreedy");
2279	dumpInverted(term);
2280	dumpInputPosition(term);
2281	dumpFrameLocation(term);
2282	dumpCharacter(term);
2283	dumpQuantity(term);
2284	break;
2285	case ByteTerm::TypePatternCharacterNonGreedy:
2286	outputTermIndexAndNest(idx, nesting);
2287	out.print(value: "PatternCharacterNonGreedy");
2288	dumpInverted(term);
2289	dumpInputPosition(term);
2290	dumpFrameLocation(term);
2291	dumpCharacter(term);
2292	dumpQuantity(term);
2293	break;
2294	case ByteTerm::TypePatternCasedCharacterOnce:
2295	outputTermIndexAndNest(idx, nesting);
2296	out.print(value: "PatternCasedCharacterOnce");
2297	break;
2298	case ByteTerm::TypePatternCasedCharacterFixed:
2299	outputTermIndexAndNest(idx, nesting);
2300	out.print(value: "PatternCasedCharacterFixed");
2301	break;
2302	case ByteTerm::TypePatternCasedCharacterGreedy:
2303	outputTermIndexAndNest(idx, nesting);
2304	out.print(value: "PatternCasedCharacterGreedy");
2305	break;
2306	case ByteTerm::TypePatternCasedCharacterNonGreedy:
2307	outputTermIndexAndNest(idx, nesting);
2308	out.print(value: "PatternCasedCharacterNonGreedy");
2309	break;
2310	case ByteTerm::TypeCharacterClass:
2311	outputTermIndexAndNest(idx, nesting);
2312	out.print(value: "CharacterClass");
2313	dumpInverted(term);
2314	dumpInputPosition(term);
2315	dumpFrameLocation(term);
2316	dumpCharClass(term);
2317	dumpQuantity(term);
2318	break;
2319	case ByteTerm::TypeBackReference:
2320	outputTermIndexAndNest(idx, nesting);
2321	out.print(value1: "BackReference #", value2: term.atom.subpatternId);
2322	dumpQuantity(term);
2323	break;
2324	case ByteTerm::TypeParenthesesSubpattern:
2325	outputTermIndexAndNest(idx, nesting);
2326	out.print(value: "ParenthesesSubpattern");
2327	dumpCaptured(term);
2328	dumpInverted(term);
2329	dumpInputPosition(term);
2330	dumpFrameLocation(term);
2331	dumpQuantity(term);
2332	out.print(value: "\n");
2333	outputNewline = false;
2334	dumpDisjunction(disjunction: term.atom.parenthesesDisjunction, nesting);
2335	break;
2336	case ByteTerm::TypeParenthesesSubpatternOnceBegin:
2337	outputTermIndexAndNest(idx, nesting++);
2338	out.print(value: "ParenthesesSubpatternOnceBegin");
2339	dumpCaptured(term);
2340	dumpInverted(term);
2341	dumpInputPosition(term);
2342	dumpFrameLocation(term);
2343	break;
2344	case ByteTerm::TypeParenthesesSubpatternOnceEnd:
2345	outputTermIndexAndNest(idx, --nesting);
2346	out.print(value: "ParenthesesSubpatternOnceEnd");
2347	dumpFrameLocation(term);
2348	break;
2349	case ByteTerm::TypeParenthesesSubpatternTerminalBegin:
2350	outputTermIndexAndNest(idx, nesting++);
2351	out.print(value: "ParenthesesSubpatternTerminalBegin");
2352	dumpInverted(term);
2353	dumpInputPosition(term);
2354	dumpFrameLocation(term);
2355	break;
2356	case ByteTerm::TypeParenthesesSubpatternTerminalEnd:
2357	outputTermIndexAndNest(idx, --nesting);
2358	out.print(value: "ParenthesesSubpatternTerminalEnd");
2359	dumpFrameLocation(term);
2360	break;
2361	case ByteTerm::TypeParentheticalAssertionBegin:
2362	outputTermIndexAndNest(idx, nesting++);
2363	out.print(value: "ParentheticalAssertionBegin");
2364	dumpInverted(term);
2365	dumpInputPosition(term);
2366	dumpFrameLocation(term);
2367	break;
2368	case ByteTerm::TypeParentheticalAssertionEnd:
2369	outputTermIndexAndNest(idx, --nesting);
2370	out.print(value: "ParentheticalAssertionEnd");
2371	dumpFrameLocation(term);
2372	break;
2373	case ByteTerm::TypeCheckInput:
2374	outputTermIndexAndNest(idx, nesting);
2375	out.print(value1: "CheckInput ", value2: term.checkInputCount);
2376	break;
2377	case ByteTerm::TypeUncheckInput:
2378	outputTermIndexAndNest(idx, nesting);
2379	out.print(value1: "UncheckInput ", value2: term.checkInputCount);
2380	break;
2381	case ByteTerm::TypeDotStarEnclosure:
2382	outputTermIndexAndNest(idx, nesting);
2383	out.print(value: "DotStarEnclosure");
2384	break;
2385	}
2386	if (outputNewline)
2387	out.print(value: "\n");
2388	}
2389	}
2390	#endif
2391
2392	private:
2393	YarrPattern& m_pattern;
2394	std::unique_ptr<ByteDisjunction> m_bodyDisjunction;
2395	unsigned m_currentAlternativeIndex;
2396	Vector<ParenthesesStackEntry> m_parenthesesStack;
2397	Vector<std::unique_ptr<ByteDisjunction>> m_allParenthesesInfo;
2398	};
2399
2400	std::unique_ptr<BytecodePattern> byteCompile(YarrPattern& pattern, BumpPointerAllocator* allocator, ConcurrentJSLock* lock)
2401	{
2402	return ByteCompiler(pattern).compile(allocator, lock);
2403	}
2404
2405	unsigned interpret(BytecodePattern* bytecode, const String& input, unsigned start, unsigned* output)
2406	{
2407	SuperSamplerScope superSamplerScope(false);
2408	if (input.is8Bit())
2409	return Interpreter<LChar>(bytecode, output, input.characters8(), input.size(), start).interpret();
2410	return Interpreter<UChar>(bytecode, output, input.characters16(), input.size(), start).interpret();
2411	}
2412
2413	unsigned interpret(BytecodePattern* bytecode, const LChar* input, unsigned length, unsigned start, unsigned* output)
2414	{
2415	SuperSamplerScope superSamplerScope(false);
2416	return Interpreter<LChar>(bytecode, output, input, length, start).interpret();
2417	}
2418
2419	unsigned interpret(BytecodePattern* bytecode, const UChar* input, unsigned length, unsigned start, unsigned* output)
2420	{
2421	SuperSamplerScope superSamplerScope(false);
2422	return Interpreter<UChar>(bytecode, output, input, length, start).interpret();
2423	}
2424
2425	// These should be the same for both UChar & LChar.
2426	COMPILE_ASSERT(sizeof(BackTrackInfoPatternCharacter) == (YarrStackSpaceForBackTrackInfoPatternCharacter * sizeof(uintptr_t)), CheckYarrStackSpaceForBackTrackInfoPatternCharacter);
2427	COMPILE_ASSERT(sizeof(BackTrackInfoCharacterClass) == (YarrStackSpaceForBackTrackInfoCharacterClass * sizeof(uintptr_t)), CheckYarrStackSpaceForBackTrackInfoCharacterClass);
2428	COMPILE_ASSERT(sizeof(BackTrackInfoBackReference) == (YarrStackSpaceForBackTrackInfoBackReference * sizeof(uintptr_t)), CheckYarrStackSpaceForBackTrackInfoBackReference);
2429	COMPILE_ASSERT(sizeof(BackTrackInfoAlternative) == (YarrStackSpaceForBackTrackInfoAlternative * sizeof(uintptr_t)), CheckYarrStackSpaceForBackTrackInfoAlternative);
2430	COMPILE_ASSERT(sizeof(BackTrackInfoParentheticalAssertion) == (YarrStackSpaceForBackTrackInfoParentheticalAssertion * sizeof(uintptr_t)), CheckYarrStackSpaceForBackTrackInfoParentheticalAssertion);
2431	COMPILE_ASSERT(sizeof(BackTrackInfoParenthesesOnce) == (YarrStackSpaceForBackTrackInfoParenthesesOnce * sizeof(uintptr_t)), CheckYarrStackSpaceForBackTrackInfoParenthesesOnce);
2432	COMPILE_ASSERT(sizeof(Interpreter<UChar>::BackTrackInfoParentheses) <= (YarrStackSpaceForBackTrackInfoParentheses * sizeof(uintptr_t)), CheckYarrStackSpaceForBackTrackInfoParentheses);
2433
2434
2435	} }
2436