Contains the definition of the basic_regex<> class template and its associated helper functions.

namespace boost {
  namespace xpressive {
    template<typename BidiIter> 
      void swap(basic_regex< BidiIter > &, basic_regex< BidiIter > &);
  }
}

Contains the definition of the match_results type and associated helpers. The match_results type holds the results of a regex_match() or regex_search() operation.

Defines the syntax elements of xpressive's action expressions.

namespace boost {
  namespace xpressive {
    template<typename PolymorphicFunctionObject> struct function;

    function< op::at >::type const at;    // at is a lazy PolymorphicFunctionObject for indexing into a sequence in an xpressive semantic action. 
    function< op::push >::type const push;    // push is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::push_back >::type const push_back;    // push_back is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::push_front >::type const push_front;    // push_front is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::pop >::type const pop;    // pop is a lazy PolymorphicFunctionObject for popping the top element from a sequence in an xpressive semantic action. 
    function< op::pop_back >::type const pop_back;    // pop_back is a lazy PolymorphicFunctionObject for popping the back element from a sequence in an xpressive semantic action. 
    function< op::pop_front >::type const pop_front;    // pop_front is a lazy PolymorphicFunctionObject for popping the front element from a sequence in an xpressive semantic action. 
    function< op::top >::type const top;    // top is a lazy PolymorphicFunctionObject for accessing the top element from a stack in an xpressive semantic action. 
    function< op::back >::type const back;    // back is a lazy PolymorphicFunctionObject for fetching the back element of a sequence in an xpressive semantic action. 
    function< op::front >::type const front;    // front is a lazy PolymorphicFunctionObject for fetching the front element of a sequence in an xpressive semantic action. 
    function< op::first >::type const first;    // first is a lazy PolymorphicFunctionObject for accessing the first element of a std::pair<> in an xpressive semantic action. 
    function< op::second >::type const second;    // second is a lazy PolymorphicFunctionObject for accessing the second element of a std::pair<> in an xpressive semantic action. 
    function< op::matched >::type const matched;    // matched is a lazy PolymorphicFunctionObject for accessing the matched member of a xpressive::sub_match<> in an xpressive semantic action. 
    function< op::length >::type const length;    // length is a lazy PolymorphicFunctionObject for computing the length of a xpressive::sub_match<> in an xpressive semantic action. 
    function< op::str >::type const str;    // str is a lazy PolymorphicFunctionObject for converting a xpressive::sub_match<> to a std::basic_string<> in an xpressive semantic action. 
    function< op::insert >::type const insert;    // insert is a lazy PolymorphicFunctionObject for inserting a value or a range of values into a sequence in an xpressive semantic action. 
    function< op::make_pair >::type const make_pair;    // make_pair is a lazy PolymorphicFunctionObject for making a std::pair<> in an xpressive semantic action. 
    function< op::unwrap_reference >::type const unwrap_reference;    // unwrap_reference is a lazy PolymorphicFunctionObject for unwrapping a boost::reference_wrapper<> in an xpressive semantic action. 
    template<typename T, typename A> unspecified as(A const &);
    template<typename T, typename A> unspecified static_cast_(A const &);
    template<typename T, typename A> unspecified dynamic_cast_(A const &);
    template<typename T, typename A> unspecified const_cast_(A const &);
    template<typename T> value< T > const val(T const &);
    template<typename T> reference< T > const ref(T &);
    template<typename T> reference< T const  > const cref(T const &);
    template<typename T> unspecified check(T const &);
    template<typename... ArgBindings> unspecified let(ArgBindings const &...);
    template<typename T, typename... Args> 
      unspecified construct(Args const &...);
    namespace op {
      struct at;
      struct push;
      struct push_back;
      struct push_front;
      struct pop;
      struct pop_back;
      struct pop_front;
      struct front;
      struct back;
      struct top;
      struct first;
      struct second;
      struct matched;
      struct length;
      struct str;
      struct insert;
      struct make_pair;
      struct unwrap_reference;
    }
  }
}

Contains the regex_match(), regex_search() and regex_replace() algorithms.

