/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman
    Copyright (c) 2011 Thomas Bernard

    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(SPIRIT_KWD_NOVEMBER_14_2008_1148AM)
#define SPIRIT_KWD_NOVEMBER_14_2008_1148AM

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/spirit/home/qi/meta_compiler.hpp>
#include <boost/spirit/home/qi/parser.hpp>
#include <boost/spirit/home/qi/auxiliary/lazy.hpp>
#include <boost/spirit/home/qi/operator/kleene.hpp>
#include <boost/spirit/home/support/container.hpp>
#include <boost/spirit/home/qi/detail/attributes.hpp>
#include <boost/spirit/home/qi/detail/fail_function.hpp>
#include <boost/spirit/home/support/info.hpp>
#include <boost/spirit/repository/home/support/kwd.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/foreach.hpp>
#include <vector>

namespace boost { namespace spirit
{
    ///////////////////////////////////////////////////////////////////////////
    // Enablers
    ///////////////////////////////////////////////////////////////////////////
         
    template < typename T>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::kwd                     // enables kwd(key)[p]
        , fusion::vector1<T > >
    > : mpl::true_ {};
    
    template < typename T>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::ikwd                     // enables ikwd(key)[p]
        , fusion::vector1<T > >
    > : mpl::true_ {};
    
    template < typename T>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::dkwd                     // enables dkwd(key)[p]
        , fusion::vector1<T > >
    > : mpl::true_ {};
    
    template < typename T>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::idkwd                     // enables idkwd(key)[p]
        , fusion::vector1<T > >
    > : mpl::true_ {};


    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::kwd                     // enables kwd(key,exact)[p]
        , fusion::vector2< T1, T2 > >
    > : mpl::true_ {};

    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::ikwd                     // enables ikwd(key,exact)[p]
        , fusion::vector2< T1, T2 > >
    > : mpl::true_ {};

    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::dkwd                     // enables dkwd(key,exact)[p]
        , fusion::vector2< T1, T2 > >
    > : mpl::true_ {};

    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::idkwd                     // enables idkwd(key,exact)[p]
        , fusion::vector2< T1, T2 > >
    > : mpl::true_ {};

   template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::kwd                     // enables kwd(min, max)[p]
        , fusion::vector3< T1, T2, T2 > >
    > : mpl::true_ {};

    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::ikwd                     // enables ikwd(min, max)[p]
        , fusion::vector3< T1, T2, T2 > >
    > : mpl::true_ {};

    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::dkwd                     // enables dkwd(min, max)[p]
        , fusion::vector3< T1, T2, T2 > >
    > : mpl::true_ {};

    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::idkwd                     // enables idkwd(min, max)[p]
        , fusion::vector3< T1, T2, T2 > >
    > : mpl::true_ {};

   template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::kwd                     // enables kwd(min, inf)[p]
        , fusion::vector3<T1, T2, inf_type > >
    > : mpl::true_ {};
    
    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::ikwd                     // enables ikwd(min, inf)[p]
        , fusion::vector3<T1, T2, inf_type > >
    > : mpl::true_ {};

   template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::dkwd                     // enables dkwd(min, inf)[p]
        , fusion::vector3<T1, T2, inf_type > >
    > : mpl::true_ {};

    template < typename T1, typename T2>
    struct use_directive<qi::domain
      , terminal_ex<repository::tag::idkwd                     // enables idkwd(min, inf)[p]
        , fusion::vector3<T1, T2, inf_type > >
    > : mpl::true_ {};


  /*  template <>                                     // enables *lazy* kwd(exact)[p]
    struct use_lazy_directive<
        qi::domain
      , tag::kwd
      , 1 // arity
    > : mpl::true_ {};

    template <>                                     // enables *lazy* kwd(min, max)[p]
    struct use_lazy_directive<                      // and kwd(min, inf)[p]
        qi::domain
      , tag::kwd
      , 2 // arity
    > : mpl::true_ {};
*/

}}

namespace boost { namespace spirit { namespace repository { namespace qi
{
    using repository::kwd;
    using repository::ikwd;
    using repository::dkwd;
    using repository::idkwd;
    using spirit::inf;
    using spirit::inf_type;

template <typename T>
    struct kwd_pass_iterator // handles kwd(exact)[p]
    {
        kwd_pass_iterator() {}
        bool flag_init() const { return true; }
        bool register_successful_parse(bool &flag,T &i) const {
            flag=true;
            return true;
        }
        

