Lines Matching defs:compiler
5 #include "src/regexp/regexp-compiler.h"
33 RegExpNode* RegExpAtom::ToNode(RegExpCompiler* compiler,
36 compiler->zone()->New<ZoneList<TextElement>>(1, compiler->zone());
37 elms->Add(TextElement::Atom(this), compiler->zone());
38 return compiler->zone()->New<TextNode>(elms, compiler->read_backward(),
42 RegExpNode* RegExpText::ToNode(RegExpCompiler* compiler,
44 return compiler->zone()->New<TextNode>(elements(), compiler->read_backward(),
207 void AddBmpCharacters(RegExpCompiler* compiler, ChoiceNode* result,
210 ToCanonicalZoneList(splitter->bmp(), compiler->zone());
213 compiler->zone(), bmp, compiler->read_backward(), on_success)));
227 void AddNonBmpSurrogatePairs(RegExpCompiler* compiler, ChoiceNode* result,
230 DCHECK(!compiler->one_byte());
231 Zone* const zone = compiler->zone();
312 compiler->read_backward(), on_success)));
320 zone, leading_range, trailing_ranges, compiler->read_backward(),
326 RegExpCompiler* compiler, ZoneList<CharacterRange>* lookbehind,
329 Zone* zone = compiler->zone();
332 int stack_register = compiler->UnicodeLookaroundStackRegister();
333 int position_register = compiler->UnicodeLookaroundPositionRegister();
342 RegExpCompiler* compiler, ZoneList<CharacterRange>* match,
345 Zone* zone = compiler->zone();
346 int stack_register = compiler->UnicodeLookaroundStackRegister();
347 int position_register = compiler->UnicodeLookaroundPositionRegister();
356 void AddLoneLeadSurrogates(RegExpCompiler* compiler, ChoiceNode* result,
360 ToCanonicalZoneList(splitter->lead_surrogates(), compiler->zone());
362 Zone* zone = compiler->zone();
368 if (compiler->read_backward()) {
372 compiler, trail_surrogates, lead_surrogates, on_success, true);
377 compiler, lead_surrogates, trail_surrogates, on_success, false);
382 void AddLoneTrailSurrogates(RegExpCompiler* compiler, ChoiceNode* result,
386 ToCanonicalZoneList(splitter->trail_surrogates(), compiler->zone());
388 Zone* zone = compiler->zone();
394 if (compiler->read_backward()) {
398 compiler, trail_surrogates, lead_surrogates, on_success, true);
403 compiler, lead_surrogates, trail_surrogates, on_success, false);
408 RegExpNode* UnanchoredAdvance(RegExpCompiler* compiler,
411 DCHECK(!compiler->read_backward());
412 Zone* zone = compiler->zone();
457 RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
460 Zone* const zone = compiler->zone();
463 if (NeedsUnicodeCaseEquivalents(compiler->flags())) {
467 if (!IsUnicode(compiler->flags()) || compiler->one_byte() ||
469 return zone->New<TextNode>(this, compiler->read_backward(), on_success);
482 return zone->New<TextNode>(fail, compiler->read_backward(), on_success);
487 return UnanchoredAdvance(compiler, on_success);
497 AddBmpCharacters(compiler, result, on_success, &splitter);
498 AddNonBmpSurrogatePairs(compiler, result, on_success, &splitter);
499 AddLoneLeadSurrogates(compiler, result, on_success, &splitter);
500 AddLoneTrailSurrogates(compiler, result, on_success, &splitter);
604 bool RegExpDisjunction::SortConsecutiveAtoms(RegExpCompiler* compiler) {
632 if (IsIgnoreCase(compiler->flags())) {
638 compiler->isolate()->regexp_macro_assembler_canonicalize();
654 void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) {
655 Zone* zone = compiler->zone();
658 const bool ignore_case = IsIgnoreCase(compiler->flags());
674 compiler->isolate()->regexp_macro_assembler_canonicalize();
752 RegExpCompiler* compiler) {
753 Zone* zone = compiler->zone();
772 const RegExpFlags flags = compiler->flags();
818 RegExpNode* RegExpDisjunction::ToNode(RegExpCompiler* compiler,
820 compiler->ToNodeMaybeCheckForStackOverflow();
825 bool found_consecutive_atoms = SortConsecutiveAtoms(compiler);
826 if (found_consecutive_atoms) RationalizeConsecutiveAtoms(compiler);
827 FixSingleCharacterDisjunctions(compiler);
829 return alternatives->at(0)->ToNode(compiler, on_success);
836 compiler->zone()->New<ChoiceNode>(length, compiler->zone());
839 alternatives->at(i)->ToNode(compiler, on_success));
845 RegExpNode* RegExpQuantifier::ToNode(RegExpCompiler* compiler,
847 return ToNode(min(), max(), is_greedy(), body(), compiler, on_success);
853 RegExpNode* BoundaryAssertionAsLookaround(RegExpCompiler* compiler,
858 Zone* zone = compiler->zone();
863 int stack_register = compiler->UnicodeLookaroundStackRegister();
864 int position_register = compiler->UnicodeLookaroundPositionRegister();
889 RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,
892 Zone* zone = compiler->zone();
900 return NeedsUnicodeCaseEquivalents(compiler->flags())
902 compiler, on_success, Type::BOUNDARY, compiler->flags())
905 return NeedsUnicodeCaseEquivalents(compiler->flags())
906 ? BoundaryAssertionAsLookaround(compiler, on_success,
908 compiler->flags())
916 int stack_pointer_register = compiler->AllocateRegister();
917 int position_register = compiler->AllocateRegister();
949 RegExpNode* RegExpBackReference::ToNode(RegExpCompiler* compiler,
951 return compiler->zone()->New<BackReferenceNode>(
953 RegExpCapture::EndRegister(index()), flags_, compiler->read_backward(),
957 RegExpNode* RegExpEmpty::ToNode(RegExpCompiler* compiler,
962 RegExpNode* RegExpGroup::ToNode(RegExpCompiler* compiler,
964 return body_->ToNode(compiler, on_success);
1006 RegExpNode* RegExpLookaround::ToNode(RegExpCompiler* compiler,
1008 int stack_pointer_register = compiler->AllocateRegister();
1009 int position_register = compiler->AllocateRegister();
1018 bool was_reading_backward = compiler->read_backward();
1019 compiler->set_read_backward(type() == LOOKBEHIND);
1022 RegExpNode* match = body_->ToNode(compiler, builder.on_match_success());
1024 compiler->set_read_backward(was_reading_backward);
1028 RegExpNode* RegExpCapture::ToNode(RegExpCompiler* compiler,
1030 return ToNode(body(), index(), compiler, on_success);
1034 RegExpCompiler* compiler,
1039 if (compiler->read_backward()) std::swap(start_reg, end_reg);
1041 RegExpNode* body_node = body->ToNode(compiler, store_end);
1131 RegExpNode* RegExpAlternative::ToNode(RegExpCompiler* compiler,
1133 compiler->ToNodeMaybeCheckForStackOverflow();
1137 AssertionSequenceRewriter::MaybeRewrite(children, compiler->zone());
1140 if (compiler->read_backward()) {
1142 current = children->at(i)->ToNode(compiler, current);
1146 current = children->at(i)->ToNode(compiler, current);
1554 RegExpExpansionLimiter(RegExpCompiler* compiler, int factor)
1555 : compiler_(compiler),
1556 saved_expansion_factor_(compiler->current_expansion_factor()),
1563 compiler->set_current_expansion_factor(kMaxExpansionFactor + 1);
1567 compiler->set_current_expansion_factor(new_factor);
1589 RegExpTree* body, RegExpCompiler* compiler,
1619 Zone* zone = compiler->zone();
1622 body_start_reg = compiler->AllocateRegister();
1623 } else if (compiler->optimize() && !needs_capture_clearing) {
1627 RegExpExpansionLimiter limiter(compiler, min + ((max != min) ? 1 : 0));
1633 ToNode(0, new_max, is_greedy, body, compiler, on_success, true);
1638 answer = body->ToNode(compiler, answer);
1645 RegExpExpansionLimiter limiter(compiler, max);
1653 GuardedAlternative(body->ToNode(compiler, answer)));
1658 GuardedAlternative(body->ToNode(compiler, answer)));
1661 if (not_at_start && !compiler->read_backward()) {
1672 int reg_ctr = needs_counter ? compiler->AllocateRegister()
1675 body->min_match() == 0, compiler->read_backward(), min, zone);
1676 if (not_at_start && !compiler->read_backward()) center->set_not_at_start();
1687 RegExpNode* body_node = body->ToNode(compiler, loop_return);
1704 Guard* rest_guard = compiler->zone()->New<Guard>(reg_ctr, Guard::GEQ, min);