namespace boost {
  namespace xpressive {
    template<typename BidiIter> 
      bool regex_match(BidiIter, BidiIter, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiIter> 
      bool regex_match(BidiIter, BidiIter, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename Char> 
      bool regex_match(Char *, match_results< Char * > &, 
                       basic_regex< Char * > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange &, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange const &, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename Char> 
      bool regex_match(Char *, basic_regex< Char * > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange &, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange const &, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiIter> 
      bool regex_search(BidiIter, BidiIter, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiIter> 
      bool regex_search(BidiIter, BidiIter, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename Char> 
      bool regex_search(Char *, match_results< Char * > &, 
                        basic_regex< Char * > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange &, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange const &, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename Char> 
      bool regex_search(Char *, basic_regex< Char * > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange &, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange const &, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename OutIter, typename BidiIter, typename Formatter> 
      OutIter regex_replace(OutIter, BidiIter, BidiIter, 
                            basic_regex< BidiIter > const &, 
                            Formatter const &, 
                            regex_constants::match_flag_type = regex_constants::match_default, 
                            unspecified = 0);
    template<typename OutIter, typename BidiIter> 
      OutIter regex_replace(OutIter, BidiIter, BidiIter, 
                            basic_regex< BidiIter > const &, 
                            typename iterator_value< BidiIter >::type const *, 
                            regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
      BidiContainer 
      regex_replace(BidiContainer &, basic_regex< BidiIter > const &, 
                    Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
      BidiContainer 
      regex_replace(BidiContainer const &, basic_regex< BidiIter > const &, 
                    Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename Char, typename Formatter> 
      std::basic_string< typename remove_const< Char >::type > 
      regex_replace(Char *, basic_regex< Char * > const &, Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter> 
      BidiContainer 
      regex_replace(BidiContainer &, basic_regex< BidiIter > const &, 
                    typename iterator_value< BidiIter >::type const *, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter> 
      BidiContainer 
      regex_replace(BidiContainer const &, basic_regex< BidiIter > const &, 
                    typename iterator_value< BidiIter >::type const *, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename Char> 
      std::basic_string< typename remove_const< Char >::type > 
      regex_replace(Char *, basic_regex< Char * > const &, 
                    typename add_const< Char >::type *, 
                    regex_constants::match_flag_type = regex_constants::match_default);
  }
}

Contains the definition of regex_compiler, a factory for building regex objects from strings.

Contains definitions for the syntax_option_type, match_flag_type and error_type enumerations.

namespace boost {
  namespace xpressive {
    namespace regex_constants {
      enum syntax_option_type;
      enum match_flag_type;
      enum error_type;
    }
  }
}

Contains the definition of the regex_error exception class.

BOOST_XPR_ENSURE_(pred, code, msg)

namespace boost {
  namespace xpressive {
    struct regex_error;
  }
}

Contains the definition of the regex_iterator type, an STL-compatible iterator for stepping through all the matches in a sequence.

Contains the syntax elements for writing static regular expressions.

namespace boost {
  namespace xpressive {
    struct mark_tag;

    unsigned int const inf;    // For infinite repetition of a sub-expression. 
    unspecified nil;    // Successfully matches nothing. 
    unspecified alnum;    // Matches an alpha-numeric character. 
    unspecified alpha;    // Matches an alphabetic character. 
    unspecified blank;    // Matches a blank (horizonal white-space) character. 
    unspecified cntrl;    // Matches a control character. 
    unspecified digit;    // Matches a digit character. 
    unspecified graph;    // Matches a graph character. 
    unspecified lower;    // Matches a lower-case character. 
    unspecified print;    // Matches a printable character. 
    unspecified punct;    // Matches a punctuation character. 
    unspecified space;    // Matches a space character. 
    unspecified upper;    // Matches an upper-case character. 
    unspecified xdigit;    // Matches a hexadecimal digit character. 
    unspecified bos;    // Beginning of sequence assertion. 
    unspecified eos;    // End of sequence assertion. 
    unspecified bol;    // Beginning of line assertion. 
    unspecified eol;    // End of line assertion. 
    unspecified bow;    // Beginning of word assertion. 
    unspecified eow;    // End of word assertion. 
    unspecified _b;    // Word boundary assertion. 
    unspecified _w;    // Matches a word character. 
    unspecified _d;    // Matches a digit character. 
    unspecified _s;    // Matches a space character. 
    proto::terminal< char >::type const _n;    // Matches a literal newline character, '\n'. 
    unspecified _ln;    // Matches a logical newline sequence. 
    unspecified _;    // Matches any one character. 
    unspecified self;    // Reference to the current regex object. 
    unspecified set;    // Used to create character sets. 
    mark_tag const s0;    // Sub-match placeholder, like $& in Perl. 
    mark_tag const s1;    // Sub-match placeholder, like $1 in perl. 
    mark_tag const s2;
    mark_tag const s3;
    mark_tag const s4;
    mark_tag const s5;
    mark_tag const s6;
    mark_tag const s7;
    mark_tag const s8;
    mark_tag const s9;
    unspecified a1;
    unspecified a2;
    unspecified a3;
    unspecified a4;
    unspecified a5;
    unspecified a6;
    unspecified a7;
    unspecified a8;
    unspecified a9;
    template<typename Expr> unspecified icase(Expr const &);
    template<typename Literal> unspecified as_xpr(Literal const &);
    template<typename BidiIter> 
      proto::terminal< reference_wrapper< basic_regex< BidiIter > const  > >::type const 
      by_ref(basic_regex< BidiIter > const &);
    template<typename Char> unspecified range(Char, Char);
    template<typename Expr> 
      proto::result_of::make_expr< proto::tag::logical_not, proto::default_domain, Expr const & >::type const 
      optional(Expr const &);
    template<unsigned int Min, unsigned int Max, typename Expr> 
      unspecified repeat(Expr const &);
    template<unsigned int Count, typename Expr2> 
      unspecified repeat(Expr2 const &);
    template<typename Expr> unspecified keep(Expr const &);
    template<typename Expr> unspecified before(Expr const &);
    template<typename Expr> unspecified after(Expr const &);
    template<typename Locale> unspecified imbue(Locale const &);
    template<typename Skip> unspecified skip(Skip const &);
  }
}

Contains the definition of regex_token_iterator, and STL-compatible iterator for tokenizing a string using a regular expression.

Includes the C regex traits or the CPP regex traits header file depending on the BOOST_XPRESSIVE_USE_C_TRAITS macro.

namespace boost {
  namespace xpressive {
    struct regex_traits_version_1_tag;
    struct regex_traits_version_2_tag;
  }
}

Contains the definition of the class template sub_match<> and associated helper functions

namespace boost {
  namespace xpressive {
    template<typename BidiIter> BidiIter range_begin(sub_match< BidiIter > &);
    template<typename BidiIter> 
      BidiIter range_begin(sub_match< BidiIter > const &);
    template<typename BidiIter> BidiIter range_end(sub_match< BidiIter > &);
    template<typename BidiIter> 
      BidiIter range_end(sub_match< BidiIter > const &);
    template<typename BidiIter, typename Char, typename Traits> 
      std::basic_ostream< Char, Traits > & 
      operator<<(std::basic_ostream< Char, Traits > &, 
                 sub_match< BidiIter > const &);
    template<typename BidiIter> 
      bool operator==(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator!=(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<(sub_match< BidiIter > const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<=(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>=(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>(sub_match< BidiIter > const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator==(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator!=(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<(typename iterator_value< BidiIter >::type const * lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>(typename iterator_value< BidiIter >::type const * lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>=(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<=(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator==(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator!=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator<(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator>(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator>=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator<=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator==(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator!=(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<(typename iterator_value< BidiIter >::type const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>(typename iterator_value< BidiIter >::type const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>=(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<=(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator==(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator!=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator<(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator>(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator>=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator<=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(typename iterator_value< BidiIter >::type const & lhs, 
                sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(typename iterator_value< BidiIter >::type const * lhs, 
                sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                typename sub_match< BidiIter >::string_type const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(typename sub_match< BidiIter >::string_type const & lhs, 
                sub_match< BidiIter > const & rhs);
  }
}

Contains the definition of the c_regex_traits<> template, which is a wrapper for the C locale functions that can be used to customize the behavior of static and dynamic regexes.

Contains the definition of the cpp_regex_traits<> template, which is a wrapper for std::locale that can be used to customize the behavior of static and dynamic regexes.

Contains the definition of the null_regex_traits<> template, which is a stub regex traits implementation that can be used by static and dynamic regexes for searching non-character data.

Includes all of xpressive including support for both static and dynamic regular expressions.

Includes everything you need to write and use dynamic regular expressions.

Forward declarations for all of xpressive's public data types.

BOOST_PROTO_FUSION_V2
BOOST_XPRESSIVE_HAS_MS_STACK_GUARD

namespace boost {
  namespace xpressive {
    template<typename Char> struct cpp_regex_traits;
    template<typename Char> struct c_regex_traits;
    template<typename Elem> struct null_regex_traits;
    template<typename Trait> struct has_fold_case;
    template<typename BidiIter> struct basic_regex;
    template<typename BidiIter> struct match_results;
    template<typename BidiIter> struct regex_iterator;
    template<typename BidiIter> struct regex_token_iterator;
    template<typename BidiIter> struct regex_id_filter_predicate;
    template<typename BidiIter> struct sub_match;
    template<typename RegexTraits> struct compiler_traits;
    template<typename Char, 
             typename Impl = typename detail::default_regex_traits<Char>::type> 
      struct regex_traits;
    template<typename BidiIter, 
             typename RegexTraits = regex_traits<typename iterator_value<BidiIter>::type>, 
             typename CompilerTraits = compiler_traits<RegexTraits> > 
      struct regex_compiler;
    template<typename T> struct value;
    template<typename T> struct reference;
    template<typename T> struct local;
    template<typename T, int I = 0, typename Dummy = proto::is_proto_expr> 
      struct placeholder;

    typedef void const * regex_id_type;
    typedef basic_regex< std::string::const_iterator > sregex;
    typedef basic_regex< char const * > cregex;
    typedef basic_regex< std::wstring::const_iterator > wsregex;
    typedef basic_regex< wchar_t const * > wcregex;
    typedef sub_match< std::string::const_iterator > ssub_match;
    typedef sub_match< char const * > csub_match;
    typedef sub_match< std::wstring::const_iterator > wssub_match;
    typedef sub_match< wchar_t const * > wcsub_match;
    typedef regex_compiler< std::string::const_iterator > sregex_compiler;
    typedef regex_compiler< char const * > cregex_compiler;
    typedef regex_compiler< std::wstring::const_iterator > wsregex_compiler;
    typedef regex_compiler< wchar_t const * > wcregex_compiler;
    typedef regex_iterator< std::string::const_iterator > sregex_iterator;
    typedef regex_iterator< char const * > cregex_iterator;
    typedef regex_iterator< std::wstring::const_iterator > wsregex_iterator;
    typedef regex_iterator< wchar_t const * > wcregex_iterator;
    typedef regex_token_iterator< std::string::const_iterator > sregex_token_iterator;
    typedef regex_token_iterator< char const * > cregex_token_iterator;
    typedef regex_token_iterator< std::wstring::const_iterator > wsregex_token_iterator;
    typedef regex_token_iterator< wchar_t const * > wcregex_token_iterator;
    typedef match_results< std::string::const_iterator > smatch;
    typedef match_results< char const * > cmatch;
    typedef match_results< std::wstring::const_iterator > wsmatch;
    typedef match_results< wchar_t const * > wcmatch;
    typedef regex_id_filter_predicate< std::string::const_iterator > sregex_id_filter_predicate;
    typedef regex_id_filter_predicate< char const * > cregex_id_filter_predicate;
    typedef regex_id_filter_predicate< std::wstring::const_iterator > wsregex_id_filter_predicate;
    typedef regex_id_filter_predicate< wchar_t const * > wcregex_id_filter_predicate;
    namespace op {
      template<typename T> struct as;
      template<typename T> struct static_cast_;
      template<typename T> struct dynamic_cast_;
      template<typename T> struct const_cast_;
      template<typename T> struct construct;
      template<typename Except> struct throw_;
    }
  }
}

Includes everything you need to write static regular expressions and use them.

Type registrations so that xpressive can be used with the Boost.Typeof library.