/*=============================================================================
    Copyright (c) 2001-2007 Joel de Guzman

    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)
==============================================================================*/
#if !defined(BOOST_SPIRIT_META_GRAMMAR_FEB_02_2007_0925AM)
#define BOOST_SPIRIT_META_GRAMMAR_FEB_02_2007_0925AM

#include <boost/spirit/home/qi/domain.hpp>
#include <boost/spirit/home/support/placeholders.hpp>
#include <boost/spirit/home/support/meta_grammar.hpp>
#include <boost/spirit/home/support/char_class.hpp>
#include <boost/spirit/home/qi/char/detail/basic_chset.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/shared_ptr.hpp>

namespace boost { namespace spirit { namespace qi
{
    ///////////////////////////////////////////////////////////////////////////
    // forwards
    ///////////////////////////////////////////////////////////////////////////
    template <typename Char>
    struct any_char;

    template <typename Char>
    struct literal_char;

    struct lazy_char;

    template <typename Char>
    struct char_range;

    struct lazy_char_range;

    template <typename Positive>
    struct negated_char_parser;

    template <typename Tag>
    struct char_class;

    struct char_meta_grammar;

    ///////////////////////////////////////////////////////////////////////////
    template <typename Expr, typename Enable>
    struct is_valid_expr;

    template <typename Expr, typename Enable>
    struct expr_transform;

    ///////////////////////////////////////////////////////////////////////////
    //  get the director of an any_char
    ///////////////////////////////////////////////////////////////////////////
    template <typename Tag>
    struct extract_any_char_director;

    template <>
    struct extract_any_char_director<tag::char_>
    {
        typedef any_char<char> type;
    };

    template <>
    struct extract_any_char_director<tag::wchar>
    {
        typedef any_char<wchar_t> type;
    };

    ///////////////////////////////////////////////////////////////////////////
    // get the director of a character literal type
    ///////////////////////////////////////////////////////////////////////////
    template <typename Tag, typename T>
    struct extract_literal_char_director;

    template <typename T>
    struct extract_literal_char_director<tag::char_, T>
    {
        typedef literal_char<T> type;
    };

    template <typename T>
    struct extract_literal_char_director<tag::wchar, T>
    {
        typedef literal_char<wchar_t> type;
    };

    template <typename T>
    struct extract_literal_char_director<tag::lit, T>
    {
        typedef literal_char<T> type;
    };

    template <typename T>
    struct extract_literal_char_director<tag::wlit, T>
    {
        typedef literal_char<wchar_t> type;
    };

    ///////////////////////////////////////////////////////////////////////////
    // get the director of a character range type
    ///////////////////////////////////////////////////////////////////////////
    template <typename Tag, typename T>
    struct extract_char_range_director;

    template <typename T>
    struct extract_char_range_director<tag::char_, T>
    {
        typedef char_range<T> type;
    };

    template <typename T>
    struct extract_char_range_director<tag::wchar, T>
    {
        typedef char_range<wchar_t> type;
    };

    ///////////////////////////////////////////////////////////////////////////
    // char parser meta-grammars
    ///////////////////////////////////////////////////////////////////////////

    // literals: 'x', L'x'
    struct basic_char_literal_meta_grammar
      : proto::or_<
            proto::terminal<char>
          , proto::terminal<wchar_t>
        >
    {
    };


    // literals: 'x', L'x' and single char strings: "x", L"x"
    struct single_char_literal_meta_grammar
      : proto::or_<
        // plain chars:
            proto::terminal<char>
          , proto::terminal<wchar_t>
        // single char null terminates strings:
          , proto::terminal<char[2]>
          , proto::terminal<char(&)[2]>
          , proto::terminal<wchar_t[2]>
          , proto::terminal<wchar_t(&)[2]>
        >
    {
    };

    // literals: 'x', L'x'
    struct char_literal_meta_grammar
      : proto::or_<
            meta_grammar::terminal_rule<
                qi::domain, char, literal_char<char>
            >
          , meta_grammar::terminal_rule<
                qi::domain, wchar_t, literal_char<wchar_t>
            >
        >
    {
    };

    // literal strings: "hello" (defined in qi/string/meta_grammar.hpp)
    struct basic_string_literal_meta_grammar;

    // std::string(s) (defined in qi/string/meta_grammar.hpp)
    struct basic_std_string_meta_grammar;

    template <typename T>
    struct extract_char; // (defined in qi/string/metagrammar.hpp)

    template <typename Tag, typename T>
    struct extract_chset_director;

    template <typename T>
    struct extract_chset_director<tag::char_, T>
    {
        typedef typename extract_char<T>::type char_type;
        typedef char_set<char_type> type;
    };

    template <typename T>
    struct extract_chset_director<tag::wchar, T>
    {
        typedef typename extract_char<T>::type char_type;
        typedef char_set<char_type> type;
    };

    template <typename Char, typename Elements>
    struct char_set_component
    {
        typedef qi::domain domain;
        typedef char_set<Char> director;
        typedef Elements elements_type;

        char_set_component(Char const* definition)
          : ptr(new detail::basic_chset<Char>())
        {
            Char ch = *definition++;
            while (ch)
            {
                Char next = *definition++;
                if (next == '-')
                {
                    next = *definition++;
                    if (next == 0)
                    {
                        ptr->set(ch);
                        ptr->set('-');
                        break;
                    }
                    ptr->set(ch, next);
                }
                else
                {
                    ptr->set(ch);
                }
                ch = next;
            }
        }

