/////////////////////////////////////////////////////////////////////////////// | |
// 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) && (_MSC_VER >= 1020) | |
# 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; | |
template<typename BidiIter> | |
struct replacement_context; | |
/////////////////////////////////////////////////////////////////////////////// | |
// 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 |