    private:
        // silence MSVC warning C4512: assignment operator could not be generated
        kwd_pass_iterator& operator= (kwd_pass_iterator const&);
    };

    template <typename T>
    struct kwd_exact_iterator // handles kwd(exact)[p]
    {
        kwd_exact_iterator(T const exact)
          : exact(exact){}

        typedef T type;
        bool flag_init() const { return false; }
        bool register_successful_parse(bool &flag,T &i) const {
            i++;
            if(i<exact)
            {
                flag=false;
                return true;
            }
            else if(i==exact)
            {
                flag=true;
                return true;
            }
            else
                return flag=false;
            
        }
        T const exact;

    private:
        // silence MSVC warning C4512: assignment operator could not be generated
        kwd_exact_iterator& operator= (kwd_exact_iterator const&);
    };

    template <typename T>
    struct kwd_finite_iterator // handles kwd(min, max)[p]
    {
        kwd_finite_iterator(T const min, T const max)
          : min BOOST_PREVENT_MACRO_SUBSTITUTION (min)
          , max BOOST_PREVENT_MACRO_SUBSTITUTION (max)
            {}

        typedef T type;
        bool flag_init() const { return min==0; }
        bool register_successful_parse(bool &flag,T &i) const {
            i++;
            if(i<min)
            {
                flag=false;
                return true;
            }
            else if(i>=min && i<=max)
            {
                return flag=true;
            }
            else
                return flag=false;
        }
        T const min;
        T const max;

    private:
        // silence MSVC warning C4512: assignment operator could not be generated
        kwd_finite_iterator& operator= (kwd_finite_iterator const&);
    };

    template <typename T>
    struct kwd_infinite_iterator // handles kwd(min, inf)[p]
    {
        kwd_infinite_iterator(T const min)
          : min BOOST_PREVENT_MACRO_SUBSTITUTION (min) {}

        typedef T type;
        bool flag_init() const { return min==0; }
        bool register_successful_parse(bool &flag,T &i) const {
            i++;
            flag = i>=min;
            return true;
        }
        T const min;

    private:
        // silence MSVC warning C4512: assignment operator could not be generated
        kwd_infinite_iterator& operator= (kwd_infinite_iterator const&);
    };

    // This class enables the transportation of parameters needed to call 
    // the occurence constraint checker from higher level calls
    // It also serves to select the correct parse function call 
    // of the keyword parser. The implementation changes depending if it is
    // called form a keyword parsing loop or not.
    template <typename Skipper, typename NoCasePass>
    struct skipper_keyword_marker
    {
        typedef NoCasePass no_case_pass;
        
        skipper_keyword_marker(Skipper const &skipper,bool &flag,int &counter) : 
              skipper(skipper)
            , flag(flag)
            , counter(counter) 
            {}
            
        const Skipper &skipper;
        bool &flag;
        int &counter;
    };
    
    template <typename Subject, typename KeywordType, typename LoopIter , typename NoCase, typename Distinct >
    struct kwd_parser : spirit::qi::unary_parser<kwd_parser<Subject, KeywordType, LoopIter , NoCase, Distinct > >
    {
        struct kwd_parser_id;
        
        typedef Subject subject_type;
        typedef NoCase no_case_keyword;
        typedef Distinct distinct;
                
        typedef typename
            remove_const<typename traits::char_type_of<KeywordType>::type>::type
        char_type;
        
        typedef std::basic_string<char_type> keyword_type;
        
        template <typename Context, typename Iterator>
        struct attribute
        {
            typedef typename
            traits::build_std_vector<
                typename traits::attribute_of<
                Subject, Context, Iterator>::type
                        >::type
                type;
        };
        

        kwd_parser(Subject const& subject
           , typename add_reference<KeywordType>::type keyword
           , LoopIter const& iter)
          : subject(subject), iter(iter), keyword(keyword) {}    
        
        template<typename CharEncoding>
        kwd_parser(Subject const& subject
           , typename add_reference<KeywordType>::type keyword
           , LoopIter const& iter, CharEncoding encoding)
          : subject(subject), iter(iter), keyword(keyword,encoding) {}


