FM / core

/usr/include/boost/xpressive/detail/core/

/usr/include/boost/xpressive/detail/core

Name	Size	Mode	Actions
matcher/	-	0755	rm
access.hpp	3514	0644	edit dl rm
action.hpp	1052	0644	edit dl rm
adaptor.hpp	2370	0644	edit dl rm
finder.hpp	6210	0644	edit dl rm
flow_control.hpp	2364	0644	edit dl rm
icase.hpp	1357	0644	edit dl rm
linker.hpp	8567	0644	edit dl rm
list.hpp	6433	0644	edit dl rm
matchers.hpp	2772	0644	edit dl rm
optimize.hpp	3466	0644	edit dl rm
peeker.hpp	8002	0644	edit dl rm
quant_style.hpp	4451	0644	edit dl rm
regex_domain.hpp	834	0644	edit dl rm
regex_impl.hpp	5591	0644	edit dl rm
results_cache.hpp	4480	0644	edit dl rm
state.hpp	13463	0644	edit dl rm
sub_match_impl.hpp	1295	0644	edit dl rm
sub_match_vector.hpp	4196	0644	edit dl rm

Edit: /usr/include/boost/xpressive/detail/core/optimize.hpp (3466B)

#ifndef BOOST_XPRESSIVE_DETAIL_CORE_OPTIMIZE_HPP_EAN_10_04_2005
#define BOOST_XPRESSIVE_DETAIL_CORE_OPTIMIZE_HPP_EAN_10_04_2005

#include <string>
#include <utility>
#include <boost/mpl/bool.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/xpressive/detail/core/finder.hpp>
#include <boost/xpressive/detail/core/linker.hpp>
#include <boost/xpressive/detail/core/peeker.hpp>
#include <boost/xpressive/detail/core/regex_impl.hpp>

namespace boost { namespace xpressive { namespace detail
{

///////////////////////////////////////////////////////////////////////////////
// optimize_regex
//
template<typename BidiIter, typename Traits>
intrusive_ptr<finder<BidiIter> > optimize_regex
(
    xpression_peeker<typename iterator_value<BidiIter>::type> const &peeker
  , Traits const &tr
  , mpl::false_
)
{
    if(peeker.line_start())
    {
        return intrusive_ptr<finder<BidiIter> >
        (
            new line_start_finder<BidiIter, Traits>(tr)
        );
    }
    else if(peeker.leading_simple_repeat())
    {
        return intrusive_ptr<finder<BidiIter> >
        (
            new leading_simple_repeat_finder<BidiIter>()
        );
    }
    else if(256 != peeker.bitset().count())
    {
        return intrusive_ptr<finder<BidiIter> >
        (
            new hash_peek_finder<BidiIter, Traits>(peeker.bitset())
        );
    }

return intrusive_ptr<finder<BidiIter> >();
}

// if we have a leading string literal, initialize a boyer-moore struct with it
    peeker_string<char_type> const &str = peeker.get_string();
    if(str.begin_ != str.end_)
    {
        BOOST_ASSERT(1 == peeker.bitset().count());
        return intrusive_ptr<finder<BidiIter> >
        (
            new boyer_moore_finder<BidiIter, Traits>(str.begin_, str.end_, tr, str.icase_)
        );
    }

return optimize_regex<BidiIter>(peeker, tr, mpl::false_());
}

///////////////////////////////////////////////////////////////////////////////
// common_compile
//
template<typename BidiIter, typename Traits>
void common_compile
(
    intrusive_ptr<matchable_ex<BidiIter> const> const &regex
  , regex_impl<BidiIter> &impl
  , Traits const &tr
)
{
    typedef typename iterator_value<BidiIter>::type char_type;

// "link" the regex
    xpression_linker<char_type> linker(tr);
    regex->link(linker);

// "peek" into the compiled regex to see if there are optimization opportunities
    hash_peek_bitset<char_type> bset;
    xpression_peeker<char_type> peeker(bset, tr, linker.has_backrefs());
    regex->peek(peeker);

// optimization: get the peek chars OR the boyer-moore search string
    impl.finder_ = optimize_regex<BidiIter>(peeker, tr, is_random<BidiIter>());
    impl.xpr_ = regex;
}

}}} // namespace boost::xpressive

#endif

/////////////////////////////////////////////////////////////////////////////// // optimize.hpp // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_XPRESSIVE_DETAIL_CORE_OPTIMIZE_HPP_EAN_10_04_2005 #define BOOST_XPRESSIVE_DETAIL_CORE_OPTIMIZE_HPP_EAN_10_04_2005 #include #include #include #include #include #include #include #include #include namespace boost { namespace xpressive { namespace detail { /////////////////////////////////////////////////////////////////////////////// // optimize_regex // template intrusive_ptr > optimize_regex ( xpression_peeker::type> const &peeker , Traits const &tr , mpl::false_ ) { if(peeker.line_start()) { return intrusive_ptr > ( new line_start_finder(tr) ); } else if(peeker.leading_simple_repeat()) { return intrusive_ptr > ( new leading_simple_repeat_finder() ); } else if(256 != peeker.bitset().count()) { return intrusive_ptr > ( new hash_peek_finder(peeker.bitset()) ); } return intrusive_ptr >(); } /////////////////////////////////////////////////////////////////////////////// // optimize_regex // template intrusive_ptr > optimize_regex ( xpression_peeker::type> const &peeker , Traits const &tr , mpl::true_ ) { typedef typename iterator_value::type char_type; // if we have a leading string literal, initialize a boyer-moore struct with it peeker_string const &str = peeker.get_string(); if(str.begin_ != str.end_) { BOOST_ASSERT(1 == peeker.bitset().count()); return intrusive_ptr > ( new boyer_moore_finder(str.begin_, str.end_, tr, str.icase_) ); } return optimize_regex(peeker, tr, mpl::false_()); } /////////////////////////////////////////////////////////////////////////////// // common_compile // template void common_compile ( intrusive_ptr const> const ®ex , regex_impl &impl , Traits const &tr ) { typedef typename iterator_value::type char_type; // "link" the regex xpression_linker linker(tr); regex->link(linker); // "peek" into the compiled regex to see if there are optimization opportunities hash_peek_bitset bset; xpression_peeker peeker(bset, tr, linker.has_backrefs()); regex->peek(peeker); // optimization: get the peek chars OR the boyer-moore search string impl.finder_ = optimize_regex(peeker, tr, is_random()); impl.xpr_ = regex; } }}} // namespace boost::xpressive #endif