[Boost-commit] svn:boost r56100 - in trunk/boost/spirit/home: karma/char karma/detail qi/char

Subject: [Boost-commit] svn:boost r56100 - in trunk/boost/spirit/home: karma/char karma/detail qi/char
From: hartmut.kaiser_at_[hidden]
Date: 2009-09-07 22:16:32

Author: hkaiser
Date: 2009-09-07 22:16:31 EDT (Mon, 07 Sep 2009)
New Revision: 56100
URL: http://svn.boost.org/trac/boost/changeset/56100

Log:
Spirit: Added character generator negation (unary '~' for character generators)
Text files modified: 
   trunk/boost/spirit/home/karma/char/char.hpp          |    97 +++++++++++++-------------------------- 
   trunk/boost/spirit/home/karma/char/char_class.hpp    |    60 +++++++++++-------------                
   trunk/boost/spirit/home/karma/detail/get_casetag.hpp |     4 -                                       
   trunk/boost/spirit/home/qi/char/char_parser.hpp      |     2                                         
   4 files changed, 63 insertions(+), 100 deletions(-)

Modified: trunk/boost/spirit/home/karma/char/char.hpp
==============================================================================
--- trunk/boost/spirit/home/karma/char/char.hpp	(original)
+++ trunk/boost/spirit/home/karma/char/char.hpp	2009-09-07 22:16:31 EDT (Mon, 07 Sep 2009)
@@ -19,6 +19,7 @@
 #include <boost/spirit/home/karma/domain.hpp>
 #include <boost/spirit/home/karma/meta_compiler.hpp>
 #include <boost/spirit/home/karma/delimit_out.hpp>
+#include <boost/spirit/home/karma/char/char_generator.hpp>
 #include <boost/spirit/home/karma/auxiliary/lazy.hpp>
 #include <boost/spirit/home/karma/detail/get_casetag.hpp>
 #include <boost/spirit/home/karma/detail/generate_to.hpp>
@@ -97,11 +98,8 @@
     ///////////////////////////////////////////////////////////////////////////
     template <typename CharEncoding, typename Tag>
     struct any_char
