libstdc++

regex_compiler.h
Go to the documentation of this file.
1 // class template regex -*- C++ -*-
2
3 // Copyright (C) 2010-2013 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /**
26 * @file bits/regex_compiler.h
27 * This is an internal header file, included by other library headers.
28 * Do not attempt to use it directly. @headername{regex}
29 */
30
31 namespace std _GLIBCXX_VISIBILITY(default)
32 {
33 namespace __detail
34 {
35 _GLIBCXX_BEGIN_NAMESPACE_VERSION
36
37 /**
38 * @addtogroup regex-detail
39 * @{
40 */
41
42 /// Base class for scanner.
43 struct _Scanner_base
44 {
45 typedef unsigned int _StateT;
46
47 static constexpr _StateT _S_state_at_start = 1 << 0;
48 static constexpr _StateT _S_state_in_brace = 1 << 2;
49 static constexpr _StateT _S_state_in_bracket = 1 << 3;
50
51 virtual ~_Scanner_base() { };
52 };
53
54 /**
55 * @brief struct _Scanner. Scans an input range for regex tokens.
56 *
57 * The %_Scanner class interprets the regular expression pattern in
58 * the input range passed to its constructor as a sequence of parse
59 * tokens passed to the regular expression compiler. The sequence
60 * of tokens provided depends on the flag settings passed to the
61 * constructor: different regular expression grammars will interpret
62 * the same input pattern in syntactically different ways.
63 */
64 template<typename _InputIterator>
65 class _Scanner: public _Scanner_base
66 {
67 public:
68 typedef _InputIterator _IteratorT;
69 typedef typename std::iterator_traits<_IteratorT>::value_type _CharT;
70 typedef std::basic_string<_CharT> _StringT;
71 typedef regex_constants::syntax_option_type _FlagT;
72 typedef const std::ctype<_CharT> _CtypeT;
73
74 /// Token types returned from the scanner.
75 enum _TokenT
76 {
77 _S_token_anychar,
78 _S_token_backref,
79 _S_token_bracket_begin,
80 _S_token_bracket_end,
81 _S_token_inverse_class,
82 _S_token_char_class_name,
83 _S_token_closure0,
84 _S_token_closure1,
85 _S_token_collelem_multi,
86 _S_token_collelem_single,
87 _S_token_collsymbol,
88 _S_token_comma,
89 _S_token_dash,
90 _S_token_dup_count,
91 _S_token_eof,
92 _S_token_equiv_class_name,
93 _S_token_interval_begin,
94 _S_token_interval_end,
95 _S_token_line_begin,
96 _S_token_line_end,
97 _S_token_opt,
98 _S_token_or,
99 _S_token_ord_char,
100 _S_token_quoted_char,
101 _S_token_subexpr_begin,
102 _S_token_subexpr_end,
103 _S_token_word_begin,
104 _S_token_word_end,
105 _S_token_unknown
106 };
107
108 _Scanner(_IteratorT __begin, _IteratorT __end, _FlagT __flags,
109 std::locale __loc)
110 : _M_current(__begin) , _M_end(__end) , _M_flags(__flags),
111 _M_ctype(std::use_facet<_CtypeT>(__loc)), _M_state(_S_state_at_start)
112 { _M_advance(); }
113
114 void
115 _M_advance();
116
117 _TokenT
118 _M_token() const
119 { return _M_curToken; }
120
121 const _StringT&
122 _M_value() const
123 { return _M_curValue; }
124
125 #ifdef _GLIBCXX_DEBUG
126 std::ostream&
127 _M_print(std::ostream&);
128 #endif
129
130 private:
131 void
132 _M_eat_escape();
133
134 void
135 _M_scan_in_brace();
136
137 void
138 _M_scan_in_bracket();
139
140 void
141 _M_eat_charclass();
142
143 void
144 _M_eat_equivclass();
145
146 void
147 _M_eat_collsymbol();
148
149 _IteratorT _M_current;
150 _IteratorT _M_end;
151 _FlagT _M_flags;
152 _CtypeT& _M_ctype;
153 _TokenT _M_curToken;
154 _StringT _M_curValue;
155 _StateT _M_state;
156 };
157
158 template<typename _InputIterator>
159 void
160 _Scanner<_InputIterator>::
161 _M_advance()
162 {
163 if (_M_current == _M_end)
164 {
165 _M_curToken = _S_token_eof;
166 return;
167 }
168
169 _CharT __c = *_M_current;
170 if (_M_state & _S_state_in_bracket)
171 {
172 _M_scan_in_bracket();
173 return;
174 }
175 if (_M_state & _S_state_in_brace)
176 {
177 _M_scan_in_brace();
178 return;
179 }
180 #if 0
181 // TODO: re-enable line anchors when _M_assertion is implemented.
182 // See PR libstdc++/47724
183 else if (_M_state & _S_state_at_start && __c == _M_ctype.widen('^'))
184 {
185 _M_curToken = _S_token_line_begin;
186 ++_M_current;
187 return;
188 }
189 else if (__c == _M_ctype.widen('$'))
190 {
191 _M_curToken = _S_token_line_end;
192 ++_M_current;
193 return;
194 }
195 #endif
196 else if (__c == _M_ctype.widen('.'))
197 {
198 _M_curToken = _S_token_anychar;
199 ++_M_current;
200 return;
201 }
202 else if (__c == _M_ctype.widen('*'))
203 {
204 _M_curToken = _S_token_closure0;
205 ++_M_current;
206 return;
207 }
208 else if (__c == _M_ctype.widen('+'))
209 {
210 _M_curToken = _S_token_closure1;
211 ++_M_current;
212 return;
213 }
214 else if (__c == _M_ctype.widen('|'))
215 {
216 _M_curToken = _S_token_or;
217 ++_M_current;
218 return;
219 }
220 else if (__c == _M_ctype.widen('['))
221 {
222 _M_curToken = _S_token_bracket_begin;
223 _M_state |= (_S_state_in_bracket | _S_state_at_start);
224 ++_M_current;
225 return;
226 }
227 else if (__c == _M_ctype.widen('\\'))
228 {
229 _M_eat_escape();
230 return;
231 }
232 else if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
233 {
234 if (__c == _M_ctype.widen('('))
235 {
236 _M_curToken = _S_token_subexpr_begin;
237 ++_M_current;
238 return;
239 }
240 else if (__c == _M_ctype.widen(')'))
241 {
242 _M_curToken = _S_token_subexpr_end;
243 ++_M_current;
244 return;
245 }
246 else if (__c == _M_ctype.widen('{'))
247 {
248 _M_curToken = _S_token_interval_begin;
249 _M_state |= _S_state_in_brace;
250 ++_M_current;
251 return;
252 }
253 }
254
255 _M_curToken = _S_token_ord_char;
256 _M_curValue.assign(1, __c);
257 ++_M_current;
258 }
259
260
261 template<typename _InputIterator>
262 void
263 _Scanner<_InputIterator>::
264 _M_scan_in_brace()
265 {
266 if (_M_ctype.is(_CtypeT::digit, *_M_current))
267 {
268 _M_curToken = _S_token_dup_count;
269 _M_curValue.assign(1, *_M_current);
270 ++_M_current;
271 while (_M_current != _M_end
272 && _M_ctype.is(_CtypeT::digit, *_M_current))
273 {
274 _M_curValue += *_M_current;
275 ++_M_current;
276 }
277 return;
278 }
279 else if (*_M_current == _M_ctype.widen(','))
280 {
281 _M_curToken = _S_token_comma;
282 ++_M_current;
283 return;
284 }
285 if (_M_flags & (regex_constants::basic | regex_constants::grep))
286 {
287 if (*_M_current == _M_ctype.widen('\\'))
288 _M_eat_escape();
289 }
290 else
291 {
292 if (*_M_current == _M_ctype.widen('}'))
293 {
294 _M_curToken = _S_token_interval_end;
295 _M_state &= ~_S_state_in_brace;
296 ++_M_current;
297 return;
298 }
299 }
300 }
301
302 template<typename _InputIterator>
303 void
304 _Scanner<_InputIterator>::
305 _M_scan_in_bracket()
306 {
307 if (_M_state & _S_state_at_start && *_M_current == _M_ctype.widen('^'))
308 {
309 _M_curToken = _S_token_inverse_class;
310 _M_state &= ~_S_state_at_start;
311 ++_M_current;
312 return;
313 }
314 else if (*_M_current == _M_ctype.widen('['))
315 {
316 ++_M_current;
317 if (_M_current == _M_end)
318 {
319 _M_curToken = _S_token_eof;
320 return;
321 }
322
323 if (*_M_current == _M_ctype.widen('.'))
324 {
325 _M_curToken = _S_token_collsymbol;
326 _M_eat_collsymbol();
327 return;
328 }
329 else if (*_M_current == _M_ctype.widen(':'))
330 {
331 _M_curToken = _S_token_char_class_name;
332 _M_eat_charclass();
333 return;
334 }
335 else if (*_M_current == _M_ctype.widen('='))
336 {
337 _M_curToken = _S_token_equiv_class_name;
338 _M_eat_equivclass();
339 return;
340 }
341 }
342 else if (*_M_current == _M_ctype.widen('-'))
343 {
344 _M_curToken = _S_token_dash;
345 ++_M_current;
346 return;
347 }
348 else if (*_M_current == _M_ctype.widen(']'))
349 {
350 if (!(_M_flags & regex_constants::ECMAScript)
351 || !(_M_state & _S_state_at_start))
352 {
353 // special case: only if _not_ chr first after
354 // '[' or '[^' and if not ECMAscript
355 _M_curToken = _S_token_bracket_end;
356 ++_M_current;
357 return;
358 }
359 }
360 _M_curToken = _S_token_collelem_single;
361 _M_curValue.assign(1, *_M_current);
362 ++_M_current;
363 }
364
365 template<typename _InputIterator>
366 void
367 _Scanner<_InputIterator>::
368 _M_eat_escape()
369 {
370 ++_M_current;
371 if (_M_current == _M_end)
372 {
373 _M_curToken = _S_token_eof;
374 return;
375 }
376 _CharT __c = *_M_current;
377 ++_M_current;
378
379 if (__c == _M_ctype.widen('('))
380 {
381 if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
382 {
383 _M_curToken = _S_token_ord_char;
384 _M_curValue.assign(1, __c);
385 }
386 else
387 _M_curToken = _S_token_subexpr_begin;
388 }
389 else if (__c == _M_ctype.widen(')'))
390 {
391 if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
392 {
393 _M_curToken = _S_token_ord_char;
394 _M_curValue.assign(1, __c);
395 }
396 else
397 _M_curToken = _S_token_subexpr_end;
398 }
399 else if (__c == _M_ctype.widen('{'))
400 {
401 if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
402 {
403 _M_curToken = _S_token_ord_char;
404 _M_curValue.assign(1, __c);
405 }
406 else
407 {
408 _M_curToken = _S_token_interval_begin;
409 _M_state |= _S_state_in_brace;
410 }
411 }
412 else if (__c == _M_ctype.widen('}'))
413 {
414 if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
415 {
416 _M_curToken = _S_token_ord_char;
417 _M_curValue.assign(1, __c);
418 }
419 else
420 {
421 if (!(_M_state && _S_state_in_brace))
422 __throw_regex_error(regex_constants::error_badbrace);
423 _M_state &= ~_S_state_in_brace;
424 _M_curToken = _S_token_interval_end;
425 }
426 }
427 else if (__c == _M_ctype.widen('x'))
428 {
429 ++_M_current;
430 if (_M_current == _M_end)
431 {
432 _M_curToken = _S_token_eof;
433 return;
434 }
435 if (_M_ctype.is(_CtypeT::digit, *_M_current))
436 {
437 _M_curValue.assign(1, *_M_current);
438 ++_M_current;
439 if (_M_current == _M_end)
440 {
441 _M_curToken = _S_token_eof;
442 return;
443 }
444 if (_M_ctype.is(_CtypeT::digit, *_M_current))
445 {
446 _M_curValue += *_M_current;
447 ++_M_current;
448 return;
449 }
450 }
451 }
452 else if (__c == _M_ctype.widen('^')
453 || __c == _M_ctype.widen('.')
454 || __c == _M_ctype.widen('*')
455 || __c == _M_ctype.widen('$')
456 || __c == _M_ctype.widen('\\'))
457 {
458 _M_curToken = _S_token_ord_char;
459 _M_curValue.assign(1, __c);
460 }
461 else if (_M_ctype.is(_CtypeT::digit, __c))
462 {
463 _M_curToken = _S_token_backref;
464 _M_curValue.assign(1, __c);
465 }
466 else
467 __throw_regex_error(regex_constants::error_escape);
468 }
469
470
471 // Eats a character class or throwns an exception.
472 // current point to ':' delimiter on entry, char after ']' on return
473 template<typename _InputIterator>
474 void
475 _Scanner<_InputIterator>::
476 _M_eat_charclass()
477 {
478 ++_M_current; // skip ':'
479 if (_M_current == _M_end)
480 __throw_regex_error(regex_constants::error_ctype);
481 for (_M_curValue.clear();
482 _M_current != _M_end && *_M_current != _M_ctype.widen(':');
483 ++_M_current)
484 _M_curValue += *_M_current;
485 if (_M_current == _M_end)
486 __throw_regex_error(regex_constants::error_ctype);
487 ++_M_current; // skip ':'
488 if (*_M_current != _M_ctype.widen(']'))
489 __throw_regex_error(regex_constants::error_ctype);
490 ++_M_current; // skip ']'
491 }
492
493
494 template<typename _InputIterator>
495 void
496 _Scanner<_InputIterator>::
497 _M_eat_equivclass()
498 {
499 ++_M_current; // skip '='
500 if (_M_current == _M_end)
501 __throw_regex_error(regex_constants::error_collate);
502 for (_M_curValue.clear();
503 _M_current != _M_end && *_M_current != _M_ctype.widen('=');
504 ++_M_current)
505 _M_curValue += *_M_current;
506 if (_M_current == _M_end)
507 __throw_regex_error(regex_constants::error_collate);
508 ++_M_current; // skip '='
509 if (*_M_current != _M_ctype.widen(']'))
510 __throw_regex_error(regex_constants::error_collate);
511 ++_M_current; // skip ']'
512 }
513
514
515 template<typename _InputIterator>
516 void
517 _Scanner<_InputIterator>::
518 _M_eat_collsymbol()
519 {
520 ++_M_current; // skip '.'
521 if (_M_current == _M_end)
522 __throw_regex_error(regex_constants::error_collate);
523 for (_M_curValue.clear();
524 _M_current != _M_end && *_M_current != _M_ctype.widen('.');
525 ++_M_current)
526 _M_curValue += *_M_current;
527 if (_M_current == _M_end)
528 __throw_regex_error(regex_constants::error_collate);
529 ++_M_current; // skip '.'
530 if (*_M_current != _M_ctype.widen(']'))
531 __throw_regex_error(regex_constants::error_collate);
532 ++_M_current; // skip ']'
533 }
534
535 #ifdef _GLIBCXX_DEBUG
536 template<typename _InputIterator>
537 std::ostream&
538 _Scanner<_InputIterator>::
539 _M_print(std::ostream& ostr)
540 {
541 switch (_M_curToken)
542 {
543 case _S_token_anychar:
544 ostr << "any-character\n";
545 break;
546 case _S_token_backref:
547 ostr << "backref\n";
548 break;
549 case _S_token_bracket_begin:
550 ostr << "bracket-begin\n";
551 break;
552 case _S_token_bracket_end:
553 ostr << "bracket-end\n";
554 break;
555 case _S_token_char_class_name:
556 ostr << "char-class-name \"" << _M_curValue << "\"\n";
557 break;
558 case _S_token_closure0:
559 ostr << "closure0\n";
560 break;
561 case _S_token_closure1:
562 ostr << "closure1\n";
563 break;
564 case _S_token_collelem_multi:
565 ostr << "coll-elem-multi \"" << _M_curValue << "\"\n";
566 break;
567 case _S_token_collelem_single:
568 ostr << "coll-elem-single \"" << _M_curValue << "\"\n";
569 break;
570 case _S_token_collsymbol:
571 ostr << "collsymbol \"" << _M_curValue << "\"\n";
572 break;
573 case _S_token_comma:
574 ostr << "comma\n";
575 break;
576 case _S_token_dash:
577 ostr << "dash\n";
578 break;
579 case _S_token_dup_count:
580 ostr << "dup count: " << _M_curValue << "\n";
581 break;
582 case _S_token_eof:
583 ostr << "EOF\n";
584 break;
585 case _S_token_equiv_class_name:
586 ostr << "equiv-class-name \"" << _M_curValue << "\"\n";
587 break;
588 case _S_token_interval_begin:
589 ostr << "interval begin\n";
590 break;
591 case _S_token_interval_end:
592 ostr << "interval end\n";
593 break;
594 case _S_token_line_begin:
595 ostr << "line begin\n";
596 break;
597 case _S_token_line_end:
598 ostr << "line end\n";
599 break;
600 case _S_token_opt:
601 ostr << "opt\n";
602 break;
603 case _S_token_or:
604 ostr << "or\n";
605 break;
606 case _S_token_ord_char:
607 ostr << "ordinary character: \"" << _M_value() << "\"\n";
608 break;
609 case _S_token_quoted_char:
610 ostr << "quoted char\n";
611 break;
612 case _S_token_subexpr_begin:
613 ostr << "subexpr begin\n";
614 break;
615 case _S_token_subexpr_end:
616 ostr << "subexpr end\n";
617 break;
618 case _S_token_word_begin:
619 ostr << "word begin\n";
620 break;
621 case _S_token_word_end:
622 ostr << "word end\n";
623 break;
624 case _S_token_unknown:
625 ostr << "-- unknown token --\n";
626 break;
627 }
628 return ostr;
629 }
630 #endif
631
632 /// Builds an NFA from an input iterator interval.
633 template<typename _InIter, typename _TraitsT>
634 class _Compiler
635 {
636 public:
637 typedef _InIter _IterT;
638 typedef typename std::iterator_traits<_InIter>::value_type _CharT;
639 typedef std::basic_string<_CharT> _StringT;
640 typedef regex_constants::syntax_option_type _FlagT;
641
642 _Compiler(const _InIter& __b, const _InIter& __e,
643 _TraitsT& __traits, _FlagT __flags);
644
645 const _Nfa&
646 _M_nfa() const
647 { return _M_state_store; }
648
649 private:
650 typedef _Scanner<_InIter> _ScannerT;
651 typedef typename _ScannerT::_TokenT _TokenT;
652 typedef std::stack<_StateSeq, std::vector<_StateSeq> > _StackT;
653 typedef _RangeMatcher<_InIter, _TraitsT> _RMatcherT;
654
655 // accepts a specific token or returns false.
656 bool
657 _M_match_token(_TokenT __token);
658
659 void
660 _M_disjunction();
661
662 bool
663 _M_alternative();
664
665 bool
666 _M_term();
667
668 bool
669 _M_assertion();
670
671 bool
672 _M_quantifier();
673
674 bool
675 _M_atom();
676
677 bool
678 _M_bracket_expression();
679
680 bool
681 _M_bracket_list(_RMatcherT& __matcher);
682
683 bool
684 _M_follow_list(_RMatcherT& __matcher);
685
686 bool
687 _M_follow_list2(_RMatcherT& __matcher);
688
689 bool
690 _M_expression_term(_RMatcherT& __matcher);
691
692 bool
693 _M_range_expression(_RMatcherT& __matcher);
694
695 bool
696 _M_start_range(_RMatcherT& __matcher);
697
698 bool
699 _M_collating_symbol(_RMatcherT& __matcher);
700
701 bool
702 _M_equivalence_class(_RMatcherT& __matcher);
703
704 bool
705 _M_character_class(_RMatcherT& __matcher);
706
707 int
708 _M_cur_int_value(int __radix);
709
710 _TraitsT& _M_traits;
711 _ScannerT _M_scanner;
712 _StringT _M_cur_value;
713 _Nfa _M_state_store;
714 _StackT _M_stack;
715 };
716
717 template<typename _InIter, typename _TraitsT>
718 _Compiler<_InIter, _TraitsT>::
719 _Compiler(const _InIter& __b, const _InIter& __e, _TraitsT& __traits,
720 _Compiler<_InIter, _TraitsT>::_FlagT __flags)
721 : _M_traits(__traits), _M_scanner(__b, __e, __flags, _M_traits.getloc()),
722 _M_state_store(__flags)
723 {
724 typedef _StartTagger<_InIter, _TraitsT> _Start;
725 typedef _EndTagger<_InIter, _TraitsT> _End;
726
727 _StateSeq __r(_M_state_store,
728 _M_state_store._M_insert_subexpr_begin(_Start(0)));
729 _M_disjunction();
730 if (!_M_stack.empty())
731 {
732 __r._M_append(_M_stack.top());
733 _M_stack.pop();
734 }
735 __r._M_append(_M_state_store._M_insert_subexpr_end(0, _End(0)));
736 __r._M_append(_M_state_store._M_insert_accept());
737 }
738
739 template<typename _InIter, typename _TraitsT>
740 bool
741 _Compiler<_InIter, _TraitsT>::
742 _M_match_token(_Compiler<_InIter, _TraitsT>::_TokenT token)
743 {
744 if (token == _M_scanner._M_token())
745 {
746 _M_cur_value = _M_scanner._M_value();
747 _M_scanner._M_advance();
748 return true;
749 }
750 return false;
751 }
752
753 template<typename _InIter, typename _TraitsT>
754 void
755 _Compiler<_InIter, _TraitsT>::
756 _M_disjunction()
757 {
758 this->_M_alternative();
759 if (_M_match_token(_ScannerT::_S_token_or))
760 {
761 _StateSeq __alt1 = _M_stack.top(); _M_stack.pop();
762 this->_M_disjunction();
763 _StateSeq __alt2 = _M_stack.top(); _M_stack.pop();
764 _M_stack.push(_StateSeq(__alt1, __alt2));
765 }
766 }
767
768 template<typename _InIter, typename _TraitsT>
769 bool
770 _Compiler<_InIter, _TraitsT>::
771 _M_alternative()
772 {
773 if (this->_M_term())
774 {
775 _StateSeq __re = _M_stack.top(); _M_stack.pop();
776 this->_M_alternative();
777 if (!_M_stack.empty())
778 {
779 __re._M_append(_M_stack.top());
780 _M_stack.pop();
781 }
782 _M_stack.push(__re);
783 return true;
784 }
785 return false;
786 }
787
788 template<typename _InIter, typename _TraitsT>
789 bool
790 _Compiler<_InIter, _TraitsT>::
791 _M_term()
792 {
793 if (this->_M_assertion())
794 return true;
795 if (this->_M_atom())
796 {
797 this->_M_quantifier();
798 return true;
799 }
800 return false;
801 }
802
803 template<typename _InIter, typename _TraitsT>
804 bool
805 _Compiler<_InIter, _TraitsT>::
806 _M_assertion()
807 {
808 if (_M_match_token(_ScannerT::_S_token_line_begin))
809 {
810 // __m.push(_Matcher::_S_opcode_line_begin);
811 return true;
812 }
813 if (_M_match_token(_ScannerT::_S_token_line_end))
814 {
815 // __m.push(_Matcher::_S_opcode_line_end);
816 return true;
817 }
818 if (_M_match_token(_ScannerT::_S_token_word_begin))
819 {
820 // __m.push(_Matcher::_S_opcode_word_begin);
821 return true;
822 }
823 if (_M_match_token(_ScannerT::_S_token_word_end))
824 {
825 // __m.push(_Matcher::_S_opcode_word_end);
826 return true;
827 }
828 return false;
829 }
830
831 template<typename _InIter, typename _TraitsT>
832 bool
833 _Compiler<_InIter, _TraitsT>::
834 _M_quantifier()
835 {
836 if (_M_match_token(_ScannerT::_S_token_closure0))
837 {
838 if (_M_stack.empty())
839 __throw_regex_error(regex_constants::error_badrepeat);
840 _StateSeq __r(_M_stack.top(), -1);
841 __r._M_append(__r._M_front());
842 _M_stack.pop();
843 _M_stack.push(__r);
844 return true;
845 }
846 if (_M_match_token(_ScannerT::_S_token_closure1))
847 {
848 if (_M_stack.empty())
849 __throw_regex_error(regex_constants::error_badrepeat);
850 _StateSeq __r(_M_state_store,
851 _M_state_store.
852 _M_insert_alt(_S_invalid_state_id,
853 _M_stack.top()._M_front()));
854 _M_stack.top()._M_append(__r);
855 return true;
856 }
857 if (_M_match_token(_ScannerT::_S_token_opt))
858 {
859 if (_M_stack.empty())
860 __throw_regex_error(regex_constants::error_badrepeat);
861 _StateSeq __r(_M_stack.top(), -1);
862 _M_stack.pop();
863 _M_stack.push(__r);
864 return true;
865 }
866 if (_M_match_token(_ScannerT::_S_token_interval_begin))
867 {
868 if (_M_stack.empty())
869 __throw_regex_error(regex_constants::error_badrepeat);
870 if (!_M_match_token(_ScannerT::_S_token_dup_count))
871 __throw_regex_error(regex_constants::error_badbrace);
872 _StateSeq __r(_M_stack.top());
873 int __min_rep = _M_cur_int_value(10);
874 for (int __i = 1; __i < __min_rep; ++__i)
875 _M_stack.top()._M_append(__r._M_clone());
876 if (_M_match_token(_ScannerT::_S_token_comma))
877 if (_M_match_token(_ScannerT::_S_token_dup_count))
878 {
879 int __n = _M_cur_int_value(10) - __min_rep;
880 if (__n < 0)
881 __throw_regex_error(regex_constants::error_badbrace);
882 for (int __i = 0; __i < __n; ++__i)
883 {
884 _StateSeq __r(_M_state_store,
885 _M_state_store.
886 _M_insert_alt(_S_invalid_state_id,
887 _M_stack.top()._M_front()));
888 _M_stack.top()._M_append(__r);
889 }
890 }
891 else
892 {
893 _StateSeq __r(_M_stack.top(), -1);
894 __r._M_push_back(__r._M_front());
895 _M_stack.pop();
896 _M_stack.push(__r);
897 }
898 if (!_M_match_token(_ScannerT::_S_token_interval_end))
899 __throw_regex_error(regex_constants::error_brace);
900 return true;
901 }
902 return false;
903 }
904
905 template<typename _InIter, typename _TraitsT>
906 bool
907 _Compiler<_InIter, _TraitsT>::
908 _M_atom()
909 {
910 typedef _CharMatcher<_InIter, _TraitsT> _CMatcher;
911 typedef _StartTagger<_InIter, _TraitsT> _Start;
912 typedef _EndTagger<_InIter, _TraitsT> _End;
913
914 if (_M_match_token(_ScannerT::_S_token_anychar))
915 {
916 _M_stack.push(_StateSeq(_M_state_store,
917 _M_state_store._M_insert_matcher
918 (_AnyMatcher)));
919 return true;
920 }
921 if (_M_match_token(_ScannerT::_S_token_ord_char))
922 {
923 _M_stack.push(_StateSeq(_M_state_store,
924 _M_state_store._M_insert_matcher
925 (_CMatcher(_M_cur_value[0], _M_traits))));
926 return true;
927 }
928 if (_M_match_token(_ScannerT::_S_token_quoted_char))
929 {
930 // note that in the ECMA grammar, this case covers backrefs.
931 _M_stack.push(_StateSeq(_M_state_store,
932 _M_state_store._M_insert_matcher
933 (_CMatcher(_M_cur_value[0], _M_traits))));
934 return true;
935 }
936 if (_M_match_token(_ScannerT::_S_token_backref))
937 {
938 // __m.push(_Matcher::_S_opcode_ordchar, _M_cur_value);
939 return true;
940 }
941 if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
942 {
943 int __mark = _M_state_store._M_sub_count();
944 _StateSeq __r(_M_state_store,
945 _M_state_store.
946 _M_insert_subexpr_begin(_Start(__mark)));
947 this->_M_disjunction();
948 if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
949 __throw_regex_error(regex_constants::error_paren);
950 if (!_M_stack.empty())
951 {
952 __r._M_append(_M_stack.top());
953 _M_stack.pop();
954 }
955 __r._M_append(_M_state_store._M_insert_subexpr_end
956 (__mark, _End(__mark)));
957 _M_stack.push(__r);
958 return true;
959 }
960 return _M_bracket_expression();
961 }
962
963 template<typename _InIter, typename _TraitsT>
964 bool
965 _Compiler<_InIter, _TraitsT>::
966 _M_bracket_expression()
967 {
968 if (_M_match_token(_ScannerT::_S_token_bracket_begin))
969 {
970 _RMatcherT __matcher(_M_match_token(_ScannerT::_S_token_line_begin),
971 _M_traits);
972 if (!_M_bracket_list(__matcher)
973 || !_M_match_token(_ScannerT::_S_token_bracket_end))
974 __throw_regex_error(regex_constants::error_brack);
975 _M_stack.push(_StateSeq(_M_state_store,
976 _M_state_store._M_insert_matcher(__matcher)));
977 return true;
978 }
979 return false;
980 }
981
982 // If the dash is the last character in the bracket expression, it is not
983 // special.
984 template<typename _InIter, typename _TraitsT>
985 bool
986 _Compiler<_InIter, _TraitsT>::
987 _M_bracket_list(_RMatcherT& __matcher)
988 {
989 if (_M_follow_list(__matcher))
990 {
991 if (_M_match_token(_ScannerT::_S_token_dash))
992 __matcher._M_add_char(_M_cur_value[0]);
993 return true;
994 }
995 return false;
996 }
997
998 template<typename _InIter, typename _TraitsT>
999 bool
1000 _Compiler<_InIter, _TraitsT>::
1001 _M_follow_list(_RMatcherT& __matcher)
1002 { return _M_expression_term(__matcher) && _M_follow_list2(__matcher); }
1003
1004 template<typename _InIter, typename _TraitsT>
1005 bool
1006 _Compiler<_InIter, _TraitsT>::
1007 _M_follow_list2(_RMatcherT& __matcher)
1008 {
1009 if (_M_expression_term(__matcher))
1010 return _M_follow_list2(__matcher);
1011 return true;
1012 }
1013
1014 template<typename _InIter, typename _TraitsT>
1015 bool
1016 _Compiler<_InIter, _TraitsT>::
1017 _M_expression_term(_RMatcherT& __matcher)
1018 {
1019 return (_M_collating_symbol(__matcher)
1020 || _M_character_class(__matcher)
1021 || _M_equivalence_class(__matcher)
1022 || (_M_start_range(__matcher)
1023 && _M_range_expression(__matcher)));
1024 }
1025
1026 template<typename _InIter, typename _TraitsT>
1027 bool
1028 _Compiler<_InIter, _TraitsT>::
1029 _M_range_expression(_RMatcherT& __matcher)
1030 {
1031 if (!_M_collating_symbol(__matcher))
1032 if (!_M_match_token(_ScannerT::_S_token_dash))
1033 __throw_regex_error(regex_constants::error_range);
1034 __matcher._M_make_range();
1035 return true;
1036 }
1037
1038 template<typename _InIter, typename _TraitsT>
1039 bool
1040 _Compiler<_InIter, _TraitsT>::
1041 _M_start_range(_RMatcherT& __matcher)
1042 { return _M_match_token(_ScannerT::_S_token_dash); }
1043
1044 template<typename _InIter, typename _TraitsT>
1045 bool
1046 _Compiler<_InIter, _TraitsT>::
1047 _M_collating_symbol(_RMatcherT& __matcher)
1048 {
1049 if (_M_match_token(_ScannerT::_S_token_collelem_single))
1050 {
1051 __matcher._M_add_char(_M_cur_value[0]);
1052 return true;
1053 }
1054 if (_M_match_token(_ScannerT::_S_token_collsymbol))
1055 {
1056 __matcher._M_add_collating_element(_M_cur_value);
1057 return true;
1058 }
1059 return false;
1060 }
1061
1062 template<typename _InIter, typename _TraitsT>
1063 bool
1064 _Compiler<_InIter, _TraitsT>::
1065 _M_equivalence_class(_RMatcherT& __matcher)
1066 {
1067 if (_M_match_token(_ScannerT::_S_token_equiv_class_name))
1068 {
1069 __matcher._M_add_equivalence_class(_M_cur_value);
1070 return true;
1071 }
1072 return false;
1073 }
1074
1075 template<typename _InIter, typename _TraitsT>
1076 bool
1077 _Compiler<_InIter, _TraitsT>::
1078 _M_character_class(_RMatcherT& __matcher)
1079 {
1080 if (_M_match_token(_ScannerT::_S_token_char_class_name))
1081 {
1082 __matcher._M_add_character_class(_M_cur_value);
1083 return true;
1084 }
1085 return false;
1086 }
1087
1088 template<typename _InIter, typename _TraitsT>
1089 int
1090 _Compiler<_InIter, _TraitsT>::
1091 _M_cur_int_value(int __radix)
1092 {
1093 int __v = 0;
1094 for (typename _StringT::size_type __i = 0;
1095 __i < _M_cur_value.length(); ++__i)
1096 __v =__v * __radix + _M_traits.value(_M_cur_value[__i], __radix);
1097 return __v;
1098 }
1099
1100 template<typename _InIter, typename _TraitsT>
1101 _AutomatonPtr
1102 __compile(const _InIter& __b, const _InIter& __e, _TraitsT& __t,
1103 regex_constants::syntax_option_type __f)
1104 { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t,
1105 __f)._M_nfa())); }
1106
1107 //@} regex-detail
1108 _GLIBCXX_END_NAMESPACE_VERSION
1109 } // namespace __detail
1110 } // namespace std