FM / detail

/usr/include/boost/xpressive/detail

Name	Size	Mode	Actions
core/	-	0755	rm
dynamic/	-	0755	rm
static/	-	0755	rm
utility/	-	0755	rm
detail_fwd.hpp	11991	0644	edit dl rm

Edit: /usr/include/boost/xpressive/detail/detail_fwd.hpp (11991B)

///////////////////////////////////////////////////////////////////////////////
// detail_fwd.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_DETAIL_FWD_HPP_EAN_10_04_2005
#define BOOST_XPRESSIVE_DETAIL_DETAIL_FWD_HPP_EAN_10_04_2005

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

#include <map>
#include <string>
#include <vector>
#include <climits> // for INT_MAX
#include <typeinfo>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/size_t.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/xpressive/xpressive_fwd.hpp>

namespace boost { namespace xpressive { namespace detail
{
    typedef unsigned int uint_t;

template<uint_t Min, uint_t Max = Min>
    struct generic_quant_tag;

struct modifier_tag;

struct check_tag;

typedef mpl::size_t<INT_MAX / 2 - 1> unknown_width;

struct type_info_less;

typedef std::map<std::type_info const *, void *, type_info_less> action_args_type;

struct action_context;

struct ReplaceAlgo;

///////////////////////////////////////////////////////////////////////////////
    // placeholders
    //
    struct mark_placeholder;

struct posix_charset_placeholder;

template<typename Cond>
    struct assert_word_placeholder;

template<typename Char>
    struct range_placeholder;

struct assert_bol_placeholder;

struct assert_eol_placeholder;

struct logical_newline_placeholder;

struct self_placeholder;

template<typename Nbr>
    struct attribute_placeholder;

///////////////////////////////////////////////////////////////////////////////
    // matchers
    //
    struct end_matcher;

struct independent_end_matcher;

struct assert_bos_matcher;

struct assert_eos_matcher;

template<typename Traits>
    struct assert_bol_matcher;

template<typename Traits>
    struct assert_eol_matcher;

template<typename Cond, typename Traits>
    struct assert_word_matcher;

struct true_matcher;

template<typename Alternates, typename Traits>
    struct alternate_matcher;

struct alternate_end_matcher;

template<typename Traits>
    struct posix_charset_matcher;

template<typename BidiIter>
    struct sequence;

template<typename Traits, typename ICase>
    struct mark_matcher;

struct mark_begin_matcher;

struct mark_end_matcher;

template<typename BidiIter>
    struct regex_matcher;

template<typename BidiIter>
    struct regex_byref_matcher;

template<typename Traits>
    struct compound_charset;

template<typename Traits, typename ICase, typename CharSet = compound_charset<Traits> >
    struct charset_matcher;

template<typename Traits, typename ICase>
    struct range_matcher;

template<typename Traits, typename Size>
    struct set_matcher;

template<typename Xpr, typename Greedy>
    struct simple_repeat_matcher;

struct repeat_begin_matcher;

template<typename Greedy>
    struct repeat_end_matcher;

template<typename Traits, typename ICase, typename Not>
    struct literal_matcher;

template<typename Traits, typename ICase>
    struct string_matcher;

template<typename Actor>
    struct action_matcher;

template<typename Predicate>
    struct predicate_matcher;

template<typename Xpr, typename Greedy>
    struct optional_matcher;

template<typename Xpr, typename Greedy>
    struct optional_mark_matcher;

template<typename Matcher, typename Traits, typename ICase>
    struct attr_matcher;

template<typename Nbr>
    struct attr_begin_matcher;

struct attr_end_matcher;

template<typename Xpr>
    struct is_modifiable;

template<typename Head, typename Tail>
    struct alternates_list;

template<typename Modifier>
    struct modifier_op;

struct icase_modifier;

template<typename BidiIter, typename ICase, typename Traits>
    struct xpression_visitor;

template<typename BidiIter>
    struct regex_impl;

struct epsilon_matcher;

template<typename BidiIter>
    struct nested_results;

template<typename BidiIter>
    struct regex_id_filter_predicate;

template<typename Xpr>
    struct keeper_matcher;

template<typename Xpr>
    struct lookahead_matcher;

template<typename Xpr>
    struct lookbehind_matcher;

template<typename IsBoundary>
    struct word_boundary;

template<typename BidiIter, typename Matcher>
    sequence<BidiIter> make_dynamic(Matcher const &matcher);

template<typename Char>
    struct xpression_linker;

template<typename Char>
    struct xpression_peeker;

struct any_matcher;

template<typename Traits>
    struct logical_newline_matcher;

typedef proto::expr<proto::tag::terminal, proto::term<logical_newline_placeholder>, 0> logical_newline_xpression;

struct set_initializer;

typedef proto::expr<proto::tag::terminal, proto::term<set_initializer>, 0> set_initializer_type;

struct lookahead_tag;

struct lookbehind_tag;

struct keeper_tag;

template<typename Locale>
    struct locale_modifier;

template<typename Matcher>
    struct matcher_wrapper;

template<typename Locale, typename BidiIter>
    struct regex_traits_type;

template<typename Expr>
    struct let_;

template<typename Args, typename BidiIter>
    void bind_args(let_<Args> const &, match_results<BidiIter> &);

///////////////////////////////////////////////////////////////////////////////
    // Misc.
    struct no_next;

template<typename BidiIter>
    struct core_access;

template<typename BidiIter>
    struct match_state;

template<typename BidiIter>
    struct matchable;

template<typename BidiIter>
    struct matchable_ex;

template<typename Matcher, typename BidiIter>
    struct dynamic_xpression;

template<typename BidiIter>
    struct shared_matchable;

template<typename BidiIter>
    struct alternates_vector;

template<typename Matcher, typename Next>
    struct static_xpression;

typedef static_xpression<end_matcher, no_next> end_xpression;

typedef static_xpression<alternate_end_matcher, no_next> alternate_end_xpression;

typedef static_xpression<independent_end_matcher, no_next> independent_end_xpression;

typedef static_xpression<true_matcher, no_next> true_xpression;

template<typename Matcher, typename Next = end_xpression>
    struct static_xpression;

template<typename Top, typename Next>
    struct stacked_xpression;

template<typename Xpr>
    struct is_static_xpression;

template<typename BidiIter>
    struct sub_match_impl;

template<typename T>
    struct list;

template<typename BidiIter>
    struct results_cache;

template<typename T>
    struct sequence_stack;

template<typename BidiIter>
    struct results_extras;

template<typename BidiIter>
    struct match_context;

template<typename BidiIter>
    struct sub_match_vector;

template<typename T, typename U>
    struct action_arg;

struct actionable;

template<typename Char>
    struct traits;

template<typename Traits, typename BidiIter>
    Traits const &traits_cast(match_state<BidiIter> const &state);

template<typename Char>
    struct basic_chset;

template<typename Char>
    struct named_mark;

template<typename BidiIter>
    struct memento;

template<typename Char, typename Traits>
    void set_char(compound_charset<Traits> &chset, Char ch, Traits const &tr, bool icase);

template<typename Char, typename Traits>
    void set_range(compound_charset<Traits> &chset, Char from, Char to, Traits const &tr, bool icase);

template<typename Traits>
    void set_class(compound_charset<Traits> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr);

template<typename Char, typename Traits>
    void set_char(basic_chset<Char> &chset, Char ch, Traits const &tr, bool icase);

template<typename Char, typename Traits>
    void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &tr, bool icase);

template<typename Char, typename Traits>
    void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr);

template<typename Matcher>
    static_xpression<Matcher> const
    make_static(Matcher const &matcher);

template<typename Matcher, typename Next>
    static_xpression<Matcher, Next> const
    make_static(Matcher const &matcher, Next const &next);

int get_mark_number(basic_mark_tag const &);

template<typename Xpr, typename BidiIter>
    void static_compile(Xpr const &xpr, shared_ptr<regex_impl<BidiIter> > const &impl);

struct quant_spec;

template<typename BidiIter, typename Xpr>
    void make_simple_repeat(quant_spec const &spec, sequence<BidiIter> &seq, Xpr const &xpr);

template<typename BidiIter>
    void make_simple_repeat(quant_spec const &spec, sequence<BidiIter> &seq);

template<typename BidiIter>
    void make_repeat(quant_spec const &spec, sequence<BidiIter> &seq, int mark_nbr);

template<typename BidiIter>
    void make_repeat(quant_spec const &spec, sequence<BidiIter> &seq);

template<typename BidiIter>
    void make_optional(quant_spec const &spec, sequence<BidiIter> &seq);

template<typename BidiIter>
    void make_optional(quant_spec const &spec, sequence<BidiIter> &seq, int mark_nbr);

template<typename Char>
    struct string_type
    {
        typedef std::vector<Char> type;
    };

template<>
    struct string_type<char>
    {
        typedef std::string type;
    };

#ifndef BOOST_XPRESSIVE_NO_WREGEX
    template<>
    struct string_type<wchar_t>
    {
        typedef std::wstring type;
    };
    #endif

}}} // namespace boost::xpressive::detail

