FM / static

/usr/include/boost/xpressive/detail/static/

/usr/include/boost/xpressive/detail/static

Name	Size	Mode	Actions
transforms/	-	0755	rm
compile.hpp	4186	0644	edit dl rm
grammar.hpp	12801	0644	edit dl rm
is_pure.hpp	7685	0644	edit dl rm
modifier.hpp	1858	0644	edit dl rm
placeholders.hpp	3136	0644	edit dl rm
static.hpp	7632	0644	edit dl rm
transmogrify.hpp	8133	0644	edit dl rm
type_traits.hpp	2337	0644	edit dl rm
visitor.hpp	4221	0644	edit dl rm
width_of.hpp	8960	0644	edit dl rm

Edit: /usr/include/boost/xpressive/detail/static/grammar.hpp (12801B)

#ifndef BOOST_XPRESSIVE_DETAIL_STATIC_GRAMMAR_HPP_EAN_11_12_2006
#define BOOST_XPRESSIVE_DETAIL_STATIC_GRAMMAR_HPP_EAN_11_12_2006

// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif

#include <boost/mpl/if.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/proto/core.hpp>
#include <boost/xpressive/detail/static/is_pure.hpp>
#include <boost/xpressive/detail/static/transforms/as_matcher.hpp>
#include <boost/xpressive/detail/static/transforms/as_alternate.hpp>
#include <boost/xpressive/detail/static/transforms/as_sequence.hpp>
#include <boost/xpressive/detail/static/transforms/as_quantifier.hpp>
#include <boost/xpressive/detail/static/transforms/as_marker.hpp>
#include <boost/xpressive/detail/static/transforms/as_set.hpp>
#include <boost/xpressive/detail/static/transforms/as_independent.hpp>
#include <boost/xpressive/detail/static/transforms/as_modifier.hpp>
#include <boost/xpressive/detail/static/transforms/as_inverse.hpp>
#include <boost/xpressive/detail/static/transforms/as_action.hpp>
#include <boost/xpressive/detail/detail_fwd.hpp>

#define BOOST_XPRESSIVE_CHECK_REGEX(Expr, Char)\
    BOOST_MPL_ASSERT\
    ((\
        typename boost::mpl::if_c<\
            boost::xpressive::is_valid_regex<Expr, Char>::value\
          , boost::mpl::true_\
          , boost::xpressive::INVALID_REGULAR_EXPRESSION\
        >::type\
    ));

//////////////////////////////////////////////////////////////////////////
//**********************************************************************//
//*                            << NOTE! >>                             *//
//*                                                                    *//
//* Whenever you change this grammar, you MUST also make corresponding *//
//* changes to width_of.hpp and is_pure.hpp.                           *//
//*                                                                    *//
//**********************************************************************//
//////////////////////////////////////////////////////////////////////////