        template <typename CharSetClass> // no-case version
        char_set_component(Char const* definition, CharSetClass)
          : ptr(new detail::basic_chset<Char>())
        {
            Char ch = *definition++;
            while (ch)
            {
                Char next = *definition++;
                if (next == '-')
                {
                    next = *definition++;
                    if (next == 0)
                    {
                        ptr->set(CharSetClass::tolower(ch));
                        ptr->set(CharSetClass::tolower('-'));
                        ptr->set(CharSetClass::toupper(ch));
                        ptr->set(CharSetClass::toupper('-'));
                        break;
                    }
                    ptr->set(CharSetClass::tolower(ch)
                      , CharSetClass::tolower(next));
                    ptr->set(CharSetClass::toupper(ch)
                      , CharSetClass::toupper(next));
                }
                else
                {
                    ptr->set(CharSetClass::tolower(ch));
                    ptr->set(CharSetClass::toupper(ch));
                }
                ch = next;
            }
        }

        boost::shared_ptr<detail::basic_chset<Char> > ptr;
    };

    // char_, char_('x'), char_("x"), char_(f), char_('x', 'z'),
    // char_(L'x'), char_(L'x', L'z'),
    // wchar, wchar('x'), wchar("x"), wchar('x', 'z'),
    // wchar(L'x'), wchar(L'x', L'z')
    // char_("a-z"), wchar("a-z")
    // [w]lit('x'), [w]lit(L'x')
    struct char_meta_grammar1
      : proto::or_<
            // char_, wchar --> any_char
            meta_grammar::compose_empty<
                proto::if_<
                    is_char_tag<proto::_child, qi::domain>()
                >
              , qi::domain
              , mpl::identity<extract_any_char_director<mpl::_> >
            >
            // char_('x'), wchar(L'x'), char_("x"), wchar(L"x")--> literal_char
          , meta_grammar::compose_function1_eval<
                proto::function<
                    proto::if_<
                        is_char_tag<proto::_child, qi::domain>()
                    >
                  , single_char_literal_meta_grammar
                >
              , qi::domain
              , mpl::identity<extract_literal_char_director<mpl::_, mpl::_> >
            >
            // lit("x"), wlit(L"x") --> literal_char
          , meta_grammar::compose_function1_eval<
                proto::function<
                    proto::if_<
                        is_lit_tag<proto::_child, qi::domain>()
                    >
                  , basic_char_literal_meta_grammar
                >
              , qi::domain
              , mpl::identity<extract_literal_char_director<mpl::_, mpl::_> >
            >
            // char_("a-z"), char_(L"a-z"), wchar(L"a-z") --> char_set
          , meta_grammar::compose_function1_eval<
                proto::function<
                    proto::if_<
                        is_char_tag<proto::_child, qi::domain>()>
                  , proto::or_<basic_string_literal_meta_grammar, basic_std_string_meta_grammar>
                >
              , qi::domain
              , mpl::identity<extract_chset_director<mpl::_, mpl::_> >
            >
            // char_(F()) --> lazy_char
          , meta_grammar::function1_rule<
                qi::domain
              , tag::char_
              , lazy_char
            >
            // char_('x', 'z'), wchar(L'x', L'z') --> char_range
          , meta_grammar::compose_function2_eval<
                proto::function<
                    proto::if_<
                        is_char_tag<proto::_child, qi::domain>()
                    >
                  , basic_char_literal_meta_grammar
                  , basic_char_literal_meta_grammar
                >
              , qi::domain
              , mpl::identity<extract_char_range_director<mpl::_, mpl::_> >
            >
            // char_(F1(), F2()) --> lazy_char_range
          , meta_grammar::function2_rule<
                qi::domain
              , tag::char_
              , lazy_char_range
            >
        >
    {
    };

    // char_classes: alnum, alpha, cntrl, ... etc.
    struct char_class_meta_grammar
      : proto::or_<
            // alnum, alpha, cntrl, ... etc.
            meta_grammar::compose_empty<
                proto::terminal<spirit::char_class::key<proto::_, proto::_> >
              , qi::domain
              , char_class<mpl::_>
            >
          , meta_grammar::compose_empty<
                proto::terminal<spirit::char_class::lower_case_tag<proto::_> >
              , qi::domain
              , char_class<mpl::_>
            >
          , meta_grammar::compose_empty<
                proto::terminal<spirit::char_class::upper_case_tag<proto::_> >
              , qi::domain
              , char_class<mpl::_>
            >
        >
    {};

    // ~x (where x is a char_parser)
    struct negated_char_meta_grammar
      : meta_grammar::compose_single<
            proto::unary_expr<
                proto::tag::complement
              , char_meta_grammar
            >
          , qi::domain
          , negated_char_parser<mpl::_>
        >
    {
    };

    // main char_meta_grammar
    struct char_meta_grammar
      : proto::or_<
            char_meta_grammar1
          , char_class_meta_grammar
          , char_literal_meta_grammar
          , negated_char_meta_grammar
        >
    {
    };

    ///////////////////////////////////////////////////////////////////////////
    //  These specializations non-intrusively hooks into the RD meta-grammar.
    //  (see qi/meta_grammar.hpp)
    ///////////////////////////////////////////////////////////////////////////
    template <typename Expr>
    struct is_valid_expr<Expr
      , typename enable_if<proto::matches<Expr, char_meta_grammar> >::type>
      : mpl::true_
    {
    };

    template <typename Expr>
    struct expr_transform<Expr
      , typename enable_if<proto::matches<Expr, char_meta_grammar> >::type>
      : mpl::identity<char_meta_grammar>
    {
    };
}}}

#endif
