include/boost/regex/v5/perl_matcher_common.hpp

95.9% Lines (399/416) 45.2% List of functions (477/1055)

[ ] prev/next file n p prev/next uncovered line

perl_matcher_common.hpp

f(x) Functions (1055)

Function Calls Lines Blocks

Line	Hits	Source Code
1		/*
2		*
3		* Copyright (c) 2002
4		* John Maddock
5		*
6		* Use, modification and distribution are subject to the
7		* Boost Software License, Version 1.0. (See accompanying file
8		* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9		*
10		*/
11
12		/*
13		* LOCATION: see http://www.boost.org for most recent version.
14		* FILE perl_matcher_common.cpp
15		* VERSION see <boost/version.hpp>
16		* DESCRIPTION: Definitions of perl_matcher member functions that are
17		* common to both the recursive and non-recursive versions.
18		*/
19
20		#ifndef BOOST_REGEX_V5_PERL_MATCHER_COMMON_HPP
21		#define BOOST_REGEX_V5_PERL_MATCHER_COMMON_HPP
22
23		#include <boost/regex/config.hpp>
24
25		#ifndef BOOST_REGEX_STANDALONE
26
27		#include <boost/config.hpp>
28		#if defined(BOOST_HAS_PRAGMA_ONCE)
29		#pragma once
30		#include <boost/regex/v5/perl_matcher.hpp>
31		#endif
32
33		#endif
34
35		#include <boost/regex/v5/basic_regex.hpp>
36		#include <boost/regex/v5/match_flags.hpp>
37		#include <boost/regex/v5/match_results.hpp>
38
39		#ifdef BOOST_REGEX_MSVC
40		# pragma warning(push)
41		#pragma warning(disable:4459)
42		#if BOOST_REGEX_MSVC < 1910
43		#pragma warning(disable:4800)
44		#endif
45		#endif
46
47		namespace boost{
48		namespace BOOST_REGEX_DETAIL_NS{
49
50		#ifdef BOOST_REGEX_MSVC
51		# pragma warning(push)
52		#pragma warning(disable:26812)
53		#endif
54		template <class BidiIterator, class Allocator, class traits>
55	1697799x	void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_regex<char_type, traits>& e, match_flag_type f)
56		{
57		typedef typename std::iterator_traits<BidiIterator>::iterator_category category;
58		typedef typename basic_regex<char_type, traits>::flag_type expression_flag_type;
59
60	1697799x	if(e.empty())
61		{
62		// precondition failure: e is not a valid regex.
63	✗	BOOST_REGEX_DETAIL_THROW(std::invalid_argument("Invalid regular expression object"));
64		}
65	1697799x	pstate = 0;
66	1697799x	m_match_flags = f;
67	1697799x	estimate_max_state_count(static_cast<category*>(0));
68	1697799x	expression_flag_type re_f = re.flags();
69	1697799x	icase = re_f & regex_constants::icase;
70	1697799x	if(!(m_match_flags & (match_perl\|match_posix)))
71		{
72	1697341x	if((re_f & (regbase::main_option_type\|regbase::no_perl_ex)) == 0)
73	1308429x	m_match_flags \|= match_perl;
74	388912x	else if((re_f & (regbase::main_option_type\|regbase::emacs_ex)) == (regbase::basic_syntax_group\|regbase::emacs_ex))
75	95844x	m_match_flags \|= match_perl;
76	293068x	else if((re_f & (regbase::main_option_type\|regbase::literal)) == (regbase::literal))
77	1968x	m_match_flags \|= match_perl;
78		else
79	291100x	m_match_flags \|= match_posix;
80		}
81	1697799x	if(m_match_flags & match_posix)
82		{
83	583092x	m_temp_match.reset(new match_results<BidiIterator, Allocator>());
84	291546x	m_presult = m_temp_match.get();
85		}
86		else
87	1406253x	m_presult = &m_result;
88	1697799x	m_stack_base = 0;
89	1697799x	m_backup_state = 0;
90		// find the value to use for matching word boundaries:
91	1697799x	m_word_mask = re.get_data().m_word_mask;
92		// find bitmask to use for matching '.':
93	1697799x	match_any_mask = static_cast<unsigned char>((f & match_not_dot_newline) ? BOOST_REGEX_DETAIL_NS::test_not_newline : BOOST_REGEX_DETAIL_NS::test_newline);
94		// Disable match_any if requested in the state machine:
95	1697799x	if(e.get_data().m_disable_match_any)
96		{
97	22274x	if (m_match_flags & match_posix)
98	13x	BOOST_REGEX_DETAIL_THROW(std::logic_error("Invalid regex for POSIX-style matching"));
99	22261x	m_match_flags &= regex_constants::match_not_any;
100		}
101	1697786x	}
102		#ifdef BOOST_REGEX_MSVC
103		# pragma warning(pop)
104		#endif
105
106		template <class BidiIterator, class Allocator, class traits>
107	1580010x	void perl_matcher<BidiIterator, Allocator, traits>::estimate_max_state_count(std::random_access_iterator_tag*)
108		{
109		//
110		// How many states should we allow our machine to visit before giving up?
111		// This is a heuristic: it takes the greater of O(N^2) and O(NS^2)
112		// where N is the length of the string, and S is the number of states
113		// in the machine. It's tempting to up this to O(N^2S) or even O(N^2S^2)
114		// but these take unreasonably amounts of time to bale out in pathological
115		// cases.
116		//
117		// Calculate NS^2 first:
118		//
119		static const std::ptrdiff_t k = 100000;
120	1580010x	std::ptrdiff_t dist = std::distance(base, last);
121	1580010x	if(dist == 0)
122	497347x	dist = 1;
123	1580010x	std::ptrdiff_t states = re.size();
124	1580010x	if(states == 0)
125	2016x	states = 1;
126	1580010x	if ((std::numeric_limits<std::ptrdiff_t>::max)() / states < states)
127		{
128	✗	max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits<std::ptrdiff_t>::max)() - 2);
129	✗	return;
130		}
131	1580010x	states *= states;
132	1580010x	if((std::numeric_limits<std::ptrdiff_t>::max)() / dist < states)
133		{
134	✗	max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits<std::ptrdiff_t>::max)() - 2);
135	✗	return;
136		}
137	1580010x	states *= dist;
138	1580010x	if((std::numeric_limits<std::ptrdiff_t>::max)() - k < states)
139		{
140	✗	max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits<std::ptrdiff_t>::max)() - 2);
141	✗	return;
142		}
143	1580010x	states += k;
144
145	1580010x	max_state_count = states;
146
147		//
148		// Now calculate N^2:
149		//
150	1580010x	states = dist;
151	1580010x	if((std::numeric_limits<std::ptrdiff_t>::max)() / dist < states)
152		{
153	✗	max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits<std::ptrdiff_t>::max)() - 2);
154	✗	return;
155		}
156	1580010x	states *= dist;
157	1580010x	if((std::numeric_limits<std::ptrdiff_t>::max)() - k < states)
158		{
159	✗	max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits<std::ptrdiff_t>::max)() - 2);
160	✗	return;
161		}
162	1580010x	states += k;
163		//
164		// N^2 can be a very large number indeed, to prevent things getting out
165		// of control, cap the max states:
166		//
167	1580010x	if(states > BOOST_REGEX_MAX_STATE_COUNT)
168	94x	states = BOOST_REGEX_MAX_STATE_COUNT;
169		//
170		// If (the possibly capped) N^2 is larger than our first estimate,
171		// use this instead:
172		//
173	1580010x	if(states > max_state_count)
174	41232x	max_state_count = states;
175		}
176
177		template <class BidiIterator, class Allocator, class traits>
178	117789x	inline void perl_matcher<BidiIterator, Allocator, traits>::estimate_max_state_count(void*)
179		{
180		// we don't know how long the sequence is:
181	117789x	max_state_count = BOOST_REGEX_MAX_STATE_COUNT;
182	117789x	}
183
184		template <class BidiIterator, class Allocator, class traits>
185	80857x	inline bool perl_matcher<BidiIterator, Allocator, traits>::match()
186		{
187	80857x	return match_imp();
188		}
189
190		template <class BidiIterator, class Allocator, class traits>
191	80857x	bool perl_matcher<BidiIterator, Allocator, traits>::match_imp()
192		{
193		// initialise our stack if we are non-recursive:
194	80857x	save_state_init init(&m_stack_base, &m_backup_state);
195	80857x	used_block_count = BOOST_REGEX_MAX_BLOCKS;
196		#if !defined(BOOST_NO_EXCEPTIONS)
197		try{
198		#endif
199
200		// reset our state machine:
201	80857x	position = base;
202	80857x	search_base = base;
203	80857x	state_count = 0;
204	80857x	m_match_flags \|= regex_constants::match_all;
205	80857x	m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast<typename results_type::size_type>(1u + re.mark_count()), search_base, last);
206	80857x	m_presult->set_base(base);
207	80857x	m_presult->set_named_subs(this->re.get_named_subs());
208	80857x	if(m_match_flags & match_posix)
209	15505x	m_result = *m_presult;
210	80857x	verify_options(re.flags(), m_match_flags);
211	80856x	if(0 == match_prefix())
212	32959x	return false;
213	47891x	return (m_result[0].second == last) && (m_result[0].first == base);
214
215		#if !defined(BOOST_NO_EXCEPTIONS)
216		}
217	14x	catch(...)
218		{
219		// unwind all pushed states, apart from anything else this
220		// ensures that all the states are correctly destructed
221		// not just the memory freed.
222	8x	while(unwind(true)){}
223	7x	throw;
224		}
225		#endif
226	80857x	}
227
228		template <class BidiIterator, class Allocator, class traits>
229	1649510x	inline bool perl_matcher<BidiIterator, Allocator, traits>::find()
230		{
231	1649510x	return find_imp();
232		}
233
234		template <class BidiIterator, class Allocator, class traits>
235	1649510x	bool perl_matcher<BidiIterator, Allocator, traits>::find_imp()
236		{
237		static matcher_proc_type const s_find_vtable[7] =
238		{
239		&perl_matcher<BidiIterator, Allocator, traits>::find_restart_any,
240		&perl_matcher<BidiIterator, Allocator, traits>::find_restart_word,
241		&perl_matcher<BidiIterator, Allocator, traits>::find_restart_line,
242		&perl_matcher<BidiIterator, Allocator, traits>::find_restart_buf,
243		&perl_matcher<BidiIterator, Allocator, traits>::match_prefix,
244		&perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit,
245		&perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit,
246		};
247
248		// initialise our stack if we are non-recursive:
249	1649510x	save_state_init init(&m_stack_base, &m_backup_state);
250	1649510x	used_block_count = BOOST_REGEX_MAX_BLOCKS;
251		#if !defined(BOOST_NO_EXCEPTIONS)
252		try{
253		#endif
254
255	1649510x	state_count = 0;
256	1649510x	if((m_match_flags & regex_constants::match_init) == 0)
257		{
258		// reset our state machine:
259	1616929x	search_base = position = base;
260	1616929x	pstate = re.get_first_state();
261	1616929x	m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast<typename results_type::size_type>(1u + re.mark_count()), base, last);
262	1616929x	m_presult->set_base(base);
263	1616929x	m_presult->set_named_subs(this->re.get_named_subs());
264	1616929x	m_match_flags \|= regex_constants::match_init;
265		}
266		else
267		{
268		// start again:
269	32581x	search_base = position = m_result[0].second;
270		// If last match was null and match_not_null was not set then increment
271		// our start position, otherwise we go into an infinite loop:
272	32581x	if(((m_match_flags & match_not_null) == 0) && (m_result.length() == 0))
273		{
274	3648x	if(position == last)
275	✗	return false;
276		else
277	3648x	++position;
278		}
279		// reset $` start:
280	32581x	m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast<typename results_type::size_type>(1u + re.mark_count()), search_base, last);
281		//if((base != search_base) && (base == backstop))
282		// m_match_flags \|= match_prev_avail;
283		}
284	1649510x	if(m_match_flags & match_posix)
285		{
286	280444x	m_result.set_size(static_cast<typename results_type::size_type>(1u + re.mark_count()), base, last);
287	280444x	m_result.set_base(base);
288		}
289
290	1649510x	verify_options(re.flags(), m_match_flags);
291		// find out what kind of expression we have:
292	1649510x	unsigned type = (m_match_flags & match_continuous) ?
293		static_cast<unsigned int>(regbase::restart_continue)
294	1644974x	: static_cast<unsigned int>(re.get_restart_type());
295
296		// call the appropriate search routine:
297	1649510x	matcher_proc_type proc = s_find_vtable[type];
298	1649510x	return (this->*proc)();
299
300		#if !defined(BOOST_NO_EXCEPTIONS)
301		}
302	14x	catch(...)
303		{
304		// unwind all pushed states, apart from anything else this
305		// ensures that all the states are correctly destructed
306		// not just the memory freed.
307	7x	while(unwind(true)){}
308	7x	throw;
309		}
310		#endif
311	1649510x	}
312
313		template <class BidiIterator, class Allocator, class traits>
314	2655523x	bool perl_matcher<BidiIterator, Allocator, traits>::match_prefix()
315		{
316	2655523x	m_has_partial_match = false;
317	2655523x	m_has_found_match = false;
318	2655523x	pstate = re.get_first_state();
319	2655523x	m_presult->set_first(position);
320	2655523x	restart = position;
321	2655523x	match_all_states();
322	2655510x	if(!m_has_found_match && m_has_partial_match && (m_match_flags & match_partial))
323		{
324	14859x	m_has_found_match = true;
325	14859x	m_presult->set_second(last, 0, false);
326	14859x	position = last;
327	14859x	if((m_match_flags & match_posix) == match_posix)
328		{
329	3552x	m_result.maybe_assign(*m_presult);
330		}
331		}
332		#ifdef BOOST_REGEX_MATCH_EXTRA
333	32x	if(m_has_found_match && (match_extra & m_match_flags))
334		{
335		//
336		// we have a match, reverse the capture information:
337		//
338	140x	for(unsigned i = 0; i < m_presult->size(); ++i)
339		{
340	108x	typename sub_match<BidiIterator>::capture_sequence_type & seq = ((*m_presult)[i]).get_captures();
341	108x	std::reverse(seq.begin(), seq.end());
342		}
343		}
344		#endif
345	2655510x	if(!m_has_found_match)
346	1801194x	position = restart; // reset search postion
347	2655510x	return m_has_found_match;
348		}
349
350		template <class BidiIterator, class Allocator, class traits>
351	38956077x	bool perl_matcher<BidiIterator, Allocator, traits>::match_literal()
352		{
353	38956077x	unsigned int len = static_cast<const re_literal*>(pstate)->length;
354	38956077x	const char_type* what = reinterpret_cast<const char_type>(static_cast<const re_literal>(pstate) + 1);
355		//
356		// compare string with what we stored in
357		// our records:
358	80096675x	for(unsigned int i = 0; i < len; ++i, ++position)
359		{
360	76388756x	if((position == last) \|\| (traits_inst.translate(*position, icase) != what[i]))
361	35248158x	return false;
362		}
363	3707919x	pstate = pstate->next.p;
364	3707919x	return true;
365		}
366
367		template <class BidiIterator, class Allocator, class traits>
368	162614x	bool perl_matcher<BidiIterator, Allocator, traits>::match_start_line()
369		{
370	162614x	if(position == backstop)
371		{
372	91983x	if((m_match_flags & match_prev_avail) == 0)
373		{
374	91981x	if((m_match_flags & match_not_bol) == 0)
375		{
376	89170x	pstate = pstate->next.p;
377	89170x	return true;
378		}
379	2811x	return false;
380		}
381		}
382	70631x	else if(m_match_flags & match_single_line)
383	1224x	return false;
384
385		// check the previous value character:
386	69409x	BidiIterator t(position);
387	69409x	--t;
388	69409x	if(position != last)
389		{
390	33001x	if(is_separator(t) && !((t == static_cast<char_type>('\r')) && (*position == static_cast<char_type>('\n'))) )
391		{
392	11389x	pstate = pstate->next.p;
393	11389x	return true;
394		}
395		}
396	36408x	else if(is_separator(*t))
397		{
398	1272x	pstate = pstate->next.p;
399	1272x	return true;
400		}
401	56748x	return false;
402		}
403
404		template <class BidiIterator, class Allocator, class traits>
405	49925x	bool perl_matcher<BidiIterator, Allocator, traits>::match_end_line()
406		{
407	49925x	if(position != last)
408		{
409	17592x	if(m_match_flags & match_single_line)
410	1824x	return false;
411		// we're not yet at the end so *first is always valid:
412	15768x	if(is_separator(*position))
413		{
414	7968x	if((position != backstop) \|\| (m_match_flags & match_prev_avail))
415		{
416		// check that we're not in the middle of \r\n sequence
417	7968x	BidiIterator t(position);
418	7968x	--t;
419	7968x	if((t == static_cast<char_type>('\r')) && (position == static_cast<char_type>('\n')))
420		{
421	480x	return false;
422		}
423		}
424	7488x	pstate = pstate->next.p;
425	7488x	return true;
426		}
427		}
428	32333x	else if((m_match_flags & match_not_eol) == 0)
429		{
430	30581x	pstate = pstate->next.p;
431	30581x	return true;
432		}
433	9552x	return false;
434		}
435
436		template <class BidiIterator, class Allocator, class traits>
437	182589829x	bool perl_matcher<BidiIterator, Allocator, traits>::match_wild()
438		{
439	182589829x	if(position == last)
440	17255x	return false;
441	182572574x	if(is_separator(position) && ((match_any_mask & static_cast<const re_dot>(pstate)->mask) == 0))
442	3056328x	return false;
443	179516246x	if((*position == char_type(0)) && (m_match_flags & match_not_dot_null))
444	864x	return false;
445	179515382x	pstate = pstate->next.p;
446	179515382x	++position;
447	179515382x	return true;
448		}
449
450		template <class BidiIterator, class Allocator, class traits>
451	63408x	bool perl_matcher<BidiIterator, Allocator, traits>::match_word_boundary()
452		{
453		bool b; // indcates whether next character is a word character
454	63408x	if(position != last)
455		{
456		// prev and this character must be opposites:
457	51984x	b = traits_inst.isctype(*position, m_word_mask);
458		}
459		else
460		{
461	11424x	if (m_match_flags & match_not_eow)
462	1728x	return false;
463	9696x	b = false;
464		}
465	61680x	if((position == backstop) && ((m_match_flags & match_prev_avail) == 0))
466		{
467	12864x	if(m_match_flags & match_not_bow)
468	2280x	return false;
469		else
470	10584x	b ^= false;
471		}
472		else
473		{
474	48816x	--position;
475	48816x	b ^= traits_inst.isctype(*position, m_word_mask);
476	48816x	++position;
477		}
478	59400x	if(b)
479		{
480	37080x	pstate = pstate->next.p;
481	37080x	return true;
482		}
483	22320x	return false; // no match if we get to here...
484		}
485
486		template <class BidiIterator, class Allocator, class traits>
487	9552x	bool perl_matcher<BidiIterator, Allocator, traits>::match_within_word()
488		{
489	9552x	bool b = !match_word_boundary();
490	9552x	if(b)
491	5784x	pstate = pstate->next.p;
492	9552x	return b;
493		/*
494		if(position == last)
495		return false;
496		// both prev and this character must be m_word_mask:
497		bool prev = traits_inst.isctype(*position, m_word_mask);
498		{
499		bool b;
500		if((position == backstop) && ((m_match_flags & match_prev_avail) == 0))
501		return false;
502		else
503		{
504		--position;
505		b = traits_inst.isctype(*position, m_word_mask);
506		++position;
507		}
508		if(b == prev)
509		{
510		pstate = pstate->next.p;
511		return true;
512		}
513		}
514		return false;
515		*/
516		}
517
518		template <class BidiIterator, class Allocator, class traits>
519	43835x	bool perl_matcher<BidiIterator, Allocator, traits>::match_word_start()
520		{
521	43835x	if(position == last)
522	8378x	return false; // can't be starting a word if we're already at the end of input
523	35457x	if(!traits_inst.isctype(*position, m_word_mask))
524	8784x	return false; // next character isn't a word character
525	26673x	if((position == backstop) && ((m_match_flags & match_prev_avail) == 0))
526		{
527	5424x	if(m_match_flags & match_not_bow)
528	1824x	return false; // no previous input
529		}
530		else
531		{
532		// otherwise inside buffer:
533	21249x	BidiIterator t(position);
534	21249x	--t;
535	21249x	if(traits_inst.isctype(*t, m_word_mask))
536	8240x	return false; // previous character not non-word
537		}
538		// OK we have a match:
539	16609x	pstate = pstate->next.p;
540	16609x	return true;
541		}
542
543		template <class BidiIterator, class Allocator, class traits>
544	18898x	bool perl_matcher<BidiIterator, Allocator, traits>::match_word_end()
545		{
546	18898x	if((position == backstop) && ((m_match_flags & match_prev_avail) == 0))
547	4632x	return false; // start of buffer can't be end of word
548	14266x	BidiIterator t(position);
549	14266x	--t;
550	14266x	if(traits_inst.isctype(*t, m_word_mask) == false)
551	5112x	return false; // previous character wasn't a word character
552
553	9154x	if(position == last)
554		{
555	3912x	if(m_match_flags & match_not_eow)
556	912x	return false; // end of buffer but not end of word
557		}
558		else
559		{
560		// otherwise inside buffer:
561	5242x	if(traits_inst.isctype(*position, m_word_mask))
562	1466x	return false; // next character is a word character
563		}
564	6776x	pstate = pstate->next.p;
565	6776x	return true; // if we fall through to here then we've succeeded
566		}
567
568		template <class BidiIterator, class Allocator, class traits>
569	11096x	bool perl_matcher<BidiIterator, Allocator, traits>::match_buffer_start()
570		{
571	11096x	if((position != backstop) \|\| (m_match_flags & match_not_bob))
572	4215x	return false;
573		// OK match:
574	6881x	pstate = pstate->next.p;
575	6881x	return true;
576		}
577
578		template <class BidiIterator, class Allocator, class traits>
579	6639x	bool perl_matcher<BidiIterator, Allocator, traits>::match_buffer_end()
580		{
581	6639x	if((position != last) \|\| (m_match_flags & match_not_eob))
582	2832x	return false;
583		// OK match:
584	3807x	pstate = pstate->next.p;
585	3807x	return true;
586		}
587
588		template <class BidiIterator, class Allocator, class traits>
589	559105x	bool perl_matcher<BidiIterator, Allocator, traits>::match_backref()
590		{
591		//
592		// Compare with what we previously matched.
593		// Note that this succeeds if the backref did not partisipate
594		// in the match, this is in line with ECMAScript, but not Perl
595		// or PCRE.
596		//
597	559105x	int index = static_cast<const re_brace*>(pstate)->index;
598	559105x	if(index >= hash_value_mask)
599		{
600	11952x	named_subexpressions::range_type r = re.get_data().equal_range(index);
601	11952x	BOOST_REGEX_ASSERT(r.first != r.second);
602		do
603		{
604	15984x	index = r.first->index;
605	15984x	++r.first;
606	15984x	}while((r.first != r.second) && ((*m_presult)[index].matched != true));
607		}
608
609	559105x	if((m_match_flags & match_perl) && !(*m_presult)[index].matched)
610	4080x	return false;
611
612	555025x	BidiIterator i = (*m_presult)[index].first;
613	555025x	BidiIterator j = (*m_presult)[index].second;
614	631369x	while(i != j)
615		{
616	575160x	if((position == last) \|\| (traits_inst.translate(position, icase) != traits_inst.translate(i, icase)))
617	498816x	return false;
618	76344x	++i;
619	76344x	++position;
620		}
621	56209x	pstate = pstate->next.p;
622	56209x	return true;
623		}
624
625		template <class BidiIterator, class Allocator, class traits>
626	242335x	bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set()
627		{
628		typedef typename traits::char_class_type char_class_type;
629		// let the traits class do the work:
630	242335x	if(position == last)
631	12572x	return false;
632	229763x	BidiIterator t = re_is_set_member(position, last, static_cast<const re_set_long<char_class_type>*>(pstate), re.get_data(), icase);
633	229763x	if(t != position)
634		{
635	195727x	pstate = pstate->next.p;
636	195727x	position = t;
637	195727x	return true;
638		}
639	34036x	return false;
640		}
641
642		template <class BidiIterator, class Allocator, class traits>
643	569478x	bool perl_matcher<BidiIterator, Allocator, traits>::match_set()
644		{
645	569478x	if(position == last)
646	14748x	return false;
647	554730x	if(static_cast<const re_set>(pstate)->_map[static_cast<unsigned char>(traits_inst.translate(position, icase))])
648		{
649	508518x	pstate = pstate->next.p;
650	508518x	++position;
651	508518x	return true;
652		}
653	46212x	return false;
654		}
655
656		template <class BidiIterator, class Allocator, class traits>
657	4371706x	bool perl_matcher<BidiIterator, Allocator, traits>::match_jump()
658		{
659	4371706x	pstate = static_cast<const re_jump*>(pstate)->alt.p;
660	4371706x	return true;
661		}
662
663		template <class BidiIterator, class Allocator, class traits>
664	3540x	bool perl_matcher<BidiIterator, Allocator, traits>::match_combining()
665		{
666	3540x	if(position == last)
667	1056x	return false;
668	2484x	if(is_combining(traits_inst.translate(*position, icase)))
669	✗	return false;
670	2484x	++position;
671	3036x	while((position != last) && is_combining(traits_inst.translate(*position, icase)))
672	552x	++position;
673	2484x	pstate = pstate->next.p;
674	2484x	return true;
675		}
676
677		template <class BidiIterator, class Allocator, class traits>
678	2280x	bool perl_matcher<BidiIterator, Allocator, traits>::match_soft_buffer_end()
679		{
680	2280x	if(m_match_flags & match_not_eob)
681	456x	return false;
682	1824x	BidiIterator p(position);
683	4032x	while((p != last) && is_separator(traits_inst.translate(*p, icase)))++p;
684	1824x	if(p != last)
685	480x	return false;
686	1344x	pstate = pstate->next.p;
687	1344x	return true;
688		}
689
690		template <class BidiIterator, class Allocator, class traits>
691	5400x	bool perl_matcher<BidiIterator, Allocator, traits>::match_restart_continue()
692		{
693	5400x	if(position == search_base)
694		{
695	4920x	pstate = pstate->next.p;
696	4920x	return true;
697		}
698	480x	return false;
699		}
700
701		template <class BidiIterator, class Allocator, class traits>
702	81384x	bool perl_matcher<BidiIterator, Allocator, traits>::match_backstep()
703		{
704		#ifdef BOOST_REGEX_MSVC
705		#pragma warning(push)
706		#pragma warning(disable:4127)
707		#endif
708		if( ::boost::is_random_access_iterator<BidiIterator>::value)
709		{
710	74808x	std::ptrdiff_t maxlen = std::distance(backstop, position);
711	74808x	if(maxlen < static_cast<const re_brace*>(pstate)->index)
712	26808x	return false;
713	48000x	std::advance(position, -static_cast<const re_brace*>(pstate)->index);
714		}
715		else
716		{
717	6576x	int c = static_cast<const re_brace*>(pstate)->index;
718	16224x	while(c--)
719		{
720	12816x	if(position == backstop)
721	3168x	return false;
722	9648x	--position;
723		}
724		}
725	51408x	pstate = pstate->next.p;
726	51408x	return true;
727		#ifdef BOOST_REGEX_MSVC
728		#pragma warning(pop)
729		#endif
730		}
731
732		template <class BidiIterator, class Allocator, class traits>
733	65792x	inline bool perl_matcher<BidiIterator, Allocator, traits>::match_assert_backref()
734		{
735		// return true if marked sub-expression N has been matched:
736	65792x	int index = static_cast<const re_brace*>(pstate)->index;
737	65792x	bool result = false;
738	65792x	if(index == 9999)
739		{
740		// Magic value for a (DEFINE) block:
741	12336x	return false;
742		}
743	53456x	else if(index > 0)
744		{
745		// Have we matched subexpression "index"?
746		// Check if index is a hash value:
747	24416x	if(index >= hash_value_mask)
748		{
749	1824x	named_subexpressions::range_type r = re.get_data().equal_range(index);
750	2736x	while(r.first != r.second)
751		{
752	1824x	if((*m_presult)[r.first->index].matched)
753		{
754	912x	result = true;
755	912x	break;
756		}
757	912x	++r.first;
758		}
759		}
760		else
761		{
762	22592x	result = (*m_presult)[index].matched;
763		}
764	24416x	pstate = pstate->next.p;
765		}
766		else
767		{
768		// Have we recursed into subexpression "index"?
769		// If index == 0 then check for any recursion at all, otherwise for recursion to -index-1.
770	29040x	int idx = -(index+1);
771	29040x	if(idx >= hash_value_mask)
772		{
773	5808x	named_subexpressions::range_type r = re.get_data().equal_range(idx);
774	5808x	int stack_index = recursion_stack.empty() ? -1 : recursion_stack.back().idx;
775	9072x	while(r.first != r.second)
776		{
777	5808x	result \|= (stack_index == r.first->index);
778	5808x	if(result)break;
779	3264x	++r.first;
780		}
781		}
782		else
783		{
784	23232x	result = !recursion_stack.empty() && ((recursion_stack.back().idx == idx) \|\| (index == 0));
785		}
786	29040x	pstate = pstate->next.p;
787		}
788	53456x	return result;
789		}
790
791		template <class BidiIterator, class Allocator, class traits>
792	11376x	bool perl_matcher<BidiIterator, Allocator, traits>::match_fail()
793		{
794		// Just force a backtrack:
795	11376x	return false;
796		}
797
798		template <class BidiIterator, class Allocator, class traits>
799	5450x	bool perl_matcher<BidiIterator, Allocator, traits>::match_accept()
800		{
801	5450x	if(!recursion_stack.empty())
802		{
803	1872x	return skip_until_paren(recursion_stack.back().idx);
804		}
805		else
806		{
807	3578x	return skip_until_paren(INT_MAX);
808		}
809		}
810
811		template <class BidiIterator, class Allocator, class traits>
812	1481714x	bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_any()
813		{
814		#ifdef BOOST_REGEX_MSVC
815		#pragma warning(push)
816		#pragma warning(disable:4127)
817		#endif
818	1481714x	const unsigned char* _map = re.get_map();
819		while(true)
820		{
821		// skip everything we can't match:
822	3855117x	while((position != last) && !can_start(*position, _map, (unsigned char)mask_any) )
823	922377x	++position;
824	2932740x	if(position == last)
825		{
826		// run out of characters, try a null match if possible:
827	761710x	if(re.can_be_null())
828	219914x	return match_prefix();
829	541796x	break;
830		}
831		// now try and obtain a match:
832	2171030x	if(match_prefix())
833	707349x	return true;
834	1463674x	if(position == last)
835	12648x	return false;
836	1451026x	++position;
837		}
838	541796x	return false;
839		#ifdef BOOST_REGEX_MSVC
840		#pragma warning(pop)
841		#endif
842		}
843
844		template <class BidiIterator, class Allocator, class traits>
845	23280x	bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_word()
846		{
847		#ifdef BOOST_REGEX_MSVC
848		#pragma warning(push)
849		#pragma warning(disable:4127)
850		#endif
851		// do search optimised for word starts:
852	23280x	const unsigned char* _map = re.get_map();
853	23280x	if((m_match_flags & match_prev_avail) \|\| (position != base))
854	480x	--position;
855	22800x	else if(match_prefix())
856	2112x	return true;
857		do
858		{
859	36960x	while((position != last) && traits_inst.isctype(*position, m_word_mask))
860	15792x	++position;
861	37584x	while((position != last) && !traits_inst.isctype(*position, m_word_mask))
862	16416x	++position;
863	21168x	if(position == last)
864	12840x	break;
865
866	8328x	if(can_start(*position, _map, (unsigned char)mask_any) )
867		{
868	8328x	if(match_prefix())
869	8328x	return true;
870		}
871	✗	if(position == last)
872	✗	break;
873		} while(true);
874	12840x	return false;
875		#ifdef BOOST_REGEX_MSVC
876		#pragma warning(pop)
877		#endif
878		}
879
880		template <class BidiIterator, class Allocator, class traits>
881	126534x	bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_line()
882		{
883		// do search optimised for line starts:
884	126534x	const unsigned char* _map = re.get_map();
885	126534x	if(match_prefix())
886	50268x	return true;
887	79143x	while(position != last)
888		{
889	262782x	while((position != last) && !is_separator(*position))
890	219975x	++position;
891	42807x	if(position == last)
892	32448x	return false;
893	10359x	++position;
894	10359x	if(position == last)
895		{
896	1560x	if(re.can_be_null() && match_prefix())
897	408x	return true;
898	1152x	return false;
899		}
900
901	8799x	if( can_start(*position, _map, (unsigned char)mask_any) )
902		{
903	7863x	if(match_prefix())
904	5917x	return true;
905		}
906	2882x	if(position == last)
907	5x	return false;
908		//++position;
909		}
910	36336x	return false;
911		}
912
913		template <class BidiIterator, class Allocator, class traits>
914	8622x	bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_buf()
915		{
916	8622x	if((position == base) && ((m_match_flags & match_not_bob) == 0))
917	8430x	return match_prefix();
918	192x	return false;
919		}
920
921		template <class BidiIterator, class Allocator, class traits>
922	✗	bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit()
923		{
924	✗	return false;
925		}
926
927		} // namespace BOOST_REGEX_DETAIL_NS
928
929		} // namespace boost
930
931		#ifdef BOOST_REGEX_MSVC
932		# pragma warning(pop)
933		#endif
934
935		#endif
936
937