        // Call the subject parser on a non container attribute
        template <typename Iterator, typename Context
          , typename Skipper, typename Attribute>
        bool parse_impl(Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper
          , Attribute& attr,mpl::false_) const
        {
            return subject.parse(first,last,context,skipper,attr);
        }
    
        // Call the subject parser on a container attribute
        template <typename Iterator, typename Context
          , typename Skipper, typename Attribute>
        bool parse_impl(Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper
          , Attribute& attr,mpl::true_) const
        {                   
            
            // synthesized attribute needs to be default constructed
            typename traits::container_value<Attribute>::type val =
                typename traits::container_value<Attribute>::type();

            Iterator save = first;
            bool r = subject.parse(first,last,context,skipper, val);
            if (r)
            {
                // push the parsed value into our attribute
                r = traits::push_back(attr, val);
                if (!r)
                    first = save;
            }
            return r;
        }
       
       template <typename Iterator, typename Context
          , typename Skipper, typename Attribute,typename NoCasePass>
        bool parse(Iterator& first, Iterator const& last
          , Context& context, skipper_keyword_marker<Skipper,NoCasePass> const& skipper
          , Attribute &attr) const
        {
            
            typedef typename traits::attribute_of<
                Subject, Context, Iterator>::type
                subject_attribute;
            
            typedef typename mpl::and_<
             traits::is_container<Attribute>
            , mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
            >::type predicate;
            
            if((no_case_keyword::value && NoCasePass::value) || !NoCasePass::value)
            {
                if(parse_impl(first,last,context,skipper.skipper,attr, predicate()))
                    return iter.register_successful_parse(skipper.flag,skipper.counter);
            }
            return false;
        }
       
        template <typename Iterator, typename Context
          , typename Skipper, typename Attribute>
        bool parse(Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper
          , Attribute& attr) const
          {
              typedef typename traits::attribute_of<
                Subject, Context, Iterator>::type
                subject_attribute;
            
            typedef typename mpl::and_<
            traits::is_container<Attribute>
            , mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
            >::type predicate;
            

            // Parse the keyword
            bool flag = iter.flag_init();
            int counter = 0;
            Iterator save = first;
            spirit::qi::skip_over(first, last, skipper);
            if(keyword.parse(first,last,context,skipper,unused)){
                if((!distinct::value) || skipper.parse(first,last,unused,unused,unused)){
                // Followed by the subject parser
                spirit::qi::skip_over(first, last, skipper);
                if(parse_impl(first,last,context,skipper,attr, predicate()))
                {
                    return iter.register_successful_parse(flag,counter);
                }
            }
            }
            first = save;            
            return flag;            
          }
       
    
        template <typename Context>
        info what(Context& context) const
        {
            if(distinct::value){
            if(no_case_keyword::value)
                return info("idkwd", subject.what(context));
              else
                return info("dkwd", subject.what(context));
            }
            else
            {
              if(no_case_keyword::value)
                return info("ikwd", subject.what(context));
            else
                return info("kwd", subject.what(context));
        }
        }

        Subject subject;
        LoopIter iter;            
        
        typedef typename mpl::if_<
                no_case_keyword,
                spirit::qi::no_case_literal_string< KeywordType, true>,
                spirit::qi::literal_string<KeywordType, true> >::type keyword_string_type;
       keyword_string_type keyword;
    private:
        // silence MSVC warning C4512: assignment operator could not be generated
        kwd_parser& operator= (kwd_parser const&);

        template <typename Iterator, typename Context, typename Skipper>
        static spirit::qi::detail::fail_function<Iterator, Context, Skipper>
        fail_function(
            Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper)
        {
            return spirit::qi::detail::fail_function<Iterator, Context, Skipper>
                (first, last, context, skipper);
        }


    };

template <typename Subject, typename KeywordType, typename LoopIter, typename Distinct>
    struct complex_kwd_parser : spirit::qi::unary_parser<complex_kwd_parser<Subject, KeywordType, LoopIter, Distinct > >
    {
        struct complex_kwd_parser_id;
        typedef Subject subject_type;
        typedef Distinct distinct;

