Chris@16: //  Copyright (c) 2001-2011 Hartmut Kaiser
Chris@16: //  Copyright (c)      2010 Bryce Lelbach
Chris@16: //
Chris@16: //  Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16: //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #if !defined(BOOST_SPIRIT_KARMA_CHAR_FEB_21_2007_0543PM)
Chris@16: #define BOOST_SPIRIT_KARMA_CHAR_FEB_21_2007_0543PM
Chris@16: 
Chris@16: #if defined(_MSC_VER)
Chris@16: #pragma once
Chris@16: #endif
Chris@16: 
Chris@16: #include <boost/spirit/home/support/common_terminals.hpp>
Chris@16: #include <boost/spirit/home/support/string_traits.hpp>
Chris@16: #include <boost/spirit/home/support/info.hpp>
Chris@16: #include <boost/spirit/home/support/char_class.hpp>
Chris@16: #include <boost/spirit/home/support/detail/get_encoding.hpp>
Chris@16: #include <boost/spirit/home/support/char_set/basic_chset.hpp>
Chris@16: #include <boost/spirit/home/karma/domain.hpp>
Chris@16: #include <boost/spirit/home/karma/meta_compiler.hpp>
Chris@16: #include <boost/spirit/home/karma/delimit_out.hpp>
Chris@16: #include <boost/spirit/home/karma/char/char_generator.hpp>
Chris@16: #include <boost/spirit/home/karma/auxiliary/lazy.hpp>
Chris@16: #include <boost/spirit/home/karma/detail/get_casetag.hpp>
Chris@16: #include <boost/spirit/home/karma/detail/generate_to.hpp>
Chris@16: #include <boost/spirit/home/karma/detail/enable_lit.hpp>
Chris@16: #include <boost/fusion/include/at.hpp>
Chris@16: #include <boost/fusion/include/vector.hpp>
Chris@16: #include <boost/fusion/include/cons.hpp>
Chris@16: #include <boost/mpl/if.hpp>
Chris@16: #include <boost/mpl/assert.hpp>
Chris@16: #include <boost/mpl/bool.hpp>
Chris@16: #include <boost/utility/enable_if.hpp>
Chris@16: #include <string>
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: namespace boost { namespace spirit
Chris@16: {
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     // Enablers
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     template <typename CharEncoding>
Chris@16:     struct use_terminal<karma::domain
Chris@16:       , tag::char_code<tag::char_, CharEncoding>        // enables char_
Chris@16:     > : mpl::true_ {};
Chris@16: 
Chris@16:     template <typename CharEncoding, typename A0>
Chris@16:     struct use_terminal<karma::domain
Chris@16:       , terminal_ex<
Chris@16:             tag::char_code<tag::char_, CharEncoding>    // enables char_('x'), char_("x")
Chris@16:           , fusion::vector1<A0>
Chris@16:         >
Chris@16:     > : mpl::true_ {};
Chris@16: 
Chris@16:     template <typename A0>
Chris@16:     struct use_terminal<karma::domain
Chris@16:           , terminal_ex<tag::lit, fusion::vector1<A0> > // enables lit('x')
Chris@16:           , typename enable_if<traits::is_char<A0> >::type>
Chris@16:       : mpl::true_ {};
Chris@16: 
Chris@16:     template <typename CharEncoding, typename A0, typename A1>
Chris@16:     struct use_terminal<karma::domain
Chris@16:       , terminal_ex<
Chris@16:             tag::char_code<tag::char_, CharEncoding>    // enables char_('a','z')
Chris@16:           , fusion::vector2<A0, A1>
Chris@16:         >
Chris@16:     > : mpl::true_ {};
Chris@16: 
Chris@16:     template <typename CharEncoding>                    // enables *lazy* char_('x'), char_("x")
Chris@16:     struct use_lazy_terminal<
Chris@16:         karma::domain
Chris@16:       , tag::char_code<tag::char_, CharEncoding>
Chris@16:       , 1 // arity
Chris@16:     > : mpl::true_ {};
Chris@16: 
Chris@16:     template <>
Chris@16:     struct use_terminal<karma::domain, char>            // enables 'x'
Chris@16:       : mpl::true_ {};
Chris@16: 
Chris@16:     template <>
Chris@16:     struct use_terminal<karma::domain, char[2]>         // enables "x"
Chris@16:       : mpl::true_ {};
Chris@16: 
Chris@16:     template <>
Chris@16:     struct use_terminal<karma::domain, wchar_t>         // enables L'x'
Chris@16:       : mpl::true_ {};
Chris@16: 
Chris@16:     template <>
Chris@16:     struct use_terminal<karma::domain, wchar_t[2]>      // enables L"x"
Chris@16:       : mpl::true_ {};
Chris@16: }}
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: namespace boost { namespace spirit { namespace karma
Chris@16: {
Chris@16: #ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
Chris@16:     using spirit::lit;    // lit('x') is equivalent to 'x'
Chris@16: #endif
Chris@16:     using spirit::lit_type;
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     //
Chris@16:     //  any_char
Chris@16:     //      generates a single character from the associated attribute
Chris@16:     //
Chris@16:     //      Note: this generator has to have an associated attribute
Chris@16:     //
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     template <typename CharEncoding, typename Tag>
Chris@16:     struct any_char
Chris@16:       : char_generator<any_char<CharEncoding, Tag>, CharEncoding, Tag>
Chris@16:     {
Chris@16:         typedef typename CharEncoding::char_type char_type;
Chris@16:         typedef CharEncoding char_encoding;
Chris@16: 
Chris@16:         template <typename Context, typename Unused>
Chris@16:         struct attribute
Chris@16:         {
Chris@16:             typedef char_type type;
Chris@16:         };
Chris@16: 
Chris@16:         // any_char has an attached parameter
Chris@16:         template <typename Attribute, typename CharParam, typename Context>
Chris@16:         bool test(Attribute const& attr, CharParam& ch, Context&) const
Chris@16:         {
Chris@16:             ch = CharParam(attr);
Chris@16:             return true;
Chris@16:         }
Chris@16: 
Chris@16:         // any_char has no attribute attached, it needs to have been
Chris@16:         // initialized from a direct literal
Chris@16:         template <typename CharParam, typename Context>
Chris@16:         bool test(unused_type, CharParam&, Context&) const
Chris@16:         {
Chris@16:             // It is not possible (doesn't make sense) to use char_ without
Chris@16:             // providing any attribute, as the generator doesn't 'know' what
Chris@16:             // character to output. The following assertion fires if this
Chris@16:             // situation is detected in your code.
Chris@16:             BOOST_SPIRIT_ASSERT_FAIL(CharParam, char_not_usable_without_attribute, ());
Chris@16:             return false;
Chris@16:         }
Chris@16: 
Chris@16:         template <typename Context>
Chris@16:         static info what(Context const& /*context*/)
Chris@16:         {
Chris@16:             return info("any-char");
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     //
Chris@16:     //  literal_char
Chris@16:     //      generates a single character given by a literal it was initialized
Chris@16:     //      from
Chris@16:     //
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     template <typename CharEncoding, typename Tag, bool no_attribute>
Chris@16:     struct literal_char
Chris@16:       : char_generator<literal_char<CharEncoding, Tag, no_attribute>
Chris@16:           , CharEncoding, Tag>
Chris@16:     {
Chris@16:         typedef typename CharEncoding::char_type char_type;
Chris@16:         typedef CharEncoding char_encoding;
Chris@16: 
Chris@16:         literal_char(char_type ch)
Chris@16:           : ch (spirit::char_class::convert<char_encoding>::to(Tag(), ch)) 
Chris@16:         {}
Chris@16: 
Chris@16:         template <typename Context, typename Unused>
Chris@16:         struct attribute
Chris@16:           : mpl::if_c<no_attribute, unused_type, char_type>
Chris@16:         {};
Chris@16: 
Chris@16:         // A char_('x') which additionally has an associated attribute emits
Chris@16:         // its immediate literal only if it matches the attribute, otherwise
Chris@16:         // it fails.
Chris@16:         // any_char has an attached parameter
Chris@16:         template <typename Attribute, typename CharParam, typename Context>
Chris@16:         bool test(Attribute const& attr, CharParam& ch_, Context&) const
Chris@16:         {
Chris@16:             // fail if attribute isn't matched my immediate literal
Chris@16:             ch_ = attr;
Chris@16:             return attr == ch;
Chris@16:         }
Chris@16: 
Chris@16:         // A char_('x') without any associated attribute just emits its 
Chris@16:         // immediate literal
Chris@16:         template <typename CharParam, typename Context>
Chris@16:         bool test(unused_type, CharParam& ch_, Context&) const
Chris@16:         {
Chris@16:             ch_ = ch;
Chris@16:             return true;
Chris@16:         }
Chris@16: 
Chris@16:         template <typename Context>
Chris@16:         info what(Context const& /*context*/) const
Chris@16:         {
Chris@16:             return info("literal-char", char_encoding::toucs4(ch));
Chris@16:         }
Chris@16: 
Chris@16:         char_type ch;
Chris@16:     };
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     // char range generator
Chris@16:     template <typename CharEncoding, typename Tag>
Chris@16:     struct char_range
Chris@16:       : char_generator<char_range<CharEncoding, Tag>, CharEncoding, Tag>
Chris@16:     {
Chris@16:         typedef typename CharEncoding::char_type char_type;
Chris@16:         typedef CharEncoding char_encoding;
Chris@16: 
Chris@16:         char_range(char_type from, char_type to)
Chris@16:           : from(spirit::char_class::convert<char_encoding>::to(Tag(), from))
Chris@16:           , to(spirit::char_class::convert<char_encoding>::to(Tag(), to)) 
Chris@16:         {}
Chris@16: 
Chris@16:         // A char_('a', 'z') which has an associated attribute emits it only if 
Chris@16:         // it matches the character range, otherwise it fails.
Chris@16:         template <typename Attribute, typename CharParam, typename Context>
Chris@16:         bool test(Attribute const& attr, CharParam& ch, Context&) const
Chris@16:         {
Chris@16:             // fail if attribute doesn't belong to character range
Chris@16:             ch = attr;
Chris@16:             return (from <= char_type(attr)) && (char_type(attr) <= to);
Chris@16:         }
Chris@16: 
Chris@16:         // A char_('a', 'z') without any associated attribute fails compiling
Chris@16:         template <typename CharParam, typename Context>
Chris@16:         bool test(unused_type, CharParam&, Context&) const
Chris@16:         {
Chris@16:             // It is not possible (doesn't make sense) to use char_ generators
Chris@16:             // without providing any attribute, as the generator doesn't 'know'
Chris@16:             // what to output. The following assertion fires if this situation
Chris@16:             // is detected in your code.
Chris@16:             BOOST_SPIRIT_ASSERT_FAIL(CharParam
Chris@16:               , char_range_not_usable_without_attribute, ());
Chris@16:             return false;
Chris@16:         }
Chris@16: 
Chris@16:         template <typename Context>
Chris@16:         info what(Context& /*context*/) const
Chris@16:         {
Chris@16:             info result("char-range", char_encoding::toucs4(from));
Chris@16:             boost::get<std::string>(result.value) += '-';
Chris@16:             boost::get<std::string>(result.value) += to_utf8(char_encoding::toucs4(to));
Chris@16:             return result;
Chris@16:         }
Chris@16: 
Chris@16:         char_type from, to;
Chris@16:     };
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     // character set generator
Chris@16:     template <typename CharEncoding, typename Tag, bool no_attribute>
Chris@16:     struct char_set
Chris@16:       : char_generator<char_set<CharEncoding, Tag, no_attribute>
Chris@16:           , CharEncoding, Tag>
Chris@16:     {
Chris@16:         typedef typename CharEncoding::char_type char_type;
Chris@16:         typedef CharEncoding char_encoding;
Chris@16: 
Chris@16:         template <typename Context, typename Unused>
Chris@16:         struct attribute
Chris@16:           : mpl::if_c<no_attribute, unused_type, char_type>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename String>
Chris@16:         char_set(String const& str)
Chris@16:         {
Chris@16:             typedef typename traits::char_type_of<String>::type in_type;
Chris@16: 
Chris@16:             BOOST_SPIRIT_ASSERT_MSG((
Chris@16:                 (sizeof(char_type) == sizeof(in_type))
Chris@16:             ), cannot_convert_string, (String));
Chris@16: 
Chris@16:             typedef spirit::char_class::convert<char_encoding> convert_type;
Chris@16: 
Chris@16:             char_type const* definition =
Chris@16:                 (char_type const*)traits::get_c_string(str);
Chris@16:             char_type ch = convert_type::to(Tag(), *definition++);
Chris@16:             while (ch)
Chris@16:             {
Chris@16:                 char_type next = convert_type::to(Tag(), *definition++);
Chris@16:                 if (next == '-')
Chris@16:                 {
Chris@16:                     next = convert_type::to(Tag(), *definition++);
Chris@16:                     if (next == 0)
Chris@16:                     {
Chris@16:                         chset.set(ch);
Chris@16:                         chset.set('-');
Chris@16:                         break;
Chris@16:                     }
Chris@16:                     chset.set(ch, next);
Chris@16:                 }
Chris@16:                 else
Chris@16:                 {
Chris@16:                     chset.set(ch);
Chris@16:                 }
Chris@16:                 ch = next;
Chris@16:             }
Chris@16:         }
Chris@16: 
Chris@16:         // A char_("a-z") which has an associated attribute emits it only if 
Chris@16:         // it matches the character set, otherwise it fails.
Chris@16:         template <typename Attribute, typename CharParam, typename Context>
Chris@16:         bool test(Attribute const& attr, CharParam& ch, Context&) const
Chris@16:         {
Chris@16:             // fail if attribute doesn't belong to character set
Chris@16:             ch = attr;
Chris@16:             return chset.test(char_type(attr));
Chris@16:         }
Chris@16: 
Chris@16:         // A char_("a-z") without any associated attribute fails compiling
Chris@16:         template <typename CharParam, typename Context>
Chris@16:         bool test(unused_type, CharParam&, Context&) const
Chris@16:         {
Chris@16:             // It is not possible (doesn't make sense) to use char_ generators
Chris@16:             // without providing any attribute, as the generator doesn't 'know'
Chris@16:             // what to output. The following assertion fires if this situation
Chris@16:             // is detected in your code.
Chris@16:             BOOST_SPIRIT_ASSERT_FAIL(CharParam
Chris@16:                , char_set_not_usable_without_attribute, ());
Chris@16:             return false;
Chris@16:         }
Chris@16: 
Chris@16:         template <typename Context>
Chris@16:         info what(Context& /*context*/) const
Chris@16:         {
Chris@16:             return info("char-set");
Chris@16:         }
Chris@16: 
Chris@16:         support::detail::basic_chset<char_type> chset;
Chris@16:     };
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     // Generator generators: make_xxx function (objects)
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         template <typename Modifiers, typename Encoding>
Chris@16:         struct basic_literal
Chris@16:         {
Chris@16:             static bool const lower =
Chris@16:                 has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
Chris@16:             static bool const upper =
Chris@16:                 has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
Chris@16: 
Chris@16:             typedef literal_char<
Chris@16:                 typename spirit::detail::get_encoding_with_case<
Chris@16:                     Modifiers, Encoding, lower || upper>::type
Chris@16:               , typename get_casetag<Modifiers, lower || upper>::type
Chris@16:               , true>
Chris@16:             result_type;
Chris@16: 
Chris@16:             template <typename Char>
Chris@16:             result_type operator()(Char ch, unused_type) const
Chris@16:             {
Chris@16:                 return result_type(ch);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename Char>
Chris@16:             result_type operator()(Char const* str, unused_type) const
Chris@16:             {
Chris@16:                 return result_type(str[0]);
Chris@16:             }
Chris@16:         };
Chris@16:     }
Chris@16: 
Chris@16:     // literals: 'x', "x"
Chris@16:     template <typename Modifiers>
Chris@16:     struct make_primitive<char, Modifiers>
Chris@16:       : detail::basic_literal<Modifiers, char_encoding::standard> {};
Chris@16: 
Chris@16:     template <typename Modifiers>
Chris@16:     struct make_primitive<char const(&)[2], Modifiers>
Chris@16:       : detail::basic_literal<Modifiers, char_encoding::standard> {};
Chris@16: 
Chris@16:     // literals: L'x', L"x"
Chris@16:     template <typename Modifiers>
Chris@16:     struct make_primitive<wchar_t, Modifiers>
Chris@16:       : detail::basic_literal<Modifiers, char_encoding::standard_wide> {};
Chris@16: 
Chris@16:     template <typename Modifiers>
Chris@16:     struct make_primitive<wchar_t const(&)[2], Modifiers>
Chris@16:       : detail::basic_literal<Modifiers, char_encoding::standard_wide> {};
Chris@16: 
Chris@16:     // char_
Chris@16:     template <typename CharEncoding, typename Modifiers>
Chris@16:     struct make_primitive<tag::char_code<tag::char_, CharEncoding>, Modifiers>
Chris@16:     {
Chris@16:         static bool const lower =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
Chris@16:         static bool const upper =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
Chris@16: 
Chris@16:         typedef any_char<
Chris@16:             typename spirit::detail::get_encoding_with_case<
Chris@16:                 Modifiers, CharEncoding, lower || upper>::type
Chris@16:           , typename detail::get_casetag<Modifiers, lower || upper>::type
Chris@16:         > result_type;
Chris@16: 
Chris@16:         result_type operator()(unused_type, unused_type) const
Chris@16:         {
Chris@16:             return result_type();
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         template <typename CharEncoding, typename Modifiers, typename A0
Chris@16:           , bool no_attribute>
Chris@16:         struct make_char_direct
Chris@16:         {
Chris@16:             static bool const lower =
Chris@16:                 has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
Chris@16:             static bool const upper =
Chris@16:                 has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
Chris@16: 
Chris@16:             typedef typename spirit::detail::get_encoding_with_case<
Chris@16:                 Modifiers, CharEncoding, lower || upper>::type encoding;
Chris@16:             typedef typename detail::get_casetag<
Chris@16:                 Modifiers, lower || upper>::type tag;
Chris@16: 
Chris@16:             typedef typename mpl::if_<
Chris@16:                 traits::is_string<A0>
Chris@16:               , char_set<encoding, tag, no_attribute>
Chris@16:               , literal_char<encoding, tag, no_attribute>
Chris@16:             >::type result_type;
Chris@16: 
Chris@16:             template <typename Terminal>
Chris@16:             result_type operator()(Terminal const& term, unused_type) const
Chris@16:             {
Chris@16:                 return result_type(fusion::at_c<0>(term.args));
Chris@16:             }
Chris@16:         };
Chris@16:     }
Chris@16: 
Chris@16:     // char_(...), lit(...)
Chris@16:     template <typename CharEncoding, typename Modifiers, typename A0>
Chris@16:     struct make_primitive<
Chris@16:             terminal_ex<
Chris@16:                 tag::char_code<tag::char_, CharEncoding>
Chris@16:               , fusion::vector1<A0> >
Chris@16:           , Modifiers>
Chris@16:       : detail::make_char_direct<CharEncoding, Modifiers, A0, false>
Chris@16:     {};
Chris@16: 
Chris@16:     template <typename Modifiers, typename A0>
Chris@16:     struct make_primitive<
Chris@16:             terminal_ex<tag::lit, fusion::vector1<A0> >
Chris@16:           , Modifiers
Chris@16:           , typename enable_if<traits::is_char<A0> >::type>
Chris@16:       : detail::make_char_direct<
Chris@16:             typename traits::char_encoding_from_char<
Chris@16:                 typename traits::char_type_of<A0>::type>::type
Chris@16:           , Modifiers, A0, true>
Chris@16:     {};
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     // char_("x")
Chris@16:     template <typename CharEncoding, typename Modifiers, typename Char>
Chris@16:     struct make_primitive<
Chris@16:         terminal_ex<
Chris@16:             tag::char_code<tag::char_, CharEncoding>
Chris@16:           , fusion::vector1<Char(&)[2]> > // For single char strings
Chris@16:       , Modifiers>
Chris@16:     {
Chris@16:         static bool const lower =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
Chris@16:         static bool const upper =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
Chris@16: 
Chris@16:         typedef literal_char<
Chris@16:             typename spirit::detail::get_encoding_with_case<
Chris@16:                 Modifiers, CharEncoding, lower || upper>::type
Chris@16:           , typename detail::get_casetag<Modifiers, lower || upper>::type
Chris@16:           , false
Chris@16:         > result_type;
Chris@16: 
Chris@16:         template <typename Terminal>
Chris@16:         result_type operator()(Terminal const& term, unused_type) const
Chris@16:         {
Chris@16:             return result_type(fusion::at_c<0>(term.args)[0]);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////
Chris@16:     // char_('a', 'z')
Chris@16:     template <typename CharEncoding, typename Modifiers, typename A0, typename A1>
Chris@16:     struct make_primitive<
Chris@16:         terminal_ex<
Chris@16:             tag::char_code<tag::char_, CharEncoding>
Chris@16:           , fusion::vector2<A0, A1>
Chris@16:         >
Chris@16:       , Modifiers>
Chris@16:     {
Chris@16:         static bool const lower =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
Chris@16:         static bool const upper =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
Chris@16: 
Chris@16:         typedef char_range<
Chris@16:             typename spirit::detail::get_encoding_with_case<
Chris@16:                 Modifiers, CharEncoding, lower || upper>::type
Chris@16:           , typename detail::get_casetag<Modifiers, lower || upper>::type
Chris@16:         > result_type;
Chris@16: 
Chris@16:         template <typename Terminal>
Chris@16:         result_type operator()(Terminal const& term, unused_type) const
Chris@16:         {
Chris@16:             return result_type(fusion::at_c<0>(term.args)
Chris@16:               , fusion::at_c<1>(term.args));
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     template <typename CharEncoding, typename Modifiers, typename Char>
Chris@16:     struct make_primitive<
Chris@16:         terminal_ex<
Chris@16:             tag::char_code<tag::char_, CharEncoding>
Chris@16:           , fusion::vector2<Char(&)[2], Char(&)[2]> // For single char strings
Chris@16:         >
Chris@16:       , Modifiers>
Chris@16:     {
Chris@16:         static bool const lower =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
Chris@16:         static bool const upper =
Chris@16:             has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
Chris@16: 
Chris@16:         typedef char_range<
Chris@16:             typename spirit::detail::get_encoding_with_case<
Chris@16:                 Modifiers, CharEncoding, lower || upper>::type
Chris@16:           , typename detail::get_casetag<Modifiers, lower || upper>::type
Chris@16:         > result_type;
Chris@16: 
Chris@16:         template <typename Terminal>
Chris@16:         result_type operator()(Terminal const& term, unused_type) const
Chris@16:         {
Chris@16:             return result_type(fusion::at_c<0>(term.args)[0]
Chris@16:               , fusion::at_c<1>(term.args)[0]);
Chris@16:         }
Chris@16:     };
Chris@16: }}}   // namespace boost::spirit::karma
Chris@16: 
Chris@16: #endif