namespace boost { namespace xpressive
{
    template<typename Char>
    struct Grammar;

template<typename Char>
    struct ActionableGrammar;

namespace grammar_detail
    {
        ///////////////////////////////////////////////////////////////////////////
        // CharLiteral
        template<typename Char>
        struct CharLiteral;

///////////////////////////////////////////////////////////////////////////
        // ListSet
        template<typename Char>
        struct ListSet;

///////////////////////////////////////////////////////////////////////////
        // as_repeat
        template<typename Char, typename Gram, typename Greedy>
        struct as_repeat
          : if_<
                make<detail::use_simple_repeat<_child, Char> >
              , as_simple_quantifier<Gram, Greedy>
              , as_default_quantifier<Greedy>
            >
        {};

///////////////////////////////////////////////////////////////////////////
        // NonGreedyRepeatCases
        template<typename Gram>
        struct NonGreedyRepeatCases
        {
            template<typename Tag, typename Dummy = void>
            struct case_
              : not_<_>
            {};

template<typename Dummy>
            struct case_<tag::dereference, Dummy>
              : dereference<Gram>
            {};

template<typename Dummy>
            struct case_<tag::unary_plus, Dummy>
              : unary_plus<Gram>
            {};

template<typename Dummy>
            struct case_<tag::logical_not, Dummy>
              : logical_not<Gram>
            {};

template<uint_t Min, uint_t Max, typename Dummy>
            struct case_<detail::generic_quant_tag<Min, Max>, Dummy>
              : unary_expr<detail::generic_quant_tag<Min, Max>, Gram>
            {};
        };

///////////////////////////////////////////////////////////////////////////
        // InvertibleCases
        template<typename Char, typename Gram>
        struct InvertibleCases
        {
            template<typename Tag, typename Dummy = void>
            struct case_
              : not_<_>
            {};

template<typename Dummy>
            struct case_<tag::comma, Dummy>
              : when<ListSet<Char>, as_list_set_matcher<Char> >
            {};

template<typename Dummy>
            struct case_<tag::assign, Dummy>
              : when<ListSet<Char>, as_list_set_matcher<Char> >
            {};

template<typename Dummy>
            struct case_<tag::subscript, Dummy>
              : when<subscript<detail::set_initializer_type, Gram>, call<as_set_matcher<Gram>(_right)> >
            {};

template<typename Dummy>
            struct case_<detail::lookahead_tag, Dummy>
              : when<
                    unary_expr<detail::lookahead_tag, Gram>
                  , as_lookahead<Gram>
                >
            {};

template<typename Dummy>
            struct case_<detail::lookbehind_tag, Dummy>
              : when<
                    unary_expr<detail::lookbehind_tag, Gram>
                  , as_lookbehind<Gram>
                >
            {};

template<typename Dummy>
            struct case_<tag::terminal, Dummy>
              : when<
                    or_<
                        CharLiteral<Char>
                      , terminal<detail::posix_charset_placeholder>
                      , terminal<detail::range_placeholder<_> >
                      , terminal<detail::logical_newline_placeholder>
                      , terminal<detail::assert_word_placeholder<detail::word_boundary<mpl::true_> > >
                    >
                  , as_matcher
                >
            {};
        };

///////////////////////////////////////////////////////////////////////////
        // Cases
        template<typename Char, typename Gram>
        struct Cases
        {
            template<typename Tag, typename Dummy = void>
            struct case_
              : not_<_>
            {};

template<typename Dummy>
            struct case_<tag::terminal, Dummy>
              : when<
                    _
                  , in_sequence<as_matcher>
                >
            {};

template<typename Dummy>
            struct case_<tag::shift_right, Dummy>
              : when<
                    shift_right<Gram, Gram>
                  , reverse_fold<_, _state, Gram>
                >
            {};

template<typename Dummy>
            struct case_<tag::bitwise_or, Dummy>
              : when<
                    bitwise_or<Gram, Gram>
                  , in_sequence<
                        as_alternate_matcher<
                            reverse_fold_tree<_, make<fusion::nil>, in_alternate_list<Gram> >
                        >
                    >
                >
            {};

template<typename Dummy, typename Greedy>
            struct case_<optional_tag<Greedy> , Dummy>
              : when<
                    unary_expr<optional_tag<Greedy>, Gram>
                  , in_sequence<call<as_optional<Gram, Greedy>(_child)> >
                >
            {};

template<typename Dummy>
            struct case_<tag::dereference, Dummy>
              : when<
                    dereference<Gram>
                  , call<Gram(as_repeat<Char, Gram, mpl::true_>)>
                >
            {};

template<typename Dummy>
            struct case_<tag::unary_plus, Dummy>
              : when<
                    unary_plus<Gram>
                  , call<Gram(as_repeat<Char, Gram, mpl::true_>)>
                >
            {};

template<typename Dummy>
            struct case_<tag::logical_not, Dummy>
              : when<
                    logical_not<Gram>
                  , call<Gram(as_repeat<Char, Gram, mpl::true_>)>
                >
            {};

template<uint_t Min, uint_t Max, typename Dummy>
            struct case_<detail::generic_quant_tag<Min, Max>, Dummy>
              : when<
                    unary_expr<detail::generic_quant_tag<Min, Max>, Gram>
                  , call<Gram(as_repeat<Char, Gram, mpl::true_>)>
                >
            {};

template<typename Dummy>
            struct case_<tag::negate, Dummy>
              : when<
                    negate<switch_<NonGreedyRepeatCases<Gram> > >
                  , call<Gram(call<as_repeat<Char, Gram, mpl::false_>(_child)>)>
                >
            {};

template<typename Dummy>
            struct case_<tag::complement, Dummy>
              : when<
                    complement<switch_<InvertibleCases<Char, Gram> > >
                  , in_sequence<call<as_inverse(call<switch_<InvertibleCases<Char, Gram> >(_child)>)> >
                >
            {};

template<typename Dummy>
            struct case_<detail::modifier_tag, Dummy>
              : when<binary_expr<detail::modifier_tag, _, Gram>, as_modifier<Gram> >
            {};

template<typename Dummy>
            struct case_<detail::lookahead_tag, Dummy>
              : when<
                    unary_expr<detail::lookahead_tag, Gram>
                  , in_sequence<as_lookahead<Gram> >
                >
            {};

template<typename Dummy>
            struct case_<detail::lookbehind_tag, Dummy>
              : when<
                    unary_expr<detail::lookbehind_tag, Gram>
                  , in_sequence<as_lookbehind<Gram> >
                >
            {};

template<typename Dummy>
            struct case_<detail::keeper_tag, Dummy>
              : when<
                    unary_expr<detail::keeper_tag, Gram>
                  , in_sequence<as_keeper<Gram> >
                >
            {};

template<typename Dummy>
            struct case_<tag::comma, Dummy>
              : when<ListSet<Char>, in_sequence<as_list_set_matcher<Char> > >
            {};

template<typename Dummy>
            struct case_<tag::assign, Dummy>
              : or_<
                    when<assign<detail::basic_mark_tag, Gram>, call<Gram(as_marker)> >
                  , when<ListSet<Char>, in_sequence<as_list_set_matcher<Char> > >
                >
            {};

template<typename Dummy>
            struct case_<tag::subscript, Dummy>
              : or_<
                    when<subscript<detail::set_initializer_type, Gram>, in_sequence<call<as_set_matcher<Gram>(_right)> > >
                  , when<subscript<ActionableGrammar<Char>, _>, call<ActionableGrammar<Char>(as_action)> >
                >
            {};
        };

///////////////////////////////////////////////////////////////////////////
        // ActionableCases
        template<typename Char, typename Gram>
        struct ActionableCases
        {
            template<typename Tag, typename Dummy = void>
            struct case_
              : Cases<Char, Gram>::template case_<Tag>
            {};

// Only in sub-expressions with actions attached do we allow attribute assignements
            template<typename Dummy>
            struct case_<proto::tag::assign, Dummy>
              : or_<
                    typename Cases<Char, Gram>::template case_<proto::tag::assign>
                  , when<proto::assign<terminal<detail::attribute_placeholder<_> >, _>, in_sequence<as_attr_matcher> >
                >
            {};
        };

} // namespace detail

///////////////////////////////////////////////////////////////////////////
    // Grammar
    template<typename Char>
    struct Grammar
      : proto::switch_<grammar_detail::Cases<Char, Grammar<Char> > >
    {};

template<typename Char>
    struct ActionableGrammar
      : proto::switch_<grammar_detail::ActionableCases<Char, ActionableGrammar<Char> > >
    {};

///////////////////////////////////////////////////////////////////////////
    // INVALID_REGULAR_EXPRESSION
    struct INVALID_REGULAR_EXPRESSION
      : mpl::false_
    {};

///////////////////////////////////////////////////////////////////////////
    // is_valid_regex
    template<typename Expr, typename Char>
    struct is_valid_regex
      : proto::matches<Expr, Grammar<Char> >
    {};

}} // namespace boost::xpressive