        template <typename Context, typename Iterator>
        struct attribute
        {
            typedef typename
            traits::build_std_vector<
                typename traits::attribute_of<
                Subject, Context, Iterator>::type
                        >::type
                type;
        };


        complex_kwd_parser(Subject const& subject
           , typename add_reference<KeywordType>::type keyword
           , LoopIter const& iter)
          : subject(subject), iter(iter), keyword(keyword) {}

        // Call the subject parser on a non container attribute
        template <typename Iterator, typename Context
          , typename Skipper, typename Attribute>
        bool parse_impl(Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper
          , Attribute& attr,mpl::false_) const
        {
            return subject.parse(first,last,context,skipper,attr);
        }

        // Call the subject parser on a container attribute
        template <typename Iterator, typename Context
          , typename Skipper, typename Attribute>
        bool parse_impl(Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper
          , Attribute& attr,mpl::true_) const
        {

            // synthesized attribute needs to be default constructed
            typename traits::container_value<Attribute>::type val =
                typename traits::container_value<Attribute>::type();

            Iterator save = first;
            bool r = subject.parse(first,last,context,skipper, val);
            if (r)
            {
                // push the parsed value into our attribute
                r = traits::push_back(attr, val);
                if (!r)
                    first = save;
            }
            return r;
        }

       template <typename Iterator, typename Context
          , typename Skipper, typename Attribute,typename NoCasePass>
        bool parse(Iterator& first, Iterator const& last
          , Context& context, skipper_keyword_marker<Skipper,NoCasePass> const& skipper
          , Attribute &attr) const
        {

            typedef typename traits::attribute_of<
                Subject, Context, Iterator>::type
                subject_attribute;

            typedef typename mpl::and_<
             traits::is_container<Attribute>
            , mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
            >::type predicate;

            if(parse_impl(first,last,context,skipper.skipper,attr, predicate()))
                return iter.register_successful_parse(skipper.flag,skipper.counter);
            return false;
        }

        template <typename Iterator, typename Context
          , typename Skipper, typename Attribute>
        bool parse(Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper
          , Attribute& attr) const
          {
              typedef typename traits::attribute_of<
                Subject, Context, Iterator>::type
                subject_attribute;

            typedef typename mpl::and_<
            traits::is_container<Attribute>
            , mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
            >::type predicate;


            // Parse the keyword
            bool flag = iter.flag_init();
            int counter = 0;
            Iterator save = first;
            spirit::qi::skip_over(first, last, skipper);
            if(keyword.parse(first,last,context,skipper,unused)){
              if( !distinct::value || skipper.parse(first,last,unused,unused,unused)){
                // Followed by the subject parser
                spirit::qi::skip_over(first, last, skipper);
                if(parse_impl(first,last,context,skipper,attr, predicate()))
                {
                  return iter.register_successful_parse(flag,counter);
                }
              }
            }
            first = save;
            return flag;
          }


        template <typename Context>
        info what(Context& context) const
        {
           if(distinct::value)
            return info("dkwd", subject.what(context));
           else
            return info("kwd", subject.what(context));
        }

        Subject subject;
        LoopIter iter;

        KeywordType keyword;
    private:
        // silence MSVC warning C4512: assignment operator could not be generated
        complex_kwd_parser& operator= (complex_kwd_parser const&);

        template <typename Iterator, typename Context, typename Skipper>
        static spirit::qi::detail::fail_function<Iterator, Context, Skipper>
        fail_function(
            Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper)
        {
            return spirit::qi::detail::fail_function<Iterator, Context, Skipper>
                (first, last, context, skipper);
        }

    };

}}}}

///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit { namespace qi
{

    ///////////////////////////////////////////////////////////////////////////
    // Parser generators: make_xxx function (objects)
    ///////////////////////////////////////////////////////////////////////////
    
    template <typename T1, typename T2,  typename Subject, typename Modifiers, typename Distinct, typename MakeDirectiveHelper>
    struct make_directive_internal_2_args
    {

        // is the keyword a string keyword ?
        typedef typename traits::is_string<T1> is_string_kwd_type;
        // make the keyword type
        typedef typename mpl::if_< is_string_kwd_type ,
                                   T1 ,
                                   typename result_of::compile<qi::domain, T1>::type
                                 >::type keyword_type;

        typedef typename add_const<keyword_type>::type const_keyword;
        // select the pass iterator type
        typedef typename MakeDirectiveHelper::iterator_type iterator_type;
        // determine if a no case modifier applies to the context
        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
        // Determine the full type of the kwd / complex_kwd directive
        typedef typename
             mpl::if_<
                is_string_kwd_type,
                repository::qi::kwd_parser<Subject, const_keyword, iterator_type, no_case, Distinct >,
                repository::qi::complex_kwd_parser<Subject, const_keyword, iterator_type, Distinct >
                     >::type result_type;

        // Return a kwd parser object
        template <typename Terminal>
        result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::true_ ) const
        {
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;
           return result_type(subject
                        ,MakeDirectiveHelper::make_iterator(term.args)
                        ,encoding
                        );
        }
        template <typename Terminal>
        result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::false_ ) const
        {
           return result_type(subject
                        ,fusion::at_c<0>(term.args)
                        ,MakeDirectiveHelper::make_iterator(term.args)
                        );
        }
        template <typename Terminal>
        result_type create_kwd(Terminal const &term, Subject const & subject, Modifiers const& modifiers, boost::mpl::true_ ) const
        {
           return create_kwd_string(term,subject,no_case());
        }
        // Return a complex_kwd parser object
        template <typename Terminal>
        result_type create_kwd(Terminal const &term , Subject const & subject, Modifiers const& modifiers, boost::mpl::false_ ) const
        {
           return result_type(subject
                        ,compile<qi::domain>(fusion::at_c<0>(term.args),modifiers)
                        ,MakeDirectiveHelper::make_iterator(term.args)                        
                        );
        }
        // Select which object type to return
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {
            return create_kwd(term, subject, modifiers, is_string_kwd_type());
        }

    };

     // Directive kwd(key)[p]
    template <typename T1,  typename Subject, typename Modifiers, typename Distinct>
    struct make_directive_internal
    {
        // is the keyword a string keyword ?
        typedef typename traits::is_string<T1> is_string_kwd_type;
        // make the keyword type
        typedef typename mpl::if_< is_string_kwd_type ,
                                   T1 ,
                                   typename result_of::compile<qi::domain, T1, Modifiers>::type
                                 >::type keyword_type;

        typedef typename add_const<keyword_type>::type const_keyword;
        // select the pass iterator type
        typedef repository::qi::kwd_pass_iterator<int> iterator_type;
        // determine if a no case modifier applies to the context
        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
        // Determine the full type of the kwd / complex_kwd directive
        typedef typename
             mpl::if_<
                is_string_kwd_type,
                repository::qi::kwd_parser<Subject, const_keyword, iterator_type, no_case, Distinct >,
                repository::qi::complex_kwd_parser<Subject, const_keyword, iterator_type, Distinct>
                     >::type result_type;

        // Return a kwd parser object
        template <typename Terminal>
        result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::true_) const
        {
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;

            return result_type(subject
                        ,fusion::at_c<0>(term.args)
                        ,iterator_type()
                        ,encoding
                        );

        }
        template <typename Terminal>
        result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::false_) const
        {
            return result_type(subject
                        ,fusion::at_c<0>(term.args)
                        ,iterator_type()
                        );
        }
        template <typename Terminal>
        result_type create_kwd(Terminal const &term, Subject const & subject, Modifiers const& modifiers, boost::mpl::true_ ) const
        {
           return create_kwd_string(term,subject,no_case());
        }
        // Return a complex_kwd parser object
        template <typename Terminal>
        result_type create_kwd(Terminal const &term , Subject const & subject, Modifiers const& modifiers, boost::mpl::false_ ) const
        {
           return result_type(subject
                        ,compile<qi::domain>(fusion::at_c<0>(term.args),modifiers)
                        ,iterator_type()
                        );
        }
        // Select which object type to return
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers ) const
        {
            return create_kwd(term, subject, modifiers, is_string_kwd_type());
        }
    };

    template <typename T1,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::kwd, fusion::vector1<T1> >, Subject, Modifiers>
    {
        typedef make_directive_internal<T1, Subject, Modifiers, mpl::false_> make_directive_type;
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {

            return make_directive_type()(term, subject, modifiers);
        }

    };
 
   template <typename T1,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::dkwd, fusion::vector1<T1> >, Subject, Modifiers>
    {
        typedef make_directive_internal<T1, Subject, Modifiers, mpl::true_> make_directive_type;
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {

            return make_directive_type()(term, subject, modifiers);
        }

    };
 


    // Directive ikwd(key)[p]
    template <typename T1,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::ikwd, fusion::vector1<T1> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_pass_iterator<int> iterator_type;
        
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;
                
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;

            return result_type(subject
                        ,fusion::at_c<0>(term.args)
                        ,iterator_type()
                        ,encoding
                        );
        }
    };
    
    template <typename T1,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::idkwd, fusion::vector1<T1> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_pass_iterator<int> iterator_type;
        
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;

        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;
                
            return result_type(subject
                        ,fusion::at_c<0>(term.args)
                        ,iterator_type()                        
                        ,encoding
                        );
        }
    };
    
    // Directive kwd(key,exact)[p]
        template <typename T>
    struct make_exact_helper
    { 
        typedef repository::qi::kwd_exact_iterator<T> iterator_type;
        template<typename Args>
        static iterator_type make_iterator(Args const& args)
        {
          return iterator_type(fusion::at_c<1>(args));
        }
    };

    template <typename T1, typename T2,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::kwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
    {
        typedef make_directive_internal_2_args< T1
                                              , T2
                                              , Subject
                                              , Modifiers
                                              , mpl::false_
                                              , make_exact_helper<T2>
                                              > make_directive_type;
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {

            return make_directive_type()(term,subject, modifiers);
        }

    };
  
    template <typename T1, typename T2,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::dkwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
    {
         typedef make_directive_internal_2_args< T1
                                              , T2
                                              , Subject
                                              , Modifiers
                                              , mpl::true_
                                              , make_exact_helper<T2>
                                              > make_directive_type;
        
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {

            return make_directive_type()(term, subject, modifiers);
        }

    };
  

    // Directive ikwd(key,exact)[p]
    template <typename T1, typename T2,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::ikwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_exact_iterator<T2> iterator_type;
        
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;

        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;
            return result_type(subject
                        ,fusion::at_c<0>(term.args)
                        ,fusion::at_c<1>(term.args)
                        , encoding
                        );
        }
    };

    template <typename T1, typename T2,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::idkwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_exact_iterator<T2> iterator_type;
        
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;
        
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {            
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;
            return result_type(subject
                        , fusion::at_c<0>(term.args)
                        , fusion::at_c<1>(term.args)
                        , encoding
                        );
        }
    };
    

    // Directive kwd(min, max)[p]

    template <typename T>
    struct make_finite_helper
    { 
        typedef repository::qi::kwd_finite_iterator<T> iterator_type;
        template<typename Args>
        static iterator_type make_iterator(Args const& args)
        {
          return iterator_type(fusion::at_c<1>(args),fusion::at_c<2>(args));
        }

    };

    template <typename T1, typename T2, typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::kwd, fusion::vector3< T1, T2, T2> >, Subject, Modifiers>
    {
        typedef make_directive_internal_2_args< T1
                                              , T2
                                              , Subject
                                              , Modifiers
                                              , mpl::false_
                                              , make_finite_helper<T2>
                                              > make_directive_type;
        
        
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {

            return make_directive_type()(term,subject, modifiers);
        }

    };
  
    template <typename T1, typename T2,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::dkwd, fusion::vector3<T1,T2,T2> >, Subject, Modifiers>
    {
       
        typedef make_directive_internal_2_args< T1
                                              , T2
                                              , Subject
                                              , Modifiers
                                              , mpl::true_
                                              , make_finite_helper<T2>
                                              > make_directive_type;
 
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
        {

            return make_directive_type()(term,subject, modifiers);
        }

    };

    // Directive ikwd(min, max)[p]
    template <typename T1, typename T2, typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::ikwd, fusion::vector3< T1, T2, T2> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_finite_iterator<T2> iterator_type;
                    
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;

        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {

            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;
            return result_type(subject, fusion::at_c<0>(term.args),
                iterator_type(
                    fusion::at_c<1>(term.args)
                  , fusion::at_c<2>(term.args)
                  , encoding
                )
            );
        }
    };

    template <typename T1, typename T2, typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::idkwd, fusion::vector3< T1, T2, T2> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_finite_iterator<T2> iterator_type;
                
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;

        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {
        
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;
            return result_type(subject, fusion::at_c<0>(term.args),
                iterator_type(
                    fusion::at_c<1>(term.args)
                  , fusion::at_c<2>(term.args)
                  , encoding
                )
            );
        }
    };
    

    // Directive kwd(min, inf)[p]

    template <typename T>
    struct make_infinite_helper
    { 
        typedef repository::qi::kwd_infinite_iterator<T> iterator_type;
        template<typename Args>
        static iterator_type make_iterator(Args const& args)
        {
          return iterator_type(fusion::at_c<1>(args));
        }

    };


    template <typename T1, typename T2, typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::kwd, fusion::vector3<T1,T2,inf_type> >, Subject, Modifiers>
    {
         typedef make_directive_internal_2_args< T1
                                              , T2
                                              , Subject
                                              , Modifiers
                                              , mpl::false_
                                              , make_infinite_helper<T2>
                                              > make_directive_type;
        
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {

            return make_directive_type()(term,subject, unused_type());
        }

    };
  
    template <typename T1, typename T2,  typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::dkwd, fusion::vector3<T1,T2,inf_type> >, Subject, Modifiers>
    {
      typedef make_directive_internal_2_args< T1
                                              , T2
                                              , Subject
                                              , Modifiers
                                              , mpl::false_
                                              , make_infinite_helper<T2>
                                              > make_directive_type;
    
        typedef typename make_directive_type::result_type result_type;
        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {

            return make_directive_type()(term,subject, unused_type());
        }

    };


    // Directive ikwd(min, inf)[p]
    template <typename T1, typename T2, typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::ikwd
        , fusion::vector3<T1, T2, inf_type> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_infinite_iterator<T2> iterator_type;
        
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;

        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;

            return result_type(subject
                , fusion::at_c<0>(term.args)
                , fusion::at_c<1>(term.args)
                , encoding
                );
        }
    };
    
    template <typename T1, typename T2, typename Subject, typename Modifiers>
    struct make_directive<
        terminal_ex<repository::tag::idkwd
        , fusion::vector3<T1, T2, inf_type> >, Subject, Modifiers>
    {
        typedef typename add_const<T1>::type const_keyword;
        typedef repository::qi::kwd_infinite_iterator<T2> iterator_type;
        
        typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;

        template <typename Terminal>
        result_type operator()(
            Terminal const& term, Subject const& subject, unused_type) const
        {
            typename spirit::detail::get_encoding<Modifiers,
                spirit::char_encoding::standard>::type encoding;
                
            return result_type(subject
                , fusion::at_c<0>(term.args)
                , fusion::at_c<1>(term.args)
                , encoding
                );
        }
    };
    
    
}}}

namespace boost { namespace spirit { namespace traits
{
    template <typename Subject, typename KeywordType
            , typename LoopIter, typename NoCase , typename Distinct>
    struct has_semantic_action< 
            repository::qi::kwd_parser< Subject, KeywordType, LoopIter, NoCase, Distinct > >
      : unary_has_semantic_action<Subject> {};

    template <typename Subject, typename KeywordType
            , typename LoopIter, typename Distinct >
    struct has_semantic_action<
            repository::qi::complex_kwd_parser< Subject, KeywordType, LoopIter, Distinct > >
      : unary_has_semantic_action<Subject> {};

    template <typename Subject, typename KeywordType
              , typename LoopIter, typename NoCase, typename Attribute, typename Context
                , typename Iterator, typename Distinct>
    struct handles_container<repository::qi::kwd_parser<Subject, KeywordType, LoopIter, NoCase, Distinct>, Attribute
        , Context, Iterator>
      : unary_handles_container<Subject, Attribute, Context, Iterator> {};

    template <typename Subject, typename KeywordType
                , typename LoopIter
                , typename Attribute, typename Context
                , typename Iterator, typename Distinct>
    struct handles_container<repository::qi::complex_kwd_parser<Subject, KeywordType, LoopIter, Distinct>, Attribute
        , Context, Iterator>
      : unary_handles_container<Subject, Attribute, Context, Iterator> {};

}}}

#endif