/////////////////////////////////////////////////////////////////////////////// | |
// width_of.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_WIDTH_OF_HPP_EAN_10_04_2005 | |
#define BOOST_XPRESSIVE_DETAIL_STATIC_WIDTH_OF_HPP_EAN_10_04_2005 | |
// MS compatible compilers support #pragma once | |
#if defined(_MSC_VER) && (_MSC_VER >= 1020) | |
# pragma once | |
#endif | |
#include <boost/ref.hpp> | |
#include <boost/mpl/if.hpp> | |
#include <boost/mpl/or.hpp> | |
#include <boost/mpl/plus.hpp> | |
#include <boost/mpl/times.hpp> | |
#include <boost/mpl/assert.hpp> | |
#include <boost/mpl/size_t.hpp> | |
#include <boost/mpl/equal_to.hpp> | |
#include <boost/type_traits/is_same.hpp> | |
#include <boost/xpressive/detail/detail_fwd.hpp> | |
#include <boost/proto/traits.hpp> | |
namespace boost { namespace xpressive { namespace detail | |
{ | |
template<typename Expr, typename Char, typename Tag = typename Expr::proto_tag> | |
struct width_of; | |
/////////////////////////////////////////////////////////////////////////////// | |
// add_widths | |
// | |
template<std::size_t N, std::size_t M> | |
struct add_widths | |
: mpl::size_t<N + M> | |
{}; | |
template<std::size_t M> | |
struct add_widths<unknown_width::value, M> | |
: unknown_width | |
{}; | |
template<std::size_t N> | |
struct add_widths<N, unknown_width::value> | |
: unknown_width | |
{}; | |
template<> | |
struct add_widths<unknown_width::value, unknown_width::value> | |
: unknown_width | |
{}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// or_widths | |
// | |
template<std::size_t N, std::size_t M> | |
struct or_widths | |
: unknown_width | |
{}; | |
template<std::size_t N> | |
struct or_widths<N, N> | |
: mpl::size_t<N> | |
{}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// is_char | |
// | |
template<typename T> | |
struct is_char | |
: mpl::false_ | |
{}; | |
template<> | |
struct is_char<char> | |
: mpl::true_ | |
{}; | |
template<> | |
struct is_char<wchar_t> | |
: mpl::true_ | |
{}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// width_of_terminal | |
// | |
template<typename Expr, typename Char, bool IsXpr = is_xpr<Expr>::value> | |
struct width_of_terminal | |
: mpl::size_t<Expr::width> // xpressive literals | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of_terminal<Expr, Char, false> | |
: unknown_width // unknown literals (eg, basic_string, basic_regex, etc.) | |
{}; | |
template<typename Char> | |
struct width_of_terminal<Char, Char, false> | |
: mpl::size_t<1> // char literals | |
{}; | |
template<typename Char> | |
struct width_of_terminal<char, Char, false> | |
: mpl::size_t<1> // char literals | |
{}; | |
template<> | |
struct width_of_terminal<char, char, false> | |
: mpl::size_t<1> // char literals | |
{}; | |
template<typename Elem, std::size_t N, typename Char> | |
struct width_of_terminal<Elem (&) [N], Char, false> | |
: mpl::size_t<N-is_char<Elem>::value> // string literals | |
{}; | |
template<typename Elem, std::size_t N, typename Char> | |
struct width_of_terminal<Elem const (&) [N], Char, false> | |
: mpl::size_t<N-is_char<Elem>::value> // string literals | |
{}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// width_of | |
// | |
template<typename Expr, typename Char, typename Tag> | |
struct width_of | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::terminal> | |
: width_of_terminal<typename proto::result_of::value<Expr>::type, Char> | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::shift_right> | |
: add_widths< | |
width_of<typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr, Char>::value | |
, width_of<typename remove_reference<typename Expr::proto_child1>::type::proto_base_expr, Char>::value | |
> | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::bitwise_or> | |
: or_widths< | |
width_of<typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr, Char>::value | |
, width_of<typename remove_reference<typename Expr::proto_child1>::type::proto_base_expr, Char>::value | |
> | |
{}; | |
template<typename Expr, typename Char, typename Left> | |
struct width_of_assign | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of_assign<Expr, Char, mark_placeholder> | |
: width_of<typename remove_reference<typename Expr::proto_child1>::type::proto_base_expr, Char> | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of_assign<Expr, Char, set_initializer> | |
: mpl::size_t<1> | |
{}; | |
template<typename Expr, typename Char, typename Nbr> | |
struct width_of_assign<Expr, Char, attribute_placeholder<Nbr> > | |
: unknown_width | |
{}; | |
// either (s1 = ...) or (a1 = ...) or (set = ...) | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::assign> | |
: width_of_assign< | |
Expr | |
, Char | |
, typename proto::result_of::value< | |
typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr | |
>::type | |
> | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, modifier_tag> | |
: width_of<typename remove_reference<typename Expr::proto_child1>::type::proto_base_expr, Char> | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, lookahead_tag> | |
: mpl::size_t<0> | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, lookbehind_tag> | |
: mpl::size_t<0> | |
{}; | |
// keep() is used to turn off backtracking, so they should only be used | |
// for things that are variable-width (eg. quantified) | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, keeper_tag> | |
: unknown_width | |
{ | |
// TODO: keep() now has a second meaning: execute actions immediately. | |
// In that sense, it is perfectly reasonable to put a fixed-width | |
// sub-expression in a keep. Can fixed-width keep() sub-expressions | |
// use the simple_repeat_matcher? | |
}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::unary_plus> | |
: unknown_width | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::dereference> | |
: unknown_width | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::logical_not> | |
: unknown_width | |
{}; | |
template<typename Expr, typename Char, uint_t Min, uint_t Max> | |
struct width_of<Expr, Char, generic_quant_tag<Min, Max> > | |
: unknown_width | |
{}; | |
template<typename Expr, typename Char, uint_t Count> | |
struct width_of<Expr, Char, generic_quant_tag<Count, Count> > | |
: mpl::if_c< | |
mpl::equal_to<unknown_width, width_of<typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr, Char> >::value | |
, unknown_width | |
, mpl::times< | |
width_of<typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr, Char> | |
, mpl::size_t<Count> | |
> | |
>::type | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::negate> | |
: width_of<typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr, Char> | |
{}; | |
// when complementing a set or an assertion, the width is that of the set (1) or the assertion (0) | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::complement> | |
: width_of<typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr, Char> | |
{}; | |
// The comma is used in list-initialized sets, and the width of sets are 1 | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::comma> | |
: mpl::size_t<1> | |
{}; | |
// The subscript operator[] is used for sets, as in set['a' | range('b','h')], | |
// or for actions as in (any >> expr)[ action ] | |
template<typename Expr, typename Char, typename Left> | |
struct width_of_subscript | |
: width_of<Left, Char> | |
{}; | |
template<typename Expr, typename Char> | |
struct width_of_subscript<Expr, Char, set_initializer_type> | |
: mpl::size_t<1> | |
{ | |
// If Left is "set" then make sure that Right has a width_of 1 | |
BOOST_MPL_ASSERT_RELATION( | |
1 | |
, == | |
, (width_of<typename remove_reference<typename Expr::proto_child1>::type::proto_base_expr, Char>::value)); | |
}; | |
template<typename Expr, typename Char> | |
struct width_of<Expr, Char, proto::tag::subscript> | |
: width_of_subscript<Expr, Char, typename remove_reference<typename Expr::proto_child0>::type::proto_base_expr> | |
{}; | |
}}} // namespace boost::xpressive::detail | |
#undef UNREF | |
#endif |