-      : primitive_generator<any_char<CharEncoding, Tag> >
+      : char_generator<any_char<CharEncoding, Tag>, CharEncoding, Tag>
     {
-        typedef typename CharEncoding::char_type char_type;
-        typedef CharEncoding char_encoding;
-
         template <typename Context, typename Unused>
         struct attribute
         {
@@ -109,21 +107,17 @@
         };
 
         // any_char has an attached parameter
-        template <
-            typename OutputIterator, typename Context, typename Delimiter
-          , typename Attribute>
-        static bool generate(OutputIterator& sink, Context&, Delimiter const& d
-          , Attribute const& attr)
+        template <typename Attribute, typename CharParam, typename Context>
+        bool test(Attribute const& attr, CharParam& ch, Context&) const
         {
-            return karma::detail::generate_to(sink, attr, char_encoding(), Tag()) &&
-                   karma::delimit_out(sink, d);       // always do post-delimiting
+            ch = attr;
+            return true;
         }
 
         // any_char has no attribute attached, it needs to have been
         // initialized from a direct literal
-        template <typename OutputIterator, typename Context, typename Delimiter>
-        static bool generate(OutputIterator&, Context&, Delimiter const&, 
-            unused_type const&)
+        template <typename CharParam, typename Context>
+        bool test(unused_type, CharParam&, Context&) const
         {
             // It is not possible (doesn't make sense) to use char_ without
             // providing any attribute, as the generator doesn't 'know' what
@@ -149,7 +143,8 @@
     ///////////////////////////////////////////////////////////////////////////
     template <typename CharEncoding, typename Tag, bool no_attribute>
     struct literal_char
-      : primitive_generator<literal_char<CharEncoding, Tag, no_attribute> >
+      : char_generator<literal_char<CharEncoding, Tag, no_attribute>
+          , CharEncoding, Tag>
     {
         typedef typename CharEncoding::char_type char_type;
         typedef CharEncoding char_encoding;
@@ -166,28 +161,22 @@
         // A char_('x') which additionally has an associated attribute emits
         // its immediate literal only if it matches the attribute, otherwise
         // it fails.
-        template <
-            typename OutputIterator, typename Context, typename Delimiter
-          , typename Attribute>
-        bool generate(OutputIterator& sink, Context&, Delimiter const& d
-          , Attribute const& attr) const
+        // any_char has an attached parameter
+        template <typename Attribute, typename CharParam, typename Context>
+        bool test(Attribute const& attr, CharParam& ch_, Context&) const
         {
             // fail if attribute isn't matched my immediate literal
-            if (attr != ch)
-                return false;
-
-            return karma::detail::generate_to(sink, ch) &&
-                   karma::delimit_out(sink, d);    // always do post-delimiting
+            ch_ = attr;
+            return attr == ch;
         }
 
         // A char_('x') without any associated attribute just emits its 
         // immediate literal
-        template <typename OutputIterator, typename Context, typename Delimiter>
-        bool generate(OutputIterator& sink, Context&, Delimiter const& d
-          , unused_type) const
+        template <typename CharParam, typename Context>
+        bool test(unused_type, CharParam& ch_, Context&) const
         {
-            return karma::detail::generate_to(sink, ch) &&
-                   karma::delimit_out(sink, d);    // always do post-delimiting
+            ch_ = ch;
+            return true;
         }
 
         template <typename Context>
@@ -203,7 +192,7 @@
     // char range generator
     template <typename CharEncoding, typename Tag>
     struct char_range
-      : primitive_generator<char_range<CharEncoding, Tag> >
+      : char_generator<char_range<CharEncoding, Tag>, CharEncoding, Tag>
     {
         typedef typename CharEncoding::char_type char_type;
         typedef CharEncoding char_encoding;
@@ -215,36 +204,23 @@
 
         // A char_('a', 'z') which has an associated attribute emits it only if 
         // it matches the character range, otherwise it fails.
-        template <
-            typename OutputIterator, typename Context, typename Delimiter
-          , typename Attribute>
-        bool generate(OutputIterator& sink, Context&, Delimiter const& d
-          , Attribute const& attr) const
+        template <typename Attribute, typename CharParam, typename Context>
+        bool test(Attribute const& attr, CharParam& ch, Context&) const
         {
             // fail if attribute doesn't belong to character range
-            if ((char_type(attr) < from) || (to < char_type(attr)))
-                return false;
-
-            return karma::detail::generate_to(sink, attr) &&
-                   karma::delimit_out(sink, d);    // always do post-delimiting
+            ch = attr;
+            return (from <= char_type(attr)) && (char_type(attr) <= to);
         }
 
         // A char_('a', 'z') without any associated attribute fails compiling
-        template <typename OutputIterator, typename Context, typename Delimiter>
-        bool generate(OutputIterator&, Context&, Delimiter const&
-          , unused_type) const
+        template <typename CharParam, typename Context>
+        bool test(unused_type, CharParam&, Context&) const
         {
             BOOST_SPIRIT_ASSERT_MSG(false
               , char_range_not_usable_without_attribute, ());
             return false;
         }
 
-        template <typename CharParam, typename Context>
-        bool test(CharParam ch, Context&) const
-        {
-            return !(char_type(ch) < from) && !(to < char_type(ch));
-        }
-
         template <typename Context>
         info what(Context& /*context*/) const
         {
@@ -261,7 +237,7 @@
     // character set generator
     template <typename CharEncoding, typename Tag>
     struct char_set
-      : primitive_generator<char_set<CharEncoding, Tag> >
+      : char_generator<char_set<CharEncoding, Tag>, CharEncoding, Tag>
     {
         typedef typename CharEncoding::char_type char_type;
         typedef CharEncoding char_encoding;
@@ -304,24 +280,17 @@
 
         // A char_("a-z") which has an associated attribute emits it only if 
         // it matches the character set, otherwise it fails.
-        template <
-            typename OutputIterator, typename Context, typename Delimiter
-          , typename Attribute>
-        bool generate(OutputIterator& sink, Context&, Delimiter const& d
-          , Attribute const& attr) const
+        template <typename Attribute, typename CharParam, typename Context>
+        bool test(Attribute const& attr, CharParam& ch, Context&) const
         {
             // fail if attribute doesn't belong to character set
-            if (!chset.test(char_type(attr)))
-                return false;
-
-            return karma::detail::generate_to(sink, attr) &&
-                   karma::delimit_out(sink, d);    // always do post-delimiting
+            ch = attr;
+            return chset.test(char_type(attr));
         }
 
         // A char_("a-z") without any associated attribute fails compiling
-        template <typename OutputIterator, typename Context, typename Delimiter>
-        bool generate(OutputIterator&, Context&, Delimiter const&
-          , unused_type) const
+        template <typename CharParam, typename Context>
+        bool test(unused_type, CharParam&, Context&) const
         {
             BOOST_SPIRIT_ASSERT_MSG(false
               , char_set_not_usable_without_attribute, ());

Modified: trunk/boost/spirit/home/karma/char/char_class.hpp
==============================================================================
--- trunk/boost/spirit/home/karma/char/char_class.hpp	(original)
+++ trunk/boost/spirit/home/karma/char/char_class.hpp	2009-09-07 22:16:31 EDT (Mon, 07 Sep 2009)
@@ -46,9 +46,11 @@
     //      class
     //
     ///////////////////////////////////////////////////////////////////////////
-    template <typename Tag>
+    template <typename Tag, typename CharEncoding, typename CharClass>
     struct char_class
-      : primitive_generator<char_class<Tag> >
+      : char_generator<
+            char_class<Tag, CharEncoding, CharClass>
+          , CharEncoding, CharClass>
     {
         typedef typename Tag::char_encoding char_encoding;
         typedef typename char_encoding::char_type char_type;
@@ -61,24 +63,18 @@
         };
 
         // char_class needs an attached attribute
-        template <
-            typename OutputIterator, typename Context, typename Delimiter
-          , typename Attribute>
-        static bool generate(OutputIterator& sink, Context&, Delimiter const& d
-          , Attribute const& attr)
+        template <typename Attribute, typename CharParam, typename Context>
+        bool test(Attribute const& attr, CharParam& ch, Context&) const
         {
-            using spirit::char_class::classify;
-            if (!classify<char_encoding>::is(classification(), attr))
-                return false;     // allow proper character class only
+            ch = attr;
 
-            return karma::detail::generate_to(sink, attr) &&
-                   karma::delimit_out(sink, d);      // always do post-delimiting
+            using spirit::char_class::classify;
+            return classify<char_encoding>::is(classification(), attr);
         }
 
         // char_class shouldn't be used without any associated attribute
-        template <typename OutputIterator, typename Context, typename Delimiter>
-        static bool generate(OutputIterator&, Context&, Delimiter const&
-          , unused_type const&)
+        template <typename CharParam, typename Context>
+        bool test(unused_type, CharParam& ch, Context&) const
         {
             BOOST_SPIRIT_ASSERT_MSG(false
               , char_class_not_usable_without_attribute, ());
@@ -101,7 +97,7 @@
     ///////////////////////////////////////////////////////////////////////////
     template <typename CharEncoding>
     struct any_space
-      : primitive_generator<any_space<CharEncoding> >
+      : char_generator<any_space<CharEncoding>, CharEncoding, tag::space>
     {
         typedef typename CharEncoding::char_type char_type;
         typedef CharEncoding char_encoding;
@@ -113,27 +109,21 @@
         };
 
         // any_space has an attached parameter
-        template <
-            typename OutputIterator, typename Context, typename Delimiter
-          , typename Attribute>
-        static bool generate(OutputIterator& sink, Context&, Delimiter const& d
-          , Attribute const& attr)
+        template <typename Attribute, typename CharParam, typename Context>
+        bool test(Attribute const& attr, CharParam& ch, Context&) const
         {
-            using spirit::char_class::classify;
-            if (!classify<char_encoding>::is(tag::space(), attr))
-                return false;     // allow whitespace only
+            ch = attr;
 
-            return karma::detail::generate_to(sink, attr) &&
-                   karma::delimit_out(sink, d);      // always do post-delimiting
+            using spirit::char_class::classify;
+            return classify<char_encoding>::is(tag::space(), attr);
         }
 
         // any_space has no attribute attached, use single space character
-        template <typename OutputIterator, typename Context, typename Delimiter>
-        static bool generate(OutputIterator& sink, Context&, Delimiter const& d, 
-            unused_type const&)
+        template <typename CharParam, typename Context>
+        bool test(unused_type, CharParam& ch, Context&) const
         {
-            return karma::detail::generate_to(sink, ' ') &&
-                   karma::delimit_out(sink, d);      // always do post-delimiting
+            ch = ' ';
+            return true;
         }
 
         template <typename Context>
@@ -183,7 +173,13 @@
           , CharEncoding>
         tag_type;
 
-        typedef char_class<tag_type> result_type;
+        typedef char_class<
+            tag_type
+          , typename spirit::detail::get_encoding<
+                Modifiers, CharEncoding, lower || upper>::type
+          , typename detail::get_casetag<Modifiers, lower || upper>::type
+        > result_type;
+
         result_type operator()(unused_type, unused_type) const
         {
             return result_type();

Modified: trunk/boost/spirit/home/karma/detail/get_casetag.hpp
==============================================================================
--- trunk/boost/spirit/home/karma/detail/get_casetag.hpp	(original)
+++ trunk/boost/spirit/home/karma/detail/get_casetag.hpp	2009-09-07 22:16:31 EDT (Mon, 07 Sep 2009)
@@ -21,9 +21,7 @@
     template <typename Modifiers>
     struct get_casetag<Modifiers, true>
       : mpl::if_<has_modifier<Modifiers, tag::char_code_base<tag::lower> >
-          , tag::lower
-          , tag::upper
-        > {};
+          , tag::lower, tag::upper> {};
 
 }}}}
 

Modified: trunk/boost/spirit/home/qi/char/char_parser.hpp
==============================================================================
--- trunk/boost/spirit/home/qi/char/char_parser.hpp	(original)
+++ trunk/boost/spirit/home/qi/char/char_parser.hpp	2009-09-07 22:16:31 EDT (Mon, 07 Sep 2009)
@@ -51,7 +51,7 @@
         typedef Char char_type;
         struct char_parser_id;
 
-        // if Char is unused_type, Derived must supply its own attribute
+        // if Attr is unused_type, Derived must supply its own attribute
         // metafunction
         template <typename Context, typename Iterator>
         struct attribute