namespace boost { namespace xpressive { namespace grammar_detail
{
    using proto::_;
    using proto::or_;
    using proto::if_;
    using proto::call;
    using proto::when;
    using proto::otherwise;
    using proto::switch_;
    using proto::make;
    using proto::_child;
    using proto::_value;
    using proto::_left;
    using proto::_right;
    using proto::not_;
    using proto::_state;
    using proto::_data;
    using proto::callable;
    using proto::transform;
    using proto::fold;
    using proto::reverse_fold;
    using proto::fold_tree;
    using proto::reverse_fold_tree;
    using proto::terminal;
    using proto::shift_right;
    using proto::bitwise_or;
    using proto::logical_not;
    using proto::dereference;
    using proto::unary_plus;
    using proto::negate;
    using proto::complement;
    using proto::comma;
    using proto::assign;
    using proto::subscript;
    using proto::nary_expr;
    using proto::unary_expr;
    using proto::binary_expr;
    using proto::_deep_copy;
    using proto::vararg;
    namespace tag = proto::tag;
}}}

namespace boost { namespace xpressive { namespace op
{
    struct push;
    struct push_back;
    struct pop;
    struct push_front;
    struct pop_back;
    struct pop_front;
    struct back;
    struct front;
    struct top;
    struct first;
    struct second;
    struct matched;
    struct length;
    struct str;
    struct insert;
    struct make_pair;

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 T>
    struct throw_;
}}} // namespace boost::xpressive::op

/// INTERNAL ONLY
namespace boost { namespace xpressive
{

/// INTERNAL ONLY
    template<typename Traits, std::size_t N>
    typename Traits::char_class_type
    lookup_classname(Traits const &traits, char const (&cname)[N], bool icase = false);

}} // namespace boost::xpressive

#endif

cmd: