sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: /// \file basic_regex.hpp sl@0: /// Contains the definition of the basic_regex\<\> class template and its sl@0: /// associated helper functions. sl@0: // sl@0: // Copyright 2004 Eric Niebler. Distributed under the Boost sl@0: // Software License, Version 1.0. (See accompanying file sl@0: // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) sl@0: sl@0: #ifndef BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005 sl@0: #define BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005 sl@0: sl@0: // MS compatible compilers support #pragma once sl@0: #if defined(_MSC_VER) && (_MSC_VER >= 1020) sl@0: # pragma once sl@0: #endif sl@0: sl@0: #ifdef BOOST_XPRESSIVE_DEBUG_TRACKING_POINTER sl@0: # include sl@0: #endif sl@0: #include sl@0: #include sl@0: #include sl@0: #include sl@0: #include sl@0: sl@0: namespace boost { namespace xpressive sl@0: { sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // basic_regex sl@0: // sl@0: /// \brief Class template basic_regex\<\> is a class for holding a compiled regular expression. sl@0: template sl@0: struct basic_regex sl@0: { sl@0: typedef BidiIter iterator_type; sl@0: typedef typename iterator_value::type char_type; sl@0: typedef std::basic_string string_type; sl@0: typedef regex_constants::syntax_option_type flag_type; sl@0: sl@0: /// \post regex_id() == 0 sl@0: /// \post mark_count() == 0 sl@0: basic_regex() sl@0: : impl_() sl@0: { sl@0: } sl@0: sl@0: /// \param that The basic_regex object to copy. sl@0: /// \post regex_id() == that.regex_id() sl@0: /// \post mark_count() == that.mark_count() sl@0: basic_regex(basic_regex const &that) sl@0: : impl_(that.impl_) sl@0: { sl@0: } sl@0: sl@0: /// \param that The basic_regex object to copy. sl@0: /// \post regex_id() == that.regex_id() sl@0: /// \post mark_count() == that.mark_count() sl@0: /// \return *this sl@0: basic_regex &operator =(basic_regex const &that) sl@0: { sl@0: this->impl_ = that.impl_; sl@0: return *this; sl@0: } sl@0: sl@0: /// Construct from a static regular expression. sl@0: /// sl@0: /// \param xpr The static regular expression sl@0: /// \pre Xpr is the type of a static regular expression. sl@0: /// \post regex_id() != 0 sl@0: /// \post mark_count() \>= 0 sl@0: template sl@0: basic_regex(Xpr const &xpr) sl@0: : impl_() sl@0: { sl@0: this->operator =(xpr); sl@0: } sl@0: sl@0: /// Construct from a static regular expression. sl@0: /// sl@0: /// \param xpr The static regular expression. sl@0: /// \pre Xpr is the type of a static regular expression. sl@0: /// \post regex_id() != 0 sl@0: /// \post mark_count() \>= 0 sl@0: /// \throw std::bad_alloc on out of memory sl@0: /// \return *this sl@0: template sl@0: basic_regex &operator =(Xpr const &xpr) sl@0: { sl@0: detail::static_compile(xpr, *this->impl_.get()); sl@0: return *this; sl@0: } sl@0: sl@0: /// Returns the count of capturing sub-expressions in this regular expression sl@0: /// sl@0: std::size_t mark_count() const sl@0: { sl@0: return this->impl_ ? this->impl_->mark_count_ : 0; sl@0: } sl@0: sl@0: /// Returns a token which uniquely identifies this regular expression. sl@0: /// sl@0: regex_id_type regex_id() const sl@0: { sl@0: return this->impl_ ? this->impl_->xpr_.get() : 0; sl@0: } sl@0: sl@0: /// Swaps the contents of this basic_regex object with another. sl@0: /// sl@0: /// \param that The other basic_regex object. sl@0: /// \attention This is a shallow swap that does not do reference tracking. If you embed sl@0: /// a basic_regex object by reference in another regular expression and then swap its sl@0: /// contents with another basic_regex object, the change will not be visible to the enclosing sl@0: /// regular expression. It is done this way to ensure that swap() cannot throw. sl@0: /// \throw nothrow sl@0: void swap(basic_regex &that) // throw() sl@0: { sl@0: this->impl_.swap(that.impl_); sl@0: } sl@0: sl@0: /// Factory method for building a regex object from a string. sl@0: /// Equivalent to regex_compiler\< BidiIter \>().compile(str, flags); sl@0: /// sl@0: /// \param str The std::basic_string containing the regular expression. sl@0: /// \param flags Optional bitmask of type syntax_option_type to control how str is interpreted. sl@0: static basic_regex compile(string_type const &str, flag_type flags = regex_constants::ECMAScript) sl@0: { sl@0: return regex_compiler().compile(str, flags); sl@0: } sl@0: sl@0: // for binding actions to this regex when it is nested statically in another regex sl@0: /// INTERNAL ONLY sl@0: template sl@0: proto::binary_op sl@0: < sl@0: proto::unary_op, proto::noop_tag> sl@0: , proto::unary_op sl@0: , proto::right_shift_tag sl@0: > const sl@0: operator [](detail::action_matcher const &action) const sl@0: { sl@0: return proto::noop(*this) >> proto::noop(*static_cast(&action)); sl@0: } sl@0: sl@0: //{{AFX_DEBUG sl@0: #ifdef BOOST_XPRESSIVE_DEBUG_TRACKING_POINTER sl@0: // BUGBUG debug only sl@0: /// INTERNAL ONLY sl@0: friend std::ostream &operator <<(std::ostream &sout, basic_regex const &rex) sl@0: { sl@0: rex.dump_(sout); sl@0: return sout; sl@0: } sl@0: #endif sl@0: //}}AFX_DEBUG sl@0: sl@0: private: sl@0: friend struct detail::core_access; sl@0: sl@0: // Avoid a common programming mistake. Construction from a string is ambiguous. It could mean sl@0: // sregex rx = sregex::compile(str); // compile the string into a regex sl@0: // or sl@0: // sregex rx = as_xpr(str); // treat the string as a literal sl@0: // Since there is no easy way to disambiguate, disallow it and force users to say what they mean sl@0: /// INTERNAL ONLY sl@0: basic_regex(char_type const *); sl@0: /// INTERNAL ONLY sl@0: basic_regex(string_type const &); sl@0: sl@0: // used from parser, via core_access sl@0: /// INTERNAL ONLY sl@0: explicit basic_regex(detail::regex_impl const &that) sl@0: : impl_() sl@0: { sl@0: this->impl_.tracking_copy(that); sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: bool match_(detail::state_type &state) const sl@0: { sl@0: return this->impl_->xpr_->match(state); sl@0: } sl@0: sl@0: // Returns true if this basic_regex object does not contain a valid regular expression. sl@0: /// INTERNAL ONLY sl@0: bool invalid_() const sl@0: { sl@0: return !this->impl_ || !this->impl_->xpr_; sl@0: } sl@0: sl@0: /// INTERNAL ONLY sl@0: void dump_(std::ostream &sout) const; sl@0: sl@0: // the tracking_ptr manages lazy-init, COW, cycle-breaking, and sl@0: // reference/dependency tracking. sl@0: detail::tracking_ptr > impl_; sl@0: }; sl@0: sl@0: //{{AFX_DEBUG sl@0: #ifdef BOOST_XPRESSIVE_DEBUG_TRACKING_POINTER sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // dump_ sl@0: /// INTERNAL ONLY sl@0: template sl@0: inline void basic_regex::dump_(std::ostream &sout) const sl@0: { sl@0: if(!this->impl_) sl@0: { sl@0: sout << " refs={} deps={}"; sl@0: } sl@0: else sl@0: { sl@0: sout << *this->impl_; sl@0: } sl@0: } sl@0: #endif sl@0: //}}AFX_DEBUG sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // swap sl@0: /// \brief Swaps the contents of two basic_regex objects. sl@0: /// \param left The first basic_regex object. sl@0: /// \param right The second basic_regex object. sl@0: /// \attention This is a shallow swap that does not do reference tracking. sl@0: /// If you embed a basic_regex object by reference in another regular expression sl@0: /// and then swap its contents with another basic_regex object, the change will sl@0: /// not be visible to the enclosing regular expression. It is done this way to sl@0: /// ensure that swap() cannot throw. sl@0: /// \throw nothrow sl@0: template sl@0: inline void swap(basic_regex &left, basic_regex &right) // throw() sl@0: { sl@0: left.swap(right); sl@0: } sl@0: sl@0: }} // namespace boost::xpressive sl@0: sl@0: #endif // BOOST_XPRESSIVE_REGEX_HPP_EAN_10_04_2005