#endif

/////////////////////////////////////////////////////////////////////////////// // grammar.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_STATIC_GRAMMAR_HPP_EAN_11_12_2006 #define BOOST_XPRESSIVE_DETAIL_STATIC_GRAMMAR_HPP_EAN_11_12_2006 // MS compatible compilers support #pragma once #if defined(_MSC_VER) # pragma once #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define BOOST_XPRESSIVE_CHECK_REGEX(Expr, Char)\ BOOST_MPL_ASSERT\ ((\ typename boost::mpl::if_c<\ boost::xpressive::is_valid_regex::value\ , boost::mpl::true_\ , boost::xpressive::INVALID_REGULAR_EXPRESSION\ >::type\ )); ////////////////////////////////////////////////////////////////////////// //**********************************************************************// //* << NOTE! >> *// //* *// //* Whenever you change this grammar, you MUST also make corresponding *// //* changes to width_of.hpp and is_pure.hpp. *// //* *// //**********************************************************************// ////////////////////////////////////////////////////////////////////////// namespace boost { namespace xpressive { template struct Grammar; template struct ActionableGrammar; namespace grammar_detail { /////////////////////////////////////////////////////////////////////////// // CharLiteral template struct CharLiteral; /////////////////////////////////////////////////////////////////////////// // ListSet template struct ListSet; /////////////////////////////////////////////////////////////////////////// // as_repeat template struct as_repeat : if_< make > , as_simple_quantifier , as_default_quantifier > {}; /////////////////////////////////////////////////////////////////////////// // NonGreedyRepeatCases template struct NonGreedyRepeatCases { template struct case_ : not_<_> {}; template struct case_ : dereference {}; template struct case_ : unary_plus {}; template struct case_ : logical_not {}; template struct case_, Dummy> : unary_expr, Gram> {}; }; /////////////////////////////////////////////////////////////////////////// // InvertibleCases template struct InvertibleCases { template struct case_ : not_<_> {}; template struct case_ : when, as_list_set_matcher > {}; template struct case_ : when, as_list_set_matcher > {}; template struct case_ : when, call(_right)> > {}; template struct case_ : when< unary_expr , as_lookahead > {}; template struct case_ : when< unary_expr , as_lookbehind > {}; template struct case_ : when< or_< CharLiteral , terminal , terminal > , terminal , terminal > > > , as_matcher > {}; }; /////////////////////////////////////////////////////////////////////////// // Cases template struct Cases { template struct case_ : not_<_> {}; template struct case_ : when< _ , in_sequence > {}; template struct case_ : when< shift_right , reverse_fold<_, _state, Gram> > {}; template struct case_ : when< bitwise_or , in_sequence< as_alternate_matcher< reverse_fold_tree<_, make, in_alternate_list > > > > {}; template struct case_ , Dummy> : when< unary_expr, Gram> , in_sequence(_child)> > > {}; template struct case_ : when< dereference , call)> > {}; template struct case_ : when< unary_plus , call)> > {}; template struct case_ : when< logical_not , call)> > {}; template struct case_, Dummy> : when< unary_expr, Gram> , call)> > {}; template struct case_ : when< negate > > , call(_child)>)> > {}; template struct case_ : when< complement > > , in_sequence >(_child)>)> > > {}; template struct case_ : when, as_modifier > {}; template struct case_ : when< unary_expr , in_sequence > > {}; template struct case_ : when< unary_expr , in_sequence > > {}; template struct case_ : when< unary_expr , in_sequence > > {}; template struct case_ : when, in_sequence > > {}; template struct case_ : or_< when, call > , when, in_sequence > > > {}; template struct case_ : or_< when, in_sequence(_right)> > > , when, _>, call(as_action)> > > {}; }; /////////////////////////////////////////////////////////////////////////// // ActionableCases template struct ActionableCases { template struct case_ : Cases::template case_ {}; // Only in sub-expressions with actions attached do we allow attribute assignements template struct case_ : or_< typename Cases::template case_ , when >, _>, in_sequence > > {}; }; } // namespace detail /////////////////////////////////////////////////////////////////////////// // Grammar template struct Grammar : proto::switch_ > > {}; template struct ActionableGrammar : proto::switch_ > > {}; /////////////////////////////////////////////////////////////////////////// // INVALID_REGULAR_EXPRESSION struct INVALID_REGULAR_EXPRESSION : mpl::false_ {}; /////////////////////////////////////////////////////////////////////////// // is_valid_regex template struct is_valid_regex : proto::matches > {}; }} // namespace boost::xpressive #endif