source: Daodan/MSYS2/mingw32/include/c++/11.2.0/tr1/regex@ 1171

Last change on this file since 1171 was 1166, checked in by rossy, 3 years ago

Daodan: Replace MinGW build env with an up-to-date MSYS2 env

File size: 90.7 KB
RevLine 
[1166]1// class template regex -*- C++ -*-
2
3// Copyright (C) 2007-2021 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 tr1/regex
27 * @author Stephen M. Webb <stephen.webb@bregmasoft.ca>
28 * This is a TR1 C++ Library header.
29 */
30
31#ifndef _GLIBCXX_TR1_REGEX
32#define _GLIBCXX_TR1_REGEX 1
33
34#pragma GCC system_header
35
36#include <algorithm>
37#include <bitset>
38#include <iterator>
39#include <locale>
40#include <stdexcept>
41#include <string>
42#include <vector>
43#include <utility>
44#include <sstream>
45
46namespace std _GLIBCXX_VISIBILITY(default)
47{
48_GLIBCXX_BEGIN_NAMESPACE_VERSION
49
50namespace tr1
51{
52/**
53 * @defgroup tr1_regex Regular Expressions
54 * A facility for performing regular expression pattern matching.
55 */
56 ///@{
57
58/** @namespace std::regex_constants
59 * @brief ISO C++ 0x entities sub namespace for regex.
60 */
61namespace regex_constants
62{
63 /**
64 * @name 5.1 Regular Expression Syntax Options
65 */
66 ///@{
67 enum __syntax_option
68 {
69 _S_icase,
70 _S_nosubs,
71 _S_optimize,
72 _S_collate,
73 _S_ECMAScript,
74 _S_basic,
75 _S_extended,
76 _S_awk,
77 _S_grep,
78 _S_egrep,
79 _S_syntax_last
80 };
81
82 /**
83 * @brief This is a bitmask type indicating how to interpret the regex.
84 *
85 * The @c syntax_option_type is implementation defined but it is valid to
86 * perform bitwise operations on these values and expect the right thing to
87 * happen.
88 *
89 * A valid value of type syntax_option_type shall have exactly one of the
90 * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep
91 * %set.
92 */
93 typedef unsigned int syntax_option_type;
94
95 /**
96 * Specifies that the matching of regular expressions against a character
97 * sequence shall be performed without regard to case.
98 */
99 static const syntax_option_type icase = 1 << _S_icase;
100
101 /**
102 * Specifies that when a regular expression is matched against a character
103 * container sequence, no sub-expression matches are to be stored in the
104 * supplied match_results structure.
105 */
106 static const syntax_option_type nosubs = 1 << _S_nosubs;
107
108 /**
109 * Specifies that the regular expression engine should pay more attention to
110 * the speed with which regular expressions are matched, and less to the
111 * speed with which regular expression objects are constructed. Otherwise
112 * it has no detectable effect on the program output.
113 */
114 static const syntax_option_type optimize = 1 << _S_optimize;
115
116 /**
117 * Specifies that character ranges of the form [a-b] should be locale
118 * sensitive.
119 */
120 static const syntax_option_type collate = 1 << _S_collate;
121
122 /**
123 * Specifies that the grammar recognized by the regular expression engine is
124 * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript
125 * Language Specification, Standard Ecma-262, third edition, 1999], as
126 * modified in tr1 section [7.13]. This grammar is similar to that defined
127 * in the PERL scripting language but extended with elements found in the
128 * POSIX regular expression grammar.
129 */
130 static const syntax_option_type ECMAScript = 1 << _S_ECMAScript;
131
132 /**
133 * Specifies that the grammar recognized by the regular expression engine is
134 * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001,
135 * Portable Operating System Interface (POSIX), Base Definitions and
136 * Headers, Section 9, Regular Expressions [IEEE, Information Technology --
137 * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
138 */
139 static const syntax_option_type basic = 1 << _S_basic;
140
141 /**
142 * Specifies that the grammar recognized by the regular expression engine is
143 * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001,
144 * Portable Operating System Interface (POSIX), Base Definitions and Headers,
145 * Section 9, Regular Expressions.
146 */
147 static const syntax_option_type extended = 1 << _S_extended;
148
149 /**
150 * Specifies that the grammar recognized by the regular expression engine is
151 * that used by POSIX utility awk in IEEE Std 1003.1-2001. This option is
152 * identical to syntax_option_type extended, except that C-style escape
153 * sequences are supported. These sequences are:
154 * \\\\, \\a, \\b, \\f,
155 * \\n, \\r, \\t , \\v,
156 * \\&apos;, &apos;, and \\ddd
157 * (where ddd is one, two, or three octal digits).
158 */
159 static const syntax_option_type awk = 1 << _S_awk;
160
161 /**
162 * Specifies that the grammar recognized by the regular expression engine is
163 * that used by POSIX utility grep in IEEE Std 1003.1-2001. This option is
164 * identical to syntax_option_type basic, except that newlines are treated
165 * as whitespace.
166 */
167 static const syntax_option_type grep = 1 << _S_grep;
168
169 /**
170 * Specifies that the grammar recognized by the regular expression engine is
171 * that used by POSIX utility grep when given the -E option in
172 * IEEE Std 1003.1-2001. This option is identical to syntax_option_type
173 * extended, except that newlines are treated as whitespace.
174 */
175 static const syntax_option_type egrep = 1 << _S_egrep;
176
177 ///@}
178
179 /**
180 * @name 5.2 Matching Rules
181 *
182 * Matching a regular expression against a sequence of characters [first,
183 * last) proceeds according to the rules of the grammar specified for the
184 * regular expression object, modified according to the effects listed
185 * below for any bitmask elements set.
186 *
187 */
188 ///@{
189
190 enum __match_flag
191 {
192 _S_not_bol,
193 _S_not_eol,
194 _S_not_bow,
195 _S_not_eow,
196 _S_any,
197 _S_not_null,
198 _S_continuous,
199 _S_prev_avail,
200 _S_sed,
201 _S_no_copy,
202 _S_first_only,
203 _S_match_flag_last
204 };
205
206 /**
207 * @brief This is a bitmask type indicating regex matching rules.
208 *
209 * The @c match_flag_type is implementation defined but it is valid to
210 * perform bitwise operations on these values and expect the right thing to
211 * happen.
212 */
213 typedef std::bitset<_S_match_flag_last> match_flag_type;
214
215 /**
216 * The default matching rules.
217 */
218 static const match_flag_type match_default = 0;
219
220 /**
221 * The first character in the sequence [first, last) is treated as though it
222 * is not at the beginning of a line, so the character (^) in the regular
223 * expression shall not match [first, first).
224 */
225 static const match_flag_type match_not_bol = 1 << _S_not_bol;
226
227 /**
228 * The last character in the sequence [first, last) is treated as though it
229 * is not at the end of a line, so the character ($) in the regular
230 * expression shall not match [last, last).
231 */
232 static const match_flag_type match_not_eol = 1 << _S_not_eol;
233
234 /**
235 * The expression \\b is not matched against the sub-sequence
236 * [first,first).
237 */
238 static const match_flag_type match_not_bow = 1 << _S_not_bow;
239
240 /**
241 * The expression \\b should not be matched against the sub-sequence
242 * [last,last).
243 */
244 static const match_flag_type match_not_eow = 1 << _S_not_eow;
245
246 /**
247 * If more than one match is possible then any match is an acceptable
248 * result.
249 */
250 static const match_flag_type match_any = 1 << _S_any;
251
252 /**
253 * The expression does not match an empty sequence.
254 */
255 static const match_flag_type match_not_null = 1 << _S_not_null;
256
257 /**
258 * The expression only matches a sub-sequence that begins at first .
259 */
260 static const match_flag_type match_continuous = 1 << _S_continuous;
261
262 /**
263 * --first is a valid iterator position. When this flag is set then the
264 * flags match_not_bol and match_not_bow are ignored by the regular
265 * expression algorithms 7.11 and iterators 7.12.
266 */
267 static const match_flag_type match_prev_avail = 1 << _S_prev_avail;
268
269 /**
270 * When a regular expression match is to be replaced by a new string, the
271 * new string is constructed using the rules used by the ECMAScript replace
272 * function in ECMA- 262 [Ecma International, ECMAScript Language
273 * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11
274 * String.prototype.replace. In addition, during search and replace
275 * operations all non-overlapping occurrences of the regular expression
276 * are located and replaced, and sections of the input that did not match
277 * the expression are copied unchanged to the output string.
278 *
279 * Format strings (from ECMA-262 [15.5.4.11]):
280 * @li $$ The dollar-sign itself ($)
281 * @li $& The matched substring.
282 * @li $` The portion of @a string that precedes the matched substring.
283 * This would be match_results::prefix().
284 * @li $' The portion of @a string that follows the matched substring.
285 * This would be match_results::suffix().
286 * @li $n The nth capture, where n is in [1,9] and $n is not followed by a
287 * decimal digit. If n <= match_results::size() and the nth capture
288 * is undefined, use the empty string instead. If n >
289 * match_results::size(), the result is implementation-defined.
290 * @li $nn The nnth capture, where nn is a two-digit decimal number on
291 * [01, 99]. If nn <= match_results::size() and the nth capture is
292 * undefined, use the empty string instead. If
293 * nn > match_results::size(), the result is implementation-defined.
294 */
295 static const match_flag_type format_default = 0;
296
297 /**
298 * When a regular expression match is to be replaced by a new string, the
299 * new string is constructed using the rules used by the POSIX sed utility
300 * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable
301 * Operating System Interface (POSIX), IEEE Standard 1003.1-2001].
302 */
303 static const match_flag_type format_sed = 1 << _S_sed;
304
305 /**
306 * During a search and replace operation, sections of the character
307 * container sequence being searched that do not match the regular
308 * expression shall not be copied to the output string.
309 */
310 static const match_flag_type format_no_copy = 1 << _S_no_copy;
311
312 /**
313 * When specified during a search and replace operation, only the first
314 * occurrence of the regular expression shall be replaced.
315 */
316 static const match_flag_type format_first_only = 1 << _S_first_only;
317
318 ///@}
319
320 /**
321 * @name 5.3 Error Types
322 */
323 ///@{
324
325 enum error_type
326 {
327 _S_error_collate,
328 _S_error_ctype,
329 _S_error_escape,
330 _S_error_backref,
331 _S_error_brack,
332 _S_error_paren,
333 _S_error_brace,
334 _S_error_badbrace,
335 _S_error_range,
336 _S_error_space,
337 _S_error_badrepeat,
338 _S_error_complexity,
339 _S_error_stack,
340 _S_error_last
341 };
342
343 /** The expression contained an invalid collating element name. */
344 static const error_type error_collate(_S_error_collate);
345
346 /** The expression contained an invalid character class name. */
347 static const error_type error_ctype(_S_error_ctype);
348
349 /**
350 * The expression contained an invalid escaped character, or a trailing
351 * escape.
352 */
353 static const error_type error_escape(_S_error_escape);
354
355 /** The expression contained an invalid back reference. */
356 static const error_type error_backref(_S_error_backref);
357
358 /** The expression contained mismatched [ and ]. */
359 static const error_type error_brack(_S_error_brack);
360
361 /** The expression contained mismatched ( and ). */
362 static const error_type error_paren(_S_error_paren);
363
364 /** The expression contained mismatched { and } */
365 static const error_type error_brace(_S_error_brace);
366
367 /** The expression contained an invalid range in a {} expression. */
368 static const error_type error_badbrace(_S_error_badbrace);
369
370 /**
371 * The expression contained an invalid character range,
372 * such as [b-a] in most encodings.
373 */
374 static const error_type error_range(_S_error_range);
375
376 /**
377 * There was insufficient memory to convert the expression into a
378 * finite state machine.
379 */
380 static const error_type error_space(_S_error_space);
381
382 /**
383 * One of <em>*?+{</em> was not preceded by a valid regular expression.
384 */
385 static const error_type error_badrepeat(_S_error_badrepeat);
386
387 /**
388 * The complexity of an attempted match against a regular expression
389 * exceeded a pre-set level.
390 */
391 static const error_type error_complexity(_S_error_complexity);
392
393 /**
394 * There was insufficient memory to determine whether the
395 * regular expression could match the specified character sequence.
396 */
397 static const error_type error_stack(_S_error_stack);
398
399 ///@}
400}
401
402 // [7.8] Class regex_error
403 /**
404 * @brief A regular expression exception class.
405 * @ingroup exceptions
406 *
407 * The regular expression library throws objects of this class on error.
408 */
409 class regex_error
410 : public std::runtime_error
411 {
412 public:
413 /**
414 * @brief Constructs a regex_error object.
415 *
416 * @param ecode the regex error code.
417 */
418 explicit
419 regex_error(regex_constants::error_type __ecode)
420 : std::runtime_error("regex_error"), _M_code(__ecode)
421 { }
422
423 /**
424 * @brief Gets the regex error code.
425 *
426 * @returns the regex error code.
427 */
428 regex_constants::error_type
429 code() const
430 { return _M_code; }
431
432 protected:
433 regex_constants::error_type _M_code;
434 };
435
436 // [7.7] Class regex_traits
437 /**
438 * @brief Describes aspects of a regular expression.
439 *
440 * A regular expression traits class that satisfies the requirements of tr1
441 * section [7.2].
442 *
443 * The class %regex is parameterized around a set of related types and
444 * functions used to complete the definition of its semantics. This class
445 * satisfies the requirements of such a traits class.
446 */
447 template<typename _Ch_type>
448 struct regex_traits
449 {
450 public:
451 typedef _Ch_type char_type;
452 typedef std::basic_string<char_type> string_type;
453 typedef std::locale locale_type;
454 typedef std::ctype_base::mask char_class_type;
455
456 public:
457 /**
458 * @brief Constructs a default traits object.
459 */
460 regex_traits()
461 { }
462
463 /**
464 * @brief Gives the length of a C-style string starting at @p __p.
465 *
466 * @param __p a pointer to the start of a character sequence.
467 *
468 * @returns the number of characters between @p *__p and the first
469 * default-initialized value of type @p char_type. In other words, uses
470 * the C-string algorithm for determining the length of a sequence of
471 * characters.
472 */
473 static std::size_t
474 length(const char_type* __p)
475 { return string_type::traits_type::length(__p); }
476
477 /**
478 * @brief Performs the identity translation.
479 *
480 * @param c A character to the locale-specific character set.
481 *
482 * @returns c.
483 */
484 char_type
485 translate(char_type __c) const
486 { return __c; }
487
488 /**
489 * @brief Translates a character into a case-insensitive equivalent.
490 *
491 * @param c A character to the locale-specific character set.
492 *
493 * @returns the locale-specific lower-case equivalent of c.
494 * @throws std::bad_cast if the imbued locale does not support the ctype
495 * facet.
496 */
497 char_type
498 translate_nocase(char_type __c) const
499 {
500 using std::ctype;
501 using std::use_facet;
502 return use_facet<ctype<char_type> >(_M_locale).tolower(__c);
503 }
504
505 /**
506 * @brief Gets a sort key for a character sequence.
507 *
508 * @param first beginning of the character sequence.
509 * @param last one-past-the-end of the character sequence.
510 *
511 * Returns a sort key for the character sequence designated by the
512 * iterator range [F1, F2) such that if the character sequence [G1, G2)
513 * sorts before the character sequence [H1, H2) then
514 * v.transform(G1, G2) < v.transform(H1, H2).
515 *
516 * What this really does is provide a more efficient way to compare a
517 * string to multiple other strings in locales with fancy collation
518 * rules and equivalence classes.
519 *
520 * @returns a locale-specific sort key equivalent to the input range.
521 *
522 * @throws std::bad_cast if the current locale does not have a collate
523 * facet.
524 */
525 template<typename _Fwd_iter>
526 string_type
527 transform(_Fwd_iter __first, _Fwd_iter __last) const
528 {
529 using std::collate;
530 using std::use_facet;
531 const collate<_Ch_type>& __c(use_facet<
532 collate<_Ch_type> >(_M_locale));
533 string_type __s(__first, __last);
534 return __c.transform(__s.data(), __s.data() + __s.size());
535 }
536
537 /**
538 * @brief Dunno.
539 *
540 * @param first beginning of the character sequence.
541 * @param last one-past-the-end of the character sequence.
542 *
543 * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
544 * typeid(collate_byname<_Ch_type>) and the form of the sort key
545 * returned by collate_byname<_Ch_type>::transform(first, last) is known
546 * and can be converted into a primary sort key then returns that key,
547 * otherwise returns an empty string. WTF??
548 *
549 * @todo Implement this function.
550 */
551 template<typename _Fwd_iter>
552 string_type
553 transform_primary(_Fwd_iter __first, _Fwd_iter __last) const;
554
555 /**
556 * @brief Gets a collation element by name.
557 *
558 * @param first beginning of the collation element name.
559 * @param last one-past-the-end of the collation element name.
560 *
561 * @returns a sequence of one or more characters that represents the
562 * collating element consisting of the character sequence designated by
563 * the iterator range [first, last). Returns an empty string if the
564 * character sequence is not a valid collating element.
565 *
566 * @todo Implement this function.
567 */
568 template<typename _Fwd_iter>
569 string_type
570 lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
571
572 /**
573 * @brief Maps one or more characters to a named character
574 * classification.
575 *
576 * @param first beginning of the character sequence.
577 * @param last one-past-the-end of the character sequence.
578 *
579 * @returns an unspecified value that represents the character
580 * classification named by the character sequence designated by the
581 * iterator range [first, last). The value returned shall be independent
582 * of the case of the characters in the character sequence. If the name
583 * is not recognized then returns a value that compares equal to 0.
584 *
585 * At least the following names (or their wide-character equivalent) are
586 * supported.
587 * - d
588 * - w
589 * - s
590 * - alnum
591 * - alpha
592 * - blank
593 * - cntrl
594 * - digit
595 * - graph
596 * - lower
597 * - print
598 * - punct
599 * - space
600 * - upper
601 * - xdigit
602 *
603 * @todo Implement this function.
604 */
605 template<typename _Fwd_iter>
606 char_class_type
607 lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const;
608
609 /**
610 * @brief Determines if @p c is a member of an identified class.
611 *
612 * @param c a character.
613 * @param f a class type (as returned from lookup_classname).
614 *
615 * @returns true if the character @p c is a member of the classification
616 * represented by @p f, false otherwise.
617 *
618 * @throws std::bad_cast if the current locale does not have a ctype
619 * facet.
620 */
621 bool
622 isctype(_Ch_type __c, char_class_type __f) const;
623
624 /**
625 * @brief Converts a digit to an int.
626 *
627 * @param ch a character representing a digit.
628 * @param radix the radix if the numeric conversion (limited to 8, 10,
629 * or 16).
630 *
631 * @returns the value represented by the digit ch in base radix if the
632 * character ch is a valid digit in base radix; otherwise returns -1.
633 */
634 int
635 value(_Ch_type __ch, int __radix) const;
636
637 /**
638 * @brief Imbues the regex_traits object with a copy of a new locale.
639 *
640 * @param loc A locale.
641 *
642 * @returns a copy of the previous locale in use by the regex_traits
643 * object.
644 *
645 * @note Calling imbue with a different locale than the one currently in
646 * use invalidates all cached data held by *this.
647 */
648 locale_type
649 imbue(locale_type __loc)
650 {
651 std::swap(_M_locale, __loc);
652 return __loc;
653 }
654
655 /**
656 * @brief Gets a copy of the current locale in use by the regex_traits
657 * object.
658 */
659 locale_type
660 getloc() const
661 { return _M_locale; }
662
663 protected:
664 locale_type _M_locale;
665 };
666
667 template<typename _Ch_type>
668 bool regex_traits<_Ch_type>::
669 isctype(_Ch_type __c, char_class_type __f) const
670 {
671 using std::ctype;
672 using std::use_facet;
673 const ctype<_Ch_type>& __ctype(use_facet<
674 ctype<_Ch_type> >(_M_locale));
675
676 if (__ctype.is(__c, __f))
677 return true;
678#if 0
679 // special case of underscore in [[:w:]]
680 if (__c == __ctype.widen('_'))
681 {
682 const char* const __wb[] = "w";
683 char_class_type __wt = this->lookup_classname(__wb,
684 __wb + sizeof(__wb));
685 if (__f | __wt)
686 return true;
687 }
688
689 // special case of [[:space:]] in [[:blank:]]
690 if (__c == __ctype.isspace(__c))
691 {
692 const char* const __bb[] = "blank";
693 char_class_type __bt = this->lookup_classname(__bb,
694 __bb + sizeof(__bb));
695 if (__f | __bt)
696 return true;
697 }
698#endif
699 return false;
700 }
701
702 template<typename _Ch_type>
703 int regex_traits<_Ch_type>::
704 value(_Ch_type __ch, int __radix) const
705 {
706 std::basic_istringstream<_Ch_type> __is(string_type(1, __ch));
707 int __v;
708 if (__radix == 8)
709 __is >> std::oct;
710 else if (__radix == 16)
711 __is >> std::hex;
712 __is >> __v;
713 return __is.fail() ? -1 : __v;
714 }
715
716 // [7.8] Class basic_regex
717 /**
718 * Objects of specializations of this class represent regular expressions
719 * constructed from sequences of character type @p _Ch_type.
720 *
721 * Storage for the regular expression is allocated and deallocated as
722 * necessary by the member functions of this class.
723 */
724 template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> >
725 class basic_regex
726 {
727 public:
728 // types:
729 typedef _Ch_type value_type;
730 typedef regex_constants::syntax_option_type flag_type;
731 typedef typename _Rx_traits::locale_type locale_type;
732 typedef typename _Rx_traits::string_type string_type;
733
734 /**
735 * @name Constants
736 * tr1 [7.8.1] std [28.8.1]
737 */
738 ///@{
739 static const regex_constants::syntax_option_type icase
740 = regex_constants::icase;
741 static const regex_constants::syntax_option_type nosubs
742 = regex_constants::nosubs;
743 static const regex_constants::syntax_option_type optimize
744 = regex_constants::optimize;
745 static const regex_constants::syntax_option_type collate
746 = regex_constants::collate;
747 static const regex_constants::syntax_option_type ECMAScript
748 = regex_constants::ECMAScript;
749 static const regex_constants::syntax_option_type basic
750 = regex_constants::basic;
751 static const regex_constants::syntax_option_type extended
752 = regex_constants::extended;
753 static const regex_constants::syntax_option_type awk
754 = regex_constants::awk;
755 static const regex_constants::syntax_option_type grep
756 = regex_constants::grep;
757 static const regex_constants::syntax_option_type egrep
758 = regex_constants::egrep;
759 ///@}
760
761 // [7.8.2] construct/copy/destroy
762 /**
763 * Constructs a basic regular expression that does not match any
764 * character sequence.
765 */
766 basic_regex()
767 : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0)
768 { _M_compile(); }
769
770 /**
771 * @brief Constructs a basic regular expression from the sequence
772 * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the
773 * flags in @p f.
774 *
775 * @param p A pointer to the start of a C-style null-terminated string
776 * containing a regular expression.
777 * @param f Flags indicating the syntax rules and options.
778 *
779 * @throws regex_error if @p p is not a valid regular expression.
780 */
781 explicit
782 basic_regex(const _Ch_type* __p,
783 flag_type __f = regex_constants::ECMAScript)
784 : _M_flags(__f), _M_pattern(__p), _M_mark_count(0)
785 { _M_compile(); }
786
787 /**
788 * @brief Constructs a basic regular expression from the sequence
789 * [p, p + len) interpreted according to the flags in @p f.
790 *
791 * @param p A pointer to the start of a string containing a regular
792 * expression.
793 * @param len The length of the string containing the regular expression.
794 * @param f Flags indicating the syntax rules and options.
795 *
796 * @throws regex_error if @p p is not a valid regular expression.
797 */
798 basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f)
799 : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0)
800 { _M_compile(); }
801
802 /**
803 * @brief Copy-constructs a basic regular expression.
804 *
805 * @param rhs A @p regex object.
806 */
807 basic_regex(const basic_regex& __rhs)
808 : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern),
809 _M_mark_count(__rhs._M_mark_count)
810 { _M_compile(); }
811
812 /**
813 * @brief Constructs a basic regular expression from the string
814 * @p s interpreted according to the flags in @p f.
815 *
816 * @param s A string containing a regular expression.
817 * @param f Flags indicating the syntax rules and options.
818 *
819 * @throws regex_error if @p s is not a valid regular expression.
820 */
821 template<typename _Ch_traits, typename _Ch_alloc>
822 explicit
823 basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
824 flag_type __f = regex_constants::ECMAScript)
825 : _M_flags(__f), _M_pattern(__s.begin(), __s.end()), _M_mark_count(0)
826 { _M_compile(); }
827
828 /**
829 * @brief Constructs a basic regular expression from the range
830 * [first, last) interpreted according to the flags in @p f.
831 *
832 * @param first The start of a range containing a valid regular
833 * expression.
834 * @param last The end of a range containing a valid regular
835 * expression.
836 * @param f The format flags of the regular expression.
837 *
838 * @throws regex_error if @p [first, last) is not a valid regular
839 * expression.
840 */
841 template<typename _InputIterator>
842 basic_regex(_InputIterator __first, _InputIterator __last,
843 flag_type __f = regex_constants::ECMAScript)
844 : _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0)
845 { _M_compile(); }
846
847#ifdef _GLIBCXX_INCLUDE_AS_CXX11
848 /**
849 * @brief Constructs a basic regular expression from an initializer list.
850 *
851 * @param l The initializer list.
852 * @param f The format flags of the regular expression.
853 *
854 * @throws regex_error if @p l is not a valid regular expression.
855 */
856 basic_regex(initializer_list<_Ch_type> __l,
857 flag_type __f = regex_constants::ECMAScript)
858 : _M_flags(__f), _M_pattern(__l.begin(), __l.end()), _M_mark_count(0)
859 { _M_compile(); }
860#endif
861
862 /**
863 * @brief Destroys a basic regular expression.
864 */
865 ~basic_regex()
866 { }
867
868 /**
869 * @brief Assigns one regular expression to another.
870 */
871 basic_regex&
872 operator=(const basic_regex& __rhs)
873 { return this->assign(__rhs); }
874
875 /**
876 * @brief Replaces a regular expression with a new one constructed from
877 * a C-style null-terminated string.
878 *
879 * @param A pointer to the start of a null-terminated C-style string
880 * containing a regular expression.
881 */
882 basic_regex&
883 operator=(const _Ch_type* __p)
884 { return this->assign(__p, flags()); }
885
886 /**
887 * @brief Replaces a regular expression with a new one constructed from
888 * a string.
889 *
890 * @param A pointer to a string containing a regular expression.
891 */
892 template<typename _Ch_typeraits, typename _Allocator>
893 basic_regex&
894 operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s)
895 { return this->assign(__s, flags()); }
896
897 // [7.8.3] assign
898 /**
899 * @brief the real assignment operator.
900 *
901 * @param that Another regular expression object.
902 */
903 basic_regex&
904 assign(const basic_regex& __that)
905 {
906 basic_regex __tmp(__that);
907 this->swap(__tmp);
908 return *this;
909 }
910
911 /**
912 * @brief Assigns a new regular expression to a regex object from a
913 * C-style null-terminated string containing a regular expression
914 * pattern.
915 *
916 * @param p A pointer to a C-style null-terminated string containing
917 * a regular expression pattern.
918 * @param flags Syntax option flags.
919 *
920 * @throws regex_error if p does not contain a valid regular expression
921 * pattern interpreted according to @p flags. If regex_error is thrown,
922 * *this remains unchanged.
923 */
924 basic_regex&
925 assign(const _Ch_type* __p,
926 flag_type __flags = regex_constants::ECMAScript)
927 { return this->assign(string_type(__p), __flags); }
928
929 /**
930 * @brief Assigns a new regular expression to a regex object from a
931 * C-style string containing a regular expression pattern.
932 *
933 * @param p A pointer to a C-style string containing a
934 * regular expression pattern.
935 * @param len The length of the regular expression pattern string.
936 * @param flags Syntax option flags.
937 *
938 * @throws regex_error if p does not contain a valid regular expression
939 * pattern interpreted according to @p flags. If regex_error is thrown,
940 * *this remains unchanged.
941 */
942 basic_regex&
943 assign(const _Ch_type* __p, std::size_t __len, flag_type __flags)
944 { return this->assign(string_type(__p, __len), __flags); }
945
946 /**
947 * @brief Assigns a new regular expression to a regex object from a
948 * string containing a regular expression pattern.
949 *
950 * @param s A string containing a regular expression pattern.
951 * @param flags Syntax option flags.
952 *
953 * @throws regex_error if p does not contain a valid regular expression
954 * pattern interpreted according to @p flags. If regex_error is thrown,
955 * *this remains unchanged.
956 */
957 template<typename _Ch_typeraits, typename _Allocator>
958 basic_regex&
959 assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s,
960 flag_type __f = regex_constants::ECMAScript)
961 {
962 basic_regex __tmp(__s, __f);
963 this->swap(__tmp);
964 return *this;
965 }
966
967 /**
968 * @brief Assigns a new regular expression to a regex object.
969 *
970 * @param first The start of a range containing a valid regular
971 * expression.
972 * @param last The end of a range containing a valid regular
973 * expression.
974 * @param flags Syntax option flags.
975 *
976 * @throws regex_error if p does not contain a valid regular expression
977 * pattern interpreted according to @p flags. If regex_error is thrown,
978 * the object remains unchanged.
979 */
980 template<typename _InputIterator>
981 basic_regex&
982 assign(_InputIterator __first, _InputIterator __last,
983 flag_type __flags = regex_constants::ECMAScript)
984 { return this->assign(string_type(__first, __last), __flags); }
985
986#ifdef _GLIBCXX_INCLUDE_AS_CXX11
987 /**
988 * @brief Assigns a new regular expression to a regex object.
989 *
990 * @param l An initializer list representing a regular expression.
991 * @param flags Syntax option flags.
992 *
993 * @throws regex_error if @p l does not contain a valid regular
994 * expression pattern interpreted according to @p flags. If regex_error
995 * is thrown, the object remains unchanged.
996 */
997 basic_regex&
998 assign(initializer_list<_Ch_type> __l,
999 flag_type __f = regex_constants::ECMAScript)
1000 { return this->assign(__l.begin(), __l.end(), __f); }
1001#endif
1002
1003 // [7.8.4] const operations
1004 /**
1005 * @brief Gets the number of marked subexpressions within the regular
1006 * expression.
1007 */
1008 unsigned int
1009 mark_count() const
1010 { return _M_mark_count; }
1011
1012 /**
1013 * @brief Gets the flags used to construct the regular expression
1014 * or in the last call to assign().
1015 */
1016 flag_type
1017 flags() const
1018 { return _M_flags; }
1019
1020 // [7.8.5] locale
1021 /**
1022 * @brief Imbues the regular expression object with the given locale.
1023 *
1024 * @param loc A locale.
1025 */
1026 locale_type
1027 imbue(locale_type __loc)
1028 { return _M_traits.imbue(__loc); }
1029
1030 /**
1031 * @brief Gets the locale currently imbued in the regular expression
1032 * object.
1033 */
1034 locale_type
1035 getloc() const
1036 { return _M_traits.getloc(); }
1037
1038 // [7.8.6] swap
1039 /**
1040 * @brief Swaps the contents of two regular expression objects.
1041 *
1042 * @param rhs Another regular expression object.
1043 */
1044 void
1045 swap(basic_regex& __rhs)
1046 {
1047 std::swap(_M_flags, __rhs._M_flags);
1048 std::swap(_M_pattern, __rhs._M_pattern);
1049 std::swap(_M_mark_count, __rhs._M_mark_count);
1050 std::swap(_M_traits, __rhs._M_traits);
1051 }
1052
1053 private:
1054 /**
1055 * @brief Compiles a regular expression pattern into a NFA.
1056 * @todo Implement this function.
1057 */
1058 void _M_compile();
1059
1060 protected:
1061 flag_type _M_flags;
1062 string_type _M_pattern;
1063 unsigned int _M_mark_count;
1064 _Rx_traits _M_traits;
1065 };
1066
1067 /** @brief Standard regular expressions. */
1068 typedef basic_regex<char> regex;
1069#ifdef _GLIBCXX_USE_WCHAR_T
1070 /** @brief Standard wide-character regular expressions. */
1071 typedef basic_regex<wchar_t> wregex;
1072#endif
1073
1074
1075 // [7.8.6] basic_regex swap
1076 /**
1077 * @brief Swaps the contents of two regular expression objects.
1078 * @param lhs First regular expression.
1079 * @param rhs Second regular expression.
1080 */
1081 template<typename _Ch_type, typename _Rx_traits>
1082 inline void
1083 swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
1084 basic_regex<_Ch_type, _Rx_traits>& __rhs)
1085 { __lhs.swap(__rhs); }
1086
1087
1088 // [7.9] Class template sub_match
1089 /**
1090 * A sequence of characters matched by a particular marked sub-expression.
1091 *
1092 * An object of this class is essentially a pair of iterators marking a
1093 * matched subexpression within a regular expression pattern match. Such
1094 * objects can be converted to and compared with std::basic_string objects
1095 * of a similar base character type as the pattern matched by the regular
1096 * expression.
1097 *
1098 * The iterators that make up the pair are the usual half-open interval
1099 * referencing the actual original pattern matched.
1100 */
1101 template<typename _BiIter>
1102 class sub_match : public std::pair<_BiIter, _BiIter>
1103 {
1104 public:
1105 typedef typename iterator_traits<_BiIter>::value_type value_type;
1106 typedef typename iterator_traits<_BiIter>::difference_type
1107 difference_type;
1108 typedef _BiIter iterator;
1109
1110 public:
1111 bool matched;
1112
1113 /**
1114 * Gets the length of the matching sequence.
1115 */
1116 difference_type
1117 length() const
1118 { return this->matched ? std::distance(this->first, this->second) : 0; }
1119
1120 /**
1121 * @brief Gets the matching sequence as a string.
1122 *
1123 * @returns the matching sequence as a string.
1124 *
1125 * This is the implicit conversion operator. It is identical to the
1126 * str() member function except that it will want to pop up in
1127 * unexpected places and cause a great deal of confusion and cursing
1128 * from the unwary.
1129 */
1130 operator basic_string<value_type>() const
1131 {
1132 return this->matched
1133 ? std::basic_string<value_type>(this->first, this->second)
1134 : std::basic_string<value_type>();
1135 }
1136
1137 /**
1138 * @brief Gets the matching sequence as a string.
1139 *
1140 * @returns the matching sequence as a string.
1141 */
1142 basic_string<value_type>
1143 str() const
1144 {
1145 return this->matched
1146 ? std::basic_string<value_type>(this->first, this->second)
1147 : std::basic_string<value_type>();
1148 }
1149
1150 /**
1151 * @brief Compares this and another matched sequence.
1152 *
1153 * @param s Another matched sequence to compare to this one.
1154 *
1155 * @retval <0 this matched sequence will collate before @p s.
1156 * @retval =0 this matched sequence is equivalent to @p s.
1157 * @retval <0 this matched sequence will collate after @p s.
1158 */
1159 int
1160 compare(const sub_match& __s) const
1161 { return this->str().compare(__s.str()); }
1162
1163 /**
1164 * @brief Compares this sub_match to a string.
1165 *
1166 * @param s A string to compare to this sub_match.
1167 *
1168 * @retval <0 this matched sequence will collate before @p s.
1169 * @retval =0 this matched sequence is equivalent to @p s.
1170 * @retval <0 this matched sequence will collate after @p s.
1171 */
1172 int
1173 compare(const basic_string<value_type>& __s) const
1174 { return this->str().compare(__s); }
1175
1176 /**
1177 * @brief Compares this sub_match to a C-style string.
1178 *
1179 * @param s A C-style string to compare to this sub_match.
1180 *
1181 * @retval <0 this matched sequence will collate before @p s.
1182 * @retval =0 this matched sequence is equivalent to @p s.
1183 * @retval <0 this matched sequence will collate after @p s.
1184 */
1185 int
1186 compare(const value_type* __s) const
1187 { return this->str().compare(__s); }
1188 };
1189
1190
1191 /** @brief Standard regex submatch over a C-style null-terminated string. */
1192 typedef sub_match<const char*> csub_match;
1193 /** @brief Standard regex submatch over a standard string. */
1194 typedef sub_match<string::const_iterator> ssub_match;
1195#ifdef _GLIBCXX_USE_WCHAR_T
1196 /** @brief Regex submatch over a C-style null-terminated wide string. */
1197 typedef sub_match<const wchar_t*> wcsub_match;
1198 /** @brief Regex submatch over a standard wide string. */
1199 typedef sub_match<wstring::const_iterator> wssub_match;
1200#endif
1201
1202 // [7.9.2] sub_match non-member operators
1203
1204 /**
1205 * @brief Tests the equivalence of two regular expression submatches.
1206 * @param lhs First regular expression submatch.
1207 * @param rhs Second regular expression submatch.
1208 * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
1209 */
1210 template<typename _BiIter>
1211 inline bool
1212 operator==(const sub_match<_BiIter>& __lhs,
1213 const sub_match<_BiIter>& __rhs)
1214 { return __lhs.compare(__rhs) == 0; }
1215
1216 /**
1217 * @brief Tests the inequivalence of two regular expression submatches.
1218 * @param lhs First regular expression submatch.
1219 * @param rhs Second regular expression submatch.
1220 * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
1221 */
1222 template<typename _BiIter>
1223 inline bool
1224 operator!=(const sub_match<_BiIter>& __lhs,
1225 const sub_match<_BiIter>& __rhs)
1226 { return __lhs.compare(__rhs) != 0; }
1227
1228 /**
1229 * @brief Tests the ordering of two regular expression submatches.
1230 * @param lhs First regular expression submatch.
1231 * @param rhs Second regular expression submatch.
1232 * @returns true if @a lhs precedes @a rhs, false otherwise.
1233 */
1234 template<typename _BiIter>
1235 inline bool
1236 operator<(const sub_match<_BiIter>& __lhs,
1237 const sub_match<_BiIter>& __rhs)
1238 { return __lhs.compare(__rhs) < 0; }
1239
1240 /**
1241 * @brief Tests the ordering of two regular expression submatches.
1242 * @param lhs First regular expression submatch.
1243 * @param rhs Second regular expression submatch.
1244 * @returns true if @a lhs does not succeed @a rhs, false otherwise.
1245 */
1246 template<typename _BiIter>
1247 inline bool
1248 operator<=(const sub_match<_BiIter>& __lhs,
1249 const sub_match<_BiIter>& __rhs)
1250 { return __lhs.compare(__rhs) <= 0; }
1251
1252 /**
1253 * @brief Tests the ordering of two regular expression submatches.
1254 * @param lhs First regular expression submatch.
1255 * @param rhs Second regular expression submatch.
1256 * @returns true if @a lhs does not precede @a rhs, false otherwise.
1257 */
1258 template<typename _BiIter>
1259 inline bool
1260 operator>=(const sub_match<_BiIter>& __lhs,
1261 const sub_match<_BiIter>& __rhs)
1262 { return __lhs.compare(__rhs) >= 0; }
1263
1264 /**
1265 * @brief Tests the ordering of two regular expression submatches.
1266 * @param lhs First regular expression submatch.
1267 * @param rhs Second regular expression submatch.
1268 * @returns true if @a lhs succeeds @a rhs, false otherwise.
1269 */
1270 template<typename _BiIter>
1271 inline bool
1272 operator>(const sub_match<_BiIter>& __lhs,
1273 const sub_match<_BiIter>& __rhs)
1274 { return __lhs.compare(__rhs) > 0; }
1275
1276 /**
1277 * @brief Tests the equivalence of a string and a regular expression
1278 * submatch.
1279 * @param lhs A string.
1280 * @param rhs A regular expression submatch.
1281 * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
1282 */
1283 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1284 inline bool
1285 operator==(const basic_string<
1286 typename iterator_traits<_Bi_iter>::value_type,
1287 _Ch_traits, _Ch_alloc>& __lhs,
1288 const sub_match<_Bi_iter>& __rhs)
1289 { return __lhs == __rhs.str(); }
1290
1291 /**
1292 * @brief Tests the inequivalence of a string and a regular expression
1293 * submatch.
1294 * @param lhs A string.
1295 * @param rhs A regular expression submatch.
1296 * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
1297 */
1298 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1299 inline bool
1300 operator!=(const basic_string<
1301 typename iterator_traits<_Bi_iter>::value_type,
1302 _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
1303 { return __lhs != __rhs.str(); }
1304
1305 /**
1306 * @brief Tests the ordering of a string and a regular expression submatch.
1307 * @param lhs A string.
1308 * @param rhs A regular expression submatch.
1309 * @returns true if @a lhs precedes @a rhs, false otherwise.
1310 */
1311 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1312 inline bool
1313 operator<(const basic_string<
1314 typename iterator_traits<_Bi_iter>::value_type,
1315 _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
1316 { return __lhs < __rhs.str(); }
1317
1318 /**
1319 * @brief Tests the ordering of a string and a regular expression submatch.
1320 * @param lhs A string.
1321 * @param rhs A regular expression submatch.
1322 * @returns true if @a lhs succeeds @a rhs, false otherwise.
1323 */
1324 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1325 inline bool
1326 operator>(const basic_string<
1327 typename iterator_traits<_Bi_iter>::value_type,
1328 _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
1329 { return __lhs > __rhs.str(); }
1330
1331 /**
1332 * @brief Tests the ordering of a string and a regular expression submatch.
1333 * @param lhs A string.
1334 * @param rhs A regular expression submatch.
1335 * @returns true if @a lhs does not precede @a rhs, false otherwise.
1336 */
1337 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1338 inline bool
1339 operator>=(const basic_string<
1340 typename iterator_traits<_Bi_iter>::value_type,
1341 _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
1342 { return __lhs >= __rhs.str(); }
1343
1344 /**
1345 * @brief Tests the ordering of a string and a regular expression submatch.
1346 * @param lhs A string.
1347 * @param rhs A regular expression submatch.
1348 * @returns true if @a lhs does not succeed @a rhs, false otherwise.
1349 */
1350 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1351 inline bool
1352 operator<=(const basic_string<
1353 typename iterator_traits<_Bi_iter>::value_type,
1354 _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs)
1355 { return __lhs <= __rhs.str(); }
1356
1357 /**
1358 * @brief Tests the equivalence of a regular expression submatch and a
1359 * string.
1360 * @param lhs A regular expression submatch.
1361 * @param rhs A string.
1362 * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
1363 */
1364 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1365 inline bool
1366 operator==(const sub_match<_Bi_iter>& __lhs,
1367 const basic_string<
1368 typename iterator_traits<_Bi_iter>::value_type,
1369 _Ch_traits, _Ch_alloc>& __rhs)
1370 { return __lhs.str() == __rhs; }
1371
1372 /**
1373 * @brief Tests the inequivalence of a regular expression submatch and a
1374 * string.
1375 * @param lhs A regular expression submatch.
1376 * @param rhs A string.
1377 * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
1378 */
1379 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1380 inline bool
1381 operator!=(const sub_match<_Bi_iter>& __lhs,
1382 const basic_string<
1383 typename iterator_traits<_Bi_iter>::value_type,
1384 _Ch_traits, _Ch_alloc>& __rhs)
1385 { return __lhs.str() != __rhs; }
1386
1387 /**
1388 * @brief Tests the ordering of a regular expression submatch and a string.
1389 * @param lhs A regular expression submatch.
1390 * @param rhs A string.
1391 * @returns true if @a lhs precedes @a rhs, false otherwise.
1392 */
1393 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1394 inline bool
1395 operator<(const sub_match<_Bi_iter>& __lhs,
1396 const basic_string<
1397 typename iterator_traits<_Bi_iter>::value_type,
1398 _Ch_traits, _Ch_alloc>& __rhs)
1399 { return __lhs.str() < __rhs; }
1400
1401 /**
1402 * @brief Tests the ordering of a regular expression submatch and a string.
1403 * @param lhs A regular expression submatch.
1404 * @param rhs A string.
1405 * @returns true if @a lhs succeeds @a rhs, false otherwise.
1406 */
1407 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1408 inline bool
1409 operator>(const sub_match<_Bi_iter>& __lhs,
1410 const basic_string<
1411 typename iterator_traits<_Bi_iter>::value_type,
1412 _Ch_traits, _Ch_alloc>& __rhs)
1413 { return __lhs.str() > __rhs; }
1414
1415 /**
1416 * @brief Tests the ordering of a regular expression submatch and a string.
1417 * @param lhs A regular expression submatch.
1418 * @param rhs A string.
1419 * @returns true if @a lhs does not precede @a rhs, false otherwise.
1420 */
1421 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1422 inline bool
1423 operator>=(const sub_match<_Bi_iter>& __lhs,
1424 const basic_string<
1425 typename iterator_traits<_Bi_iter>::value_type,
1426 _Ch_traits, _Ch_alloc>& __rhs)
1427 { return __lhs.str() >= __rhs; }
1428
1429 /**
1430 * @brief Tests the ordering of a regular expression submatch and a string.
1431 * @param lhs A regular expression submatch.
1432 * @param rhs A string.
1433 * @returns true if @a lhs does not succeed @a rhs, false otherwise.
1434 */
1435 template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc>
1436 inline bool
1437 operator<=(const sub_match<_Bi_iter>& __lhs,
1438 const basic_string<
1439 typename iterator_traits<_Bi_iter>::value_type,
1440 _Ch_traits, _Ch_alloc>& __rhs)
1441 { return __lhs.str() <= __rhs; }
1442
1443 /**
1444 * @brief Tests the equivalence of a C string and a regular expression
1445 * submatch.
1446 * @param lhs A C string.
1447 * @param rhs A regular expression submatch.
1448 * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
1449 */
1450 template<typename _Bi_iter>
1451 inline bool
1452 operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1453 const sub_match<_Bi_iter>& __rhs)
1454 { return __lhs == __rhs.str(); }
1455
1456 /**
1457 * @brief Tests the inequivalence of an iterator value and a regular
1458 * expression submatch.
1459 * @param lhs A regular expression submatch.
1460 * @param rhs A string.
1461 * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
1462 */
1463 template<typename _Bi_iter>
1464 inline bool
1465 operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1466 const sub_match<_Bi_iter>& __rhs)
1467 { return __lhs != __rhs.str(); }
1468
1469 /**
1470 * @brief Tests the ordering of a string and a regular expression submatch.
1471 * @param lhs A string.
1472 * @param rhs A regular expression submatch.
1473 * @returns true if @a lhs precedes @a rhs, false otherwise.
1474 */
1475 template<typename _Bi_iter>
1476 inline bool
1477 operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1478 const sub_match<_Bi_iter>& __rhs)
1479 { return __lhs < __rhs.str(); }
1480
1481 /**
1482 * @brief Tests the ordering of a string and a regular expression submatch.
1483 * @param lhs A string.
1484 * @param rhs A regular expression submatch.
1485 * @returns true if @a lhs succeeds @a rhs, false otherwise.
1486 */
1487 template<typename _Bi_iter>
1488 inline bool
1489 operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1490 const sub_match<_Bi_iter>& __rhs)
1491 { return __lhs > __rhs.str(); }
1492
1493 /**
1494 * @brief Tests the ordering of a string and a regular expression submatch.
1495 * @param lhs A string.
1496 * @param rhs A regular expression submatch.
1497 * @returns true if @a lhs does not precede @a rhs, false otherwise.
1498 */
1499 template<typename _Bi_iter>
1500 inline bool
1501 operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1502 const sub_match<_Bi_iter>& __rhs)
1503 { return __lhs >= __rhs.str(); }
1504
1505 /**
1506 * @brief Tests the ordering of a string and a regular expression submatch.
1507 * @param lhs A string.
1508 * @param rhs A regular expression submatch.
1509 * @returns true if @a lhs does not succeed @a rhs, false otherwise.
1510 */
1511 template<typename _Bi_iter>
1512 inline bool
1513 operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1514 const sub_match<_Bi_iter>& __rhs)
1515 { return __lhs <= __rhs.str(); }
1516
1517 /**
1518 * @brief Tests the equivalence of a regular expression submatch and a
1519 * string.
1520 * @param lhs A regular expression submatch.
1521 * @param rhs A pointer to a string?
1522 * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
1523 */
1524 template<typename _Bi_iter>
1525 inline bool
1526 operator==(const sub_match<_Bi_iter>& __lhs,
1527 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1528 { return __lhs.str() == __rhs; }
1529
1530 /**
1531 * @brief Tests the inequivalence of a regular expression submatch and a
1532 * string.
1533 * @param lhs A regular expression submatch.
1534 * @param rhs A pointer to a string.
1535 * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
1536 */
1537 template<typename _Bi_iter>
1538 inline bool
1539 operator!=(const sub_match<_Bi_iter>& __lhs,
1540 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1541 { return __lhs.str() != __rhs; }
1542
1543 /**
1544 * @brief Tests the ordering of a regular expression submatch and a string.
1545 * @param lhs A regular expression submatch.
1546 * @param rhs A string.
1547 * @returns true if @a lhs precedes @a rhs, false otherwise.
1548 */
1549 template<typename _Bi_iter>
1550 inline bool
1551 operator<(const sub_match<_Bi_iter>& __lhs,
1552 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1553 { return __lhs.str() < __rhs; }
1554
1555 /**
1556 * @brief Tests the ordering of a regular expression submatch and a string.
1557 * @param lhs A regular expression submatch.
1558 * @param rhs A string.
1559 * @returns true if @a lhs succeeds @a rhs, false otherwise.
1560 */
1561 template<typename _Bi_iter>
1562 inline bool
1563 operator>(const sub_match<_Bi_iter>& __lhs,
1564 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1565 { return __lhs.str() > __rhs; }
1566
1567 /**
1568 * @brief Tests the ordering of a regular expression submatch and a string.
1569 * @param lhs A regular expression submatch.
1570 * @param rhs A string.
1571 * @returns true if @a lhs does not precede @a rhs, false otherwise.
1572 */
1573 template<typename _Bi_iter>
1574 inline bool
1575 operator>=(const sub_match<_Bi_iter>& __lhs,
1576 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1577 { return __lhs.str() >= __rhs; }
1578
1579 /**
1580 * @brief Tests the ordering of a regular expression submatch and a string.
1581 * @param lhs A regular expression submatch.
1582 * @param rhs A string.
1583 * @returns true if @a lhs does not succeed @a rhs, false otherwise.
1584 */
1585 template<typename _Bi_iter>
1586 inline bool
1587 operator<=(const sub_match<_Bi_iter>& __lhs,
1588 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1589 { return __lhs.str() <= __rhs; }
1590
1591 /**
1592 * @brief Tests the equivalence of a string and a regular expression
1593 * submatch.
1594 * @param lhs A string.
1595 * @param rhs A regular expression submatch.
1596 * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
1597 */
1598 template<typename _Bi_iter>
1599 inline bool
1600 operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1601 const sub_match<_Bi_iter>& __rhs)
1602 { return __lhs == __rhs.str(); }
1603
1604 /**
1605 * @brief Tests the inequivalence of a string and a regular expression
1606 * submatch.
1607 * @param lhs A string.
1608 * @param rhs A regular expression submatch.
1609 * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
1610 */
1611 template<typename _Bi_iter>
1612 inline bool
1613 operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1614 const sub_match<_Bi_iter>& __rhs)
1615 { return __lhs != __rhs.str(); }
1616
1617 /**
1618 * @brief Tests the ordering of a string and a regular expression submatch.
1619 * @param lhs A string.
1620 * @param rhs A regular expression submatch.
1621 * @returns true if @a lhs precedes @a rhs, false otherwise.
1622 */
1623 template<typename _Bi_iter>
1624 inline bool
1625 operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1626 const sub_match<_Bi_iter>& __rhs)
1627 { return __lhs < __rhs.str(); }
1628
1629 /**
1630 * @brief Tests the ordering of a string and a regular expression submatch.
1631 * @param lhs A string.
1632 * @param rhs A regular expression submatch.
1633 * @returns true if @a lhs succeeds @a rhs, false otherwise.
1634 */
1635 template<typename _Bi_iter>
1636 inline bool
1637 operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1638 const sub_match<_Bi_iter>& __rhs)
1639 { return __lhs > __rhs.str(); }
1640
1641 /**
1642 * @brief Tests the ordering of a string and a regular expression submatch.
1643 * @param lhs A string.
1644 * @param rhs A regular expression submatch.
1645 * @returns true if @a lhs does not precede @a rhs, false otherwise.
1646 */
1647 template<typename _Bi_iter>
1648 inline bool
1649 operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1650 const sub_match<_Bi_iter>& __rhs)
1651 { return __lhs >= __rhs.str(); }
1652
1653 /**
1654 * @brief Tests the ordering of a string and a regular expression submatch.
1655 * @param lhs A string.
1656 * @param rhs A regular expression submatch.
1657 * @returns true if @a lhs does not succeed @a rhs, false otherwise.
1658 */
1659 template<typename _Bi_iter>
1660 inline bool
1661 operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1662 const sub_match<_Bi_iter>& __rhs)
1663 { return __lhs <= __rhs.str(); }
1664
1665 /**
1666 * @brief Tests the equivalence of a regular expression submatch and a
1667 * string.
1668 * @param lhs A regular expression submatch.
1669 * @param rhs A const string reference.
1670 * @returns true if @a lhs is equivalent to @a rhs, false otherwise.
1671 */
1672 template<typename _Bi_iter>
1673 inline bool
1674 operator==(const sub_match<_Bi_iter>& __lhs,
1675 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1676 { return __lhs.str() == __rhs; }
1677
1678 /**
1679 * @brief Tests the inequivalence of a regular expression submatch and a
1680 * string.
1681 * @param lhs A regular expression submatch.
1682 * @param rhs A const string reference.
1683 * @returns true if @a lhs is not equivalent to @a rhs, false otherwise.
1684 */
1685 template<typename _Bi_iter>
1686 inline bool
1687 operator!=(const sub_match<_Bi_iter>& __lhs,
1688 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1689 { return __lhs.str() != __rhs; }
1690
1691 /**
1692 * @brief Tests the ordering of a regular expression submatch and a string.
1693 * @param lhs A regular expression submatch.
1694 * @param rhs A const string reference.
1695 * @returns true if @a lhs precedes @a rhs, false otherwise.
1696 */
1697 template<typename _Bi_iter>
1698 inline bool
1699 operator<(const sub_match<_Bi_iter>& __lhs,
1700 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1701 { return __lhs.str() < __rhs; }
1702
1703 /**
1704 * @brief Tests the ordering of a regular expression submatch and a string.
1705 * @param lhs A regular expression submatch.
1706 * @param rhs A const string reference.
1707 * @returns true if @a lhs succeeds @a rhs, false otherwise.
1708 */
1709 template<typename _Bi_iter>
1710 inline bool
1711 operator>(const sub_match<_Bi_iter>& __lhs,
1712 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1713 { return __lhs.str() > __rhs; }
1714
1715 /**
1716 * @brief Tests the ordering of a regular expression submatch and a string.
1717 * @param lhs A regular expression submatch.
1718 * @param rhs A const string reference.
1719 * @returns true if @a lhs does not precede @a rhs, false otherwise.
1720 */
1721 template<typename _Bi_iter>
1722 inline bool
1723 operator>=(const sub_match<_Bi_iter>& __lhs,
1724 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1725 { return __lhs.str() >= __rhs; }
1726
1727 /**
1728 * @brief Tests the ordering of a regular expression submatch and a string.
1729 * @param lhs A regular expression submatch.
1730 * @param rhs A const string reference.
1731 * @returns true if @a lhs does not succeed @a rhs, false otherwise.
1732 */
1733 template<typename _Bi_iter>
1734 inline bool
1735 operator<=(const sub_match<_Bi_iter>& __lhs,
1736 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1737 { return __lhs.str() <= __rhs; }
1738
1739 /**
1740 * @brief Inserts a matched string into an output stream.
1741 *
1742 * @param os The output stream.
1743 * @param m A submatch string.
1744 *
1745 * @returns the output stream with the submatch string inserted.
1746 */
1747 template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
1748 inline
1749 basic_ostream<_Ch_type, _Ch_traits>&
1750 operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
1751 const sub_match<_Bi_iter>& __m)
1752 { return __os << __m.str(); }
1753
1754 // [7.10] Class template match_results
1755 /**
1756 * @brief The results of a match or search operation.
1757 *
1758 * A collection of character sequences representing the result of a regular
1759 * expression match. Storage for the collection is allocated and freed as
1760 * necessary by the member functions of class template match_results.
1761 *
1762 * This class satisfies the Sequence requirements, with the exception that
1763 * only the operations defined for a const-qualified Sequence are supported.
1764 *
1765 * The sub_match object stored at index 0 represents sub-expression 0, i.e.
1766 * the whole match. In this case the sub_match member matched is always true.
1767 * The sub_match object stored at index n denotes what matched the marked
1768 * sub-expression n within the matched expression. If the sub-expression n
1769 * participated in a regular expression match then the sub_match member
1770 * matched evaluates to true, and members first and second denote the range
1771 * of characters [first, second) which formed that match. Otherwise matched
1772 * is false, and members first and second point to the end of the sequence
1773 * that was searched.
1774 *
1775 * @nosubgrouping
1776 */
1777 template<typename _Bi_iter,
1778 typename _Allocator = allocator<sub_match<_Bi_iter> > >
1779 class match_results
1780 : private std::vector<std::tr1::sub_match<_Bi_iter>, _Allocator>
1781 {
1782 private:
1783 typedef std::vector<std::tr1::sub_match<_Bi_iter>, _Allocator>
1784 _Base_type;
1785
1786 public:
1787 /**
1788 * @name 10.? Public Types
1789 */
1790 ///@{
1791 typedef sub_match<_Bi_iter> value_type;
1792 typedef typename _Base_type::const_reference const_reference;
1793 typedef const_reference reference;
1794 typedef typename _Base_type::const_iterator const_iterator;
1795 typedef const_iterator iterator;
1796 typedef typename iterator_traits<_Bi_iter>::difference_type
1797 difference_type;
1798 typedef typename _Allocator::size_type size_type;
1799 typedef _Allocator allocator_type;
1800 typedef typename iterator_traits<_Bi_iter>::value_type char_type;
1801 typedef basic_string<char_type> string_type;
1802 ///@}
1803
1804 public:
1805 /**
1806 * @name 10.1 Construction, Copying, and Destruction
1807 */
1808 ///@{
1809
1810 /**
1811 * @brief Constructs a default %match_results container.
1812 * @post size() returns 0 and str() returns an empty string.
1813 */
1814 explicit
1815 match_results(const _Allocator& __a = _Allocator())
1816 : _Base_type(__a), _M_matched(false)
1817 { }
1818
1819 /**
1820 * @brief Copy constructs a %match_results.
1821 */
1822 match_results(const match_results& __rhs)
1823 : _Base_type(__rhs), _M_matched(__rhs._M_matched),
1824 _M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix)
1825 { }
1826
1827 /**
1828 * @brief Assigns rhs to *this.
1829 */
1830 match_results&
1831 operator=(const match_results& __rhs)
1832 {
1833 match_results __tmp(__rhs);
1834 this->swap(__tmp);
1835 return *this;
1836 }
1837
1838 /**
1839 * @brief Destroys a %match_results object.
1840 */
1841 ~match_results()
1842 { }
1843
1844 ///@}
1845
1846 /**
1847 * @name 10.2 Size
1848 */
1849 ///@{
1850
1851 /**
1852 * @brief Gets the number of matches and submatches.
1853 *
1854 * The number of matches for a given regular expression will be either 0
1855 * if there was no match or mark_count() + 1 if a match was successful.
1856 * Some matches may be empty.
1857 *
1858 * @returns the number of matches found.
1859 */
1860 size_type
1861 size() const
1862 { return _M_matched ? _Base_type::size() + 1 : 0; }
1863
1864 //size_type
1865 //max_size() const;
1866 using _Base_type::max_size;
1867
1868 /**
1869 * @brief Indicates if the %match_results contains no results.
1870 * @retval true The %match_results object is empty.
1871 * @retval false The %match_results object is not empty.
1872 */
1873 _GLIBCXX_NODISCARD bool
1874 empty() const
1875 { return size() == 0; }
1876
1877 ///@}
1878
1879 /**
1880 * @name 10.3 Element Access
1881 */
1882 ///@{
1883
1884 /**
1885 * @brief Gets the length of the indicated submatch.
1886 * @param sub indicates the submatch.
1887 *
1888 * This function returns the length of the indicated submatch, or the
1889 * length of the entire match if @p sub is zero (the default).
1890 */
1891 difference_type
1892 length(size_type __sub = 0) const
1893 { return _M_matched ? this->str(__sub).length() : 0; }
1894
1895 /**
1896 * @brief Gets the offset of the beginning of the indicated submatch.
1897 * @param sub indicates the submatch.
1898 *
1899 * This function returns the offset from the beginning of the target
1900 * sequence to the beginning of the submatch, unless the value of @p sub
1901 * is zero (the default), in which case this function returns the offset
1902 * from the beginning of the target sequence to the beginning of the
1903 * match.
1904 */
1905 difference_type
1906 position(size_type __sub = 0) const
1907 {
1908 return _M_matched ? std::distance(this->prefix().first,
1909 (*this)[__sub].first) : 0;
1910 }
1911
1912 /**
1913 * @brief Gets the match or submatch converted to a string type.
1914 * @param sub indicates the submatch.
1915 *
1916 * This function gets the submatch (or match, if @p sub is zero) extracted
1917 * from the target range and converted to the associated string type.
1918 */
1919 string_type
1920 str(size_type __sub = 0) const
1921 { return _M_matched ? (*this)[__sub].str() : string_type(); }
1922
1923 /**
1924 * @brief Gets a %sub_match reference for the match or submatch.
1925 * @param sub indicates the submatch.
1926 *
1927 * This function gets a reference to the indicated submatch, or the entire
1928 * match if @p sub is zero.
1929 *
1930 * If @p sub >= size() then this function returns a %sub_match with a
1931 * special value indicating no submatch.
1932 */
1933 const_reference
1934 operator[](size_type __sub) const
1935 { return _Base_type::operator[](__sub); }
1936
1937 /**
1938 * @brief Gets a %sub_match representing the match prefix.
1939 *
1940 * This function gets a reference to a %sub_match object representing the
1941 * part of the target range between the start of the target range and the
1942 * start of the match.
1943 */
1944 const_reference
1945 prefix() const
1946 { return _M_prefix; }
1947
1948 /**
1949 * @brief Gets a %sub_match representing the match suffix.
1950 *
1951 * This function gets a reference to a %sub_match object representing the
1952 * part of the target range between the end of the match and the end of
1953 * the target range.
1954 */
1955 const_reference
1956 suffix() const
1957 { return _M_suffix; }
1958
1959 /**
1960 * @brief Gets an iterator to the start of the %sub_match collection.
1961 */
1962 const_iterator
1963 begin() const
1964 { return _Base_type::begin(); }
1965
1966#ifdef _GLIBCXX_INCLUDE_AS_CXX11
1967 /**
1968 * @brief Gets an iterator to the start of the %sub_match collection.
1969 */
1970 const_iterator
1971 cbegin() const
1972 { return _Base_type::begin(); }
1973#endif
1974
1975 /**
1976 * @brief Gets an iterator to one-past-the-end of the collection.
1977 */
1978 const_iterator
1979 end() const
1980 { return _Base_type::end(); }
1981
1982#ifdef _GLIBCXX_INCLUDE_AS_CXX11
1983 /**
1984 * @brief Gets an iterator to one-past-the-end of the collection.
1985 */
1986 const_iterator
1987 cend() const
1988 { return _Base_type::end(); }
1989#endif
1990
1991 ///@}
1992
1993 /**
1994 * @name 10.4 Formatting
1995 *
1996 * These functions perform formatted substitution of the matched
1997 * character sequences into their target. The format specifiers
1998 * and escape sequences accepted by these functions are
1999 * determined by their @p flags parameter as documented above.
2000 */
2001 ///@{
2002
2003 /**
2004 * @todo Implement this function.
2005 */
2006 template<typename _Out_iter>
2007 _Out_iter
2008 format(_Out_iter __out, const string_type& __fmt,
2009 regex_constants::match_flag_type __flags
2010 = regex_constants::format_default) const;
2011
2012 /**
2013 * @todo Implement this function.
2014 */
2015 string_type
2016 format(const string_type& __fmt,
2017 regex_constants::match_flag_type __flags
2018 = regex_constants::format_default) const;
2019
2020 ///@}
2021
2022 /**
2023 * @name 10.5 Allocator
2024 */
2025 ///@{
2026
2027 /**
2028 * @brief Gets a copy of the allocator.
2029 */
2030 //allocator_type
2031 //get_allocator() const;
2032 using _Base_type::get_allocator;
2033
2034 ///@}
2035
2036 /**
2037 * @name 10.6 Swap
2038 */
2039 ///@{
2040
2041 /**
2042 * @brief Swaps the contents of two match_results.
2043 */
2044 void
2045 swap(match_results& __that)
2046 {
2047 _Base_type::swap(__that);
2048 std::swap(_M_matched, __that._M_matched);
2049 std::swap(_M_prefix, __that._M_prefix);
2050 std::swap(_M_suffix, __that._M_suffix);
2051 }
2052 ///@}
2053
2054 private:
2055 bool _M_matched;
2056 value_type _M_prefix;
2057 value_type _M_suffix;
2058 };
2059
2060 typedef match_results<const char*> cmatch;
2061 typedef match_results<string::const_iterator> smatch;
2062#ifdef _GLIBCXX_USE_WCHAR_T
2063 typedef match_results<const wchar_t*> wcmatch;
2064 typedef match_results<wstring::const_iterator> wsmatch;
2065#endif
2066
2067 // match_results comparisons
2068 /**
2069 * @brief Compares two match_results for equality.
2070 * @returns true if the two objects refer to the same match,
2071 * false otherwise.
2072 * @todo Implement this function.
2073 */
2074 template<typename _Bi_iter, typename _Allocator>
2075 inline bool
2076 operator==(const match_results<_Bi_iter, _Allocator>& __m1,
2077 const match_results<_Bi_iter, _Allocator>& __m2);
2078
2079 /**
2080 * @brief Compares two match_results for inequality.
2081 * @returns true if the two objects do not refer to the same match,
2082 * false otherwise.
2083 */
2084 template<typename _Bi_iter, class _Allocator>
2085 inline bool
2086 operator!=(const match_results<_Bi_iter, _Allocator>& __m1,
2087 const match_results<_Bi_iter, _Allocator>& __m2)
2088 { return !(__m1 == __m2); }
2089
2090 // [7.10.6] match_results swap
2091 /**
2092 * @brief Swaps two match results.
2093 * @param lhs A match result.
2094 * @param rhs A match result.
2095 *
2096 * The contents of the two match_results objects are swapped.
2097 */
2098 template<typename _Bi_iter, typename _Allocator>
2099 inline void
2100 swap(match_results<_Bi_iter, _Allocator>& __lhs,
2101 match_results<_Bi_iter, _Allocator>& __rhs)
2102 { __lhs.swap(__rhs); }
2103
2104 // [7.11.2] Function template regex_match
2105 /**
2106 * @name Matching, Searching, and Replacing
2107 */
2108 ///@{
2109
2110 /**
2111 * @brief Determines if there is a match between the regular expression @p e
2112 * and all of the character sequence [first, last).
2113 *
2114 * @param first Beginning of the character sequence to match.
2115 * @param last One-past-the-end of the character sequence to match.
2116 * @param m The match results.
2117 * @param re The regular expression.
2118 * @param flags Controls how the regular expression is matched.
2119 *
2120 * @retval true A match exists.
2121 * @retval false Otherwise.
2122 *
2123 * @throws an exception of type regex_error.
2124 *
2125 * @todo Implement this function.
2126 */
2127 template<typename _Bi_iter, typename _Allocator,
2128 typename _Ch_type, typename _Rx_traits>
2129 bool
2130 regex_match(_Bi_iter __first, _Bi_iter __last,
2131 match_results<_Bi_iter, _Allocator>& __m,
2132 const basic_regex<_Ch_type, _Rx_traits>& __re,
2133 regex_constants::match_flag_type __flags
2134 = regex_constants::match_default);
2135
2136 /**
2137 * @brief Indicates if there is a match between the regular expression @p e
2138 * and all of the character sequence [first, last).
2139 *
2140 * @param first Beginning of the character sequence to match.
2141 * @param last One-past-the-end of the character sequence to match.
2142 * @param re The regular expression.
2143 * @param flags Controls how the regular expression is matched.
2144 *
2145 * @retval true A match exists.
2146 * @retval false Otherwise.
2147 *
2148 * @throws an exception of type regex_error.
2149 */
2150 template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2151 bool
2152 regex_match(_Bi_iter __first, _Bi_iter __last,
2153 const basic_regex<_Ch_type, _Rx_traits>& __re,
2154 regex_constants::match_flag_type __flags
2155 = regex_constants::match_default)
2156 {
2157 match_results<_Bi_iter> __what;
2158 return regex_match(__first, __last, __what, __re, __flags);
2159 }
2160
2161 /**
2162 * @brief Determines if there is a match between the regular expression @p e
2163 * and a C-style null-terminated string.
2164 *
2165 * @param s The C-style null-terminated string to match.
2166 * @param m The match results.
2167 * @param re The regular expression.
2168 * @param f Controls how the regular expression is matched.
2169 *
2170 * @retval true A match exists.
2171 * @retval false Otherwise.
2172 *
2173 * @throws an exception of type regex_error.
2174 */
2175 template<typename _Ch_type, typename _Allocator, typename _Rx_traits>
2176 inline bool
2177 regex_match(const _Ch_type* __s,
2178 match_results<const _Ch_type*, _Allocator>& __m,
2179 const basic_regex<_Ch_type, _Rx_traits>& __re,
2180 regex_constants::match_flag_type __f
2181 = regex_constants::match_default)
2182 { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2183
2184 /**
2185 * @brief Determines if there is a match between the regular expression @p e
2186 * and a string.
2187 *
2188 * @param s The string to match.
2189 * @param m The match results.
2190 * @param re The regular expression.
2191 * @param flags Controls how the regular expression is matched.
2192 *
2193 * @retval true A match exists.
2194 * @retval false Otherwise.
2195 *
2196 * @throws an exception of type regex_error.
2197 */
2198 template<typename _Ch_traits, typename _Ch_alloc,
2199 typename _Allocator, typename _Ch_type, typename _Rx_traits>
2200 inline bool
2201 regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
2202 match_results<typename basic_string<_Ch_type,
2203 _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
2204 const basic_regex<_Ch_type, _Rx_traits>& __re,
2205 regex_constants::match_flag_type __flags
2206 = regex_constants::match_default)
2207 { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
2208
2209 /**
2210 * @brief Indicates if there is a match between the regular expression @p e
2211 * and a C-style null-terminated string.
2212 *
2213 * @param s The C-style null-terminated string to match.
2214 * @param re The regular expression.
2215 * @param f Controls how the regular expression is matched.
2216 *
2217 * @retval true A match exists.
2218 * @retval false Otherwise.
2219 *
2220 * @throws an exception of type regex_error.
2221 */
2222 template<typename _Ch_type, class _Rx_traits>
2223 inline bool
2224 regex_match(const _Ch_type* __s,
2225 const basic_regex<_Ch_type, _Rx_traits>& __re,
2226 regex_constants::match_flag_type __f
2227 = regex_constants::match_default)
2228 { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2229
2230 /**
2231 * @brief Indicates if there is a match between the regular expression @p e
2232 * and a string.
2233 *
2234 * @param s [IN] The string to match.
2235 * @param re [IN] The regular expression.
2236 * @param flags [IN] Controls how the regular expression is matched.
2237 *
2238 * @retval true A match exists.
2239 * @retval false Otherwise.
2240 *
2241 * @throws an exception of type regex_error.
2242 */
2243 template<typename _Ch_traits, typename _Str_allocator,
2244 typename _Ch_type, typename _Rx_traits>
2245 inline bool
2246 regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
2247 const basic_regex<_Ch_type, _Rx_traits>& __re,
2248 regex_constants::match_flag_type __flags
2249 = regex_constants::match_default)
2250 { return regex_match(__s.begin(), __s.end(), __re, __flags); }
2251
2252 // [7.11.3] Function template regex_search
2253 /**
2254 * Searches for a regular expression within a range.
2255 * @param first [IN] The start of the string to search.
2256 * @param last [IN] One-past-the-end of the string to search.
2257 * @param m [OUT] The match results.
2258 * @param re [IN] The regular expression to search for.
2259 * @param flags [IN] Search policy flags.
2260 * @retval true A match was found within the string.
2261 * @retval false No match was found within the string, the content of %m is
2262 * undefined.
2263 *
2264 * @throws an exception of type regex_error.
2265 *
2266 * @todo Implement this function.
2267 */
2268 template<typename _Bi_iter, typename _Allocator,
2269 typename _Ch_type, typename _Rx_traits>
2270 inline bool
2271 regex_search(_Bi_iter __first, _Bi_iter __last,
2272 match_results<_Bi_iter, _Allocator>& __m,
2273 const basic_regex<_Ch_type, _Rx_traits>& __re,
2274 regex_constants::match_flag_type __flags
2275 = regex_constants::match_default);
2276
2277 /**
2278 * Searches for a regular expression within a range.
2279 * @param first [IN] The start of the string to search.
2280 * @param last [IN] One-past-the-end of the string to search.
2281 * @param re [IN] The regular expression to search for.
2282 * @param flags [IN] Search policy flags.
2283 * @retval true A match was found within the string.
2284 * @retval false No match was found within the string.
2285 * @doctodo
2286 *
2287 * @throws an exception of type regex_error.
2288 */
2289 template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2290 inline bool
2291 regex_search(_Bi_iter __first, _Bi_iter __last,
2292 const basic_regex<_Ch_type, _Rx_traits>& __re,
2293 regex_constants::match_flag_type __flags
2294 = regex_constants::match_default)
2295 {
2296 match_results<_Bi_iter> __what;
2297 return regex_search(__first, __last, __what, __re, __flags);
2298 }
2299
2300 /**
2301 * @brief Searches for a regular expression within a C-string.
2302 * @param s [IN] A C-string to search for the regex.
2303 * @param m [OUT] The set of regex matches.
2304 * @param e [IN] The regex to search for in @p s.
2305 * @param f [IN] The search flags.
2306 * @retval true A match was found within the string.
2307 * @retval false No match was found within the string, the content of %m is
2308 * undefined.
2309 * @doctodo
2310 *
2311 * @throws an exception of type regex_error.
2312 */
2313 template<typename _Ch_type, class _Allocator, class _Rx_traits>
2314 inline bool
2315 regex_search(const _Ch_type* __s,
2316 match_results<const _Ch_type*, _Allocator>& __m,
2317 const basic_regex<_Ch_type, _Rx_traits>& __e,
2318 regex_constants::match_flag_type __f
2319 = regex_constants::match_default)
2320 { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2321
2322 /**
2323 * @brief Searches for a regular expression within a C-string.
2324 * @param s [IN] The C-string to search.
2325 * @param e [IN] The regular expression to search for.
2326 * @param f [IN] Search policy flags.
2327 * @retval true A match was found within the string.
2328 * @retval false No match was found within the string.
2329 * @doctodo
2330 *
2331 * @throws an exception of type regex_error.
2332 */
2333 template<typename _Ch_type, typename _Rx_traits>
2334 inline bool
2335 regex_search(const _Ch_type* __s,
2336 const basic_regex<_Ch_type, _Rx_traits>& __e,
2337 regex_constants::match_flag_type __f
2338 = regex_constants::match_default)
2339 { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2340
2341 /**
2342 * @brief Searches for a regular expression within a string.
2343 * @param s [IN] The string to search.
2344 * @param e [IN] The regular expression to search for.
2345 * @param flags [IN] Search policy flags.
2346 * @retval true A match was found within the string.
2347 * @retval false No match was found within the string.
2348 * @doctodo
2349 *
2350 * @throws an exception of type regex_error.
2351 */
2352 template<typename _Ch_traits, typename _String_allocator,
2353 typename _Ch_type, typename _Rx_traits>
2354 inline bool
2355 regex_search(const basic_string<_Ch_type, _Ch_traits,
2356 _String_allocator>& __s,
2357 const basic_regex<_Ch_type, _Rx_traits>& __e,
2358 regex_constants::match_flag_type __flags
2359 = regex_constants::match_default)
2360 { return regex_search(__s.begin(), __s.end(), __e, __flags); }
2361
2362 /**
2363 * @brief Searches for a regular expression within a string.
2364 * @param s [IN] A C++ string to search for the regex.
2365 * @param m [OUT] The set of regex matches.
2366 * @param e [IN] The regex to search for in @p s.
2367 * @param f [IN] The search flags.
2368 * @retval true A match was found within the string.
2369 * @retval false No match was found within the string, the content of %m is
2370 * undefined.
2371 *
2372 * @throws an exception of type regex_error.
2373 */
2374 template<typename _Ch_traits, typename _Ch_alloc,
2375 typename _Allocator, typename _Ch_type,
2376 typename _Rx_traits>
2377 inline bool
2378 regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
2379 match_results<typename basic_string<_Ch_type,
2380 _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m,
2381 const basic_regex<_Ch_type, _Rx_traits>& __e,
2382 regex_constants::match_flag_type __f
2383 = regex_constants::match_default)
2384 { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
2385
2386 // tr1 [7.11.4] std [28.11.4] Function template regex_replace
2387 /**
2388 * @doctodo
2389 * @param out
2390 * @param first
2391 * @param last
2392 * @param e
2393 * @param fmt
2394 * @param flags
2395 *
2396 * @returns out
2397 * @throws an exception of type regex_error.
2398 *
2399 * @todo Implement this function.
2400 */
2401 template<typename _Out_iter, typename _Bi_iter,
2402 typename _Rx_traits, typename _Ch_type>
2403 inline _Out_iter
2404 regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2405 const basic_regex<_Ch_type, _Rx_traits>& __e,
2406 const basic_string<_Ch_type>& __fmt,
2407 regex_constants::match_flag_type __flags
2408 = regex_constants::match_default);
2409
2410 /**
2411 * @doctodo
2412 * @param s
2413 * @param e
2414 * @param fmt
2415 * @param flags
2416 *
2417 * @returns a copy of string @p s with replacements.
2418 *
2419 * @throws an exception of type regex_error.
2420 */
2421 template<typename _Rx_traits, typename _Ch_type>
2422 inline basic_string<_Ch_type>
2423 regex_replace(const basic_string<_Ch_type>& __s,
2424 const basic_regex<_Ch_type, _Rx_traits>& __e,
2425 const basic_string<_Ch_type>& __fmt,
2426 regex_constants::match_flag_type __flags
2427 = regex_constants::match_default)
2428 {
2429 std::string __result;
2430 regex_replace(std::back_inserter(__result),
2431 __s.begin(), __s.end(), __e, __fmt, __flags);
2432 return __result;
2433 }
2434
2435 ///@}
2436
2437 // tr1 [7.12.1] std [28.12] Class template regex_iterator
2438 /**
2439 * An iterator adaptor that will provide repeated calls of regex_search over
2440 * a range until no more matches remain.
2441 */
2442 template<typename _Bi_iter,
2443 typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2444 typename _Rx_traits = regex_traits<_Ch_type> >
2445 class regex_iterator
2446 {
2447 public:
2448 typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2449 typedef match_results<_Bi_iter> value_type;
2450 typedef std::ptrdiff_t difference_type;
2451 typedef const value_type* pointer;
2452 typedef const value_type& reference;
2453 typedef std::forward_iterator_tag iterator_category;
2454
2455 public:
2456 /**
2457 * @brief Provides a singular iterator, useful for indicating
2458 * one-past-the-end of a range.
2459 * @todo Implement this function.
2460 * @doctodo
2461 */
2462 regex_iterator();
2463
2464 /**
2465 * Constructs a %regex_iterator...
2466 * @param a [IN] The start of a text range to search.
2467 * @param b [IN] One-past-the-end of the text range to search.
2468 * @param re [IN] The regular expression to match.
2469 * @param m [IN] Policy flags for match rules.
2470 * @todo Implement this function.
2471 * @doctodo
2472 */
2473 regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2474 regex_constants::match_flag_type __m
2475 = regex_constants::match_default);
2476
2477 /**
2478 * Copy constructs a %regex_iterator.
2479 * @todo Implement this function.
2480 * @doctodo
2481 */
2482 regex_iterator(const regex_iterator& __rhs);
2483
2484 /**
2485 * @todo Implement this function.
2486 * @doctodo
2487 */
2488 regex_iterator&
2489 operator=(const regex_iterator& __rhs);
2490
2491 /**
2492 * @todo Implement this function.
2493 * @doctodo
2494 */
2495 bool
2496 operator==(const regex_iterator& __rhs);
2497
2498 /**
2499 * @todo Implement this function.
2500 * @doctodo
2501 */
2502 bool
2503 operator!=(const regex_iterator& __rhs);
2504
2505 /**
2506 * @todo Implement this function.
2507 * @doctodo
2508 */
2509 const value_type&
2510 operator*();
2511
2512 /**
2513 * @todo Implement this function.
2514 * @doctodo
2515 */
2516 const value_type*
2517 operator->();
2518
2519 /**
2520 * @todo Implement this function.
2521 * @doctodo
2522 */
2523 regex_iterator&
2524 operator++();
2525
2526 /**
2527 * @todo Implement this function.
2528 * @doctodo
2529 */
2530 regex_iterator
2531 operator++(int);
2532
2533 private:
2534 // these members are shown for exposition only:
2535 _Bi_iter begin;
2536 _Bi_iter end;
2537 const regex_type* pregex;
2538 regex_constants::match_flag_type flags;
2539 match_results<_Bi_iter> match;
2540 };
2541
2542 typedef regex_iterator<const char*> cregex_iterator;
2543 typedef regex_iterator<string::const_iterator> sregex_iterator;
2544#ifdef _GLIBCXX_USE_WCHAR_T
2545 typedef regex_iterator<const wchar_t*> wcregex_iterator;
2546 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
2547#endif
2548
2549 // [7.12.2] Class template regex_token_iterator
2550 /**
2551 * Iterates over submatches in a range (or @a splits a text string).
2552 *
2553 * The purpose of this iterator is to enumerate all, or all specified,
2554 * matches of a regular expression within a text range. The dereferenced
2555 * value of an iterator of this class is a std::tr1::sub_match object.
2556 */
2557 template<typename _Bi_iter,
2558 typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2559 typename _Rx_traits = regex_traits<_Ch_type> >
2560 class regex_token_iterator
2561 {
2562 public:
2563 typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2564 typedef sub_match<_Bi_iter> value_type;
2565 typedef std::ptrdiff_t difference_type;
2566 typedef const value_type* pointer;
2567 typedef const value_type& reference;
2568 typedef std::forward_iterator_tag iterator_category;
2569
2570 public:
2571 /**
2572 * @brief Default constructs a %regex_token_iterator.
2573 * @todo Implement this function.
2574 *
2575 * A default-constructed %regex_token_iterator is a singular iterator
2576 * that will compare equal to the one-past-the-end value for any
2577 * iterator of the same type.
2578 */
2579 regex_token_iterator();
2580
2581 /**
2582 * Constructs a %regex_token_iterator...
2583 * @param a [IN] The start of the text to search.
2584 * @param b [IN] One-past-the-end of the text to search.
2585 * @param re [IN] The regular expression to search for.
2586 * @param submatch [IN] Which submatch to return. There are some
2587 * special values for this parameter:
2588 * - -1 each enumerated subexpression does NOT
2589 * match the regular expression (aka field
2590 * splitting)
2591 * - 0 the entire string matching the
2592 * subexpression is returned for each match
2593 * within the text.
2594 * - >0 enumerates only the indicated
2595 * subexpression from a match within the text.
2596 * @param m [IN] Policy flags for match rules.
2597 *
2598 * @todo Implement this function.
2599 * @doctodo
2600 */
2601 regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2602 int __submatch = 0,
2603 regex_constants::match_flag_type __m
2604 = regex_constants::match_default);
2605
2606 /**
2607 * Constructs a %regex_token_iterator...
2608 * @param a [IN] The start of the text to search.
2609 * @param b [IN] One-past-the-end of the text to search.
2610 * @param re [IN] The regular expression to search for.
2611 * @param submatches [IN] A list of subexpressions to return for each
2612 * regular expression match within the text.
2613 * @param m [IN] Policy flags for match rules.
2614 *
2615 * @todo Implement this function.
2616 * @doctodo
2617 */
2618 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2619 const regex_type& __re,
2620 const std::vector<int>& __submatches,
2621 regex_constants::match_flag_type __m
2622 = regex_constants::match_default);
2623
2624 /**
2625 * Constructs a %regex_token_iterator...
2626 * @param a [IN] The start of the text to search.
2627 * @param b [IN] One-past-the-end of the text to search.
2628 * @param re [IN] The regular expression to search for.
2629 * @param submatches [IN] A list of subexpressions to return for each
2630 * regular expression match within the text.
2631 * @param m [IN] Policy flags for match rules.
2632
2633 * @todo Implement this function.
2634 * @doctodo
2635 */
2636 template<std::size_t _Nm>
2637 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2638 const regex_type& __re,
2639 const int (&__submatches)[_Nm],
2640 regex_constants::match_flag_type __m
2641 = regex_constants::match_default);
2642
2643 /**
2644 * @brief Copy constructs a %regex_token_iterator.
2645 * @param rhs [IN] A %regex_token_iterator to copy.
2646 * @todo Implement this function.
2647 */
2648 regex_token_iterator(const regex_token_iterator& __rhs);
2649
2650 /**
2651 * @brief Assigns a %regex_token_iterator to another.
2652 * @param rhs [IN] A %regex_token_iterator to copy.
2653 * @todo Implement this function.
2654 */
2655 regex_token_iterator&
2656 operator=(const regex_token_iterator& __rhs);
2657
2658 /**
2659 * @brief Compares a %regex_token_iterator to another for equality.
2660 * @todo Implement this function.
2661 */
2662 bool
2663 operator==(const regex_token_iterator& __rhs);
2664
2665 /**
2666 * @brief Compares a %regex_token_iterator to another for inequality.
2667 * @todo Implement this function.
2668 */
2669 bool
2670 operator!=(const regex_token_iterator& __rhs);
2671
2672 /**
2673 * @brief Dereferences a %regex_token_iterator.
2674 * @todo Implement this function.
2675 */
2676 const value_type&
2677 operator*();
2678
2679 /**
2680 * @brief Selects a %regex_token_iterator member.
2681 * @todo Implement this function.
2682 */
2683 const value_type*
2684 operator->();
2685
2686 /**
2687 * @brief Increments a %regex_token_iterator.
2688 * @todo Implement this function.
2689 */
2690 regex_token_iterator&
2691 operator++();
2692
2693 /**
2694 * @brief Postincrements a %regex_token_iterator.
2695 * @todo Implement this function.
2696 */
2697 regex_token_iterator
2698 operator++(int);
2699
2700 private: // data members for exposition only:
2701 typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator;
2702
2703 position_iterator __position;
2704 const value_type* __result;
2705 value_type __suffix;
2706 std::size_t __n;
2707 std::vector<int> __subs;
2708 };
2709
2710 /** @brief Token iterator for C-style NULL-terminated strings. */
2711 typedef regex_token_iterator<const char*> cregex_token_iterator;
2712 /** @brief Token iterator for standard strings. */
2713 typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
2714#ifdef _GLIBCXX_USE_WCHAR_T
2715 /** @brief Token iterator for C-style NULL-terminated wide strings. */
2716 typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
2717 /** @brief Token iterator for standard wide-character strings. */
2718 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
2719#endif
2720
2721 ///@}
2722}
2723
2724_GLIBCXX_END_NAMESPACE_VERSION
2725}
2726
2727#endif // _GLIBCXX_TR1_REGEX
Note: See TracBrowser for help on using the repository browser.