Ticket #6050: spirit-transform-attribute-post-bool-v2.diff

home/qi/auxiliary/attr_cast.hpp

@@ -92 +92 @@
 
             typename transform::type attr_ = transform::pre(attr);
 
-            if (!compile<qi::domain>(subject).
-                    parse(first, last, context, skipper, attr_))
+            Iterator i = first;
+
+            if (compile<qi::domain>(subject).
+                    parse(i, last, context, skipper, attr_))
             {
-                transform::fail(attr);
-                return false;
+                // do up-stream transformation, this mainly integrates the results
+                // back into the original attribute value, if appropriate
+                if (traits::post_transform(attr, attr_)) {
+                    first = i;
+                    return true;
+                }
             }
 
-            // do up-stream transformation, this mainly integrates the results
-            // back into the original attribute value, if appropriate
-            traits::post_transform(attr, attr_);
-            return true;
+            transform::fail(attr);
+            return false;
         }
 
         template <typename Context>

home/qi/detail/attributes.hpp

@@ -22 +22 @@
 
         static Transformed pre(Exposed&) { return Transformed(); }
 
-        static void post(Exposed& val, Transformed const& attr)
+        static bool post(Exposed& val, Transformed const& attr)
         {
             traits::assign_to(attr, val);
+            return true;
         }
 
         // fail() will be called by Qi rule's if the rhs failed parsing
@@ -37 +38 @@
     {
         typedef Attribute& type;
         static Attribute& pre(Attribute& val) { return val; }
-        static void post(Attribute&, Attribute const&) {}
+        static bool post(Attribute&, Attribute const&) { return true; }
         static void fail(Attribute&) {}
     };
 
@@ -47 +48 @@
         typedef Transformed type;
 
         static Transformed pre(Exposed& val) { return Transformed(val); }
-        static void post(Exposed&, Transformed const&) { /* no-op */ }
+        static bool post(Exposed&, Transformed const&) { return true; }
 
         // fail() will be called by Qi rule's if the rhs failed parsing
         static void fail(Exposed&) {}
@@ -59 +60 @@
     {
         typedef Attribute& type;
         static Attribute& pre(Attribute& val) { return val; }
-        static void post(Attribute&, Attribute const&) {}
+        static bool post(Attribute&, Attribute const&) { return true; }
         static void fail(Attribute&) {}
     };
 
@@ -87 +88 @@
                 val = Transformed();
             return boost::get<Transformed>(val);
         }
-        static void post(boost::optional<Exposed>&, Transformed const&) {}
+        static bool post(boost::optional<Exposed>&, Transformed const&) { return true; }
         static void fail(boost::optional<Exposed>& val)
         {
              val = none_t();    // leave optional uninitialized if rhs failed
@@ -100 +101 @@
     {
         typedef Attribute& type;
         static Attribute& pre(Attribute& val) { return val; }
-        static void post(Attribute&, Attribute const&) {}
+        static bool post(Attribute&, Attribute const&) { return true; }
         static void fail(Attribute&) {}
     };
 
@@ -110 +111 @@
     {
         typedef unused_type type;
         static unused_type pre(unused_type) { return unused; }
-        static void post(unused_type, unused_type) {}
+        static bool post(unused_type, unused_type) { return true; }
         static void fail(unused_type) {}
     };
 
@@ -160 +161 @@
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename Exposed, typename Transformed>
-    void post_transform(Exposed& dest, Transformed const& attr)
+    bool post_transform(Exposed& dest, Transformed const& attr)
     {
         return transform_attribute<Exposed, Transformed, qi::domain>::post(dest, attr);
     }

home/qi/nonterminal/rule.hpp

@@ -285 +285 @@
                 // attributes, without passing values for them.
                 context_type context(attr_);
 
+                Iterator i = first;
+
                 // If you are seeing a compilation error here stating that the
                 // fourth parameter can't be converted to a required target type
                 // then you are probably trying to use a rule or a grammar with
                 // an incompatible skipper type.
-                if (f(first, last, context, skipper))
+                if (f(i, last, context, skipper))
                 {
                     // do up-stream transformation, this integrates the results
                     // back into the original attribute value, if appropriate
-                    traits::post_transform(attr, attr_);
-                    return true;
+                    if (traits::post_transform(attr, attr_)) {
+                        first = i;
+                        return true;
+                    }
                 }
 
                 // inform attribute transformation of failed rhs
@@ -331 +335 @@
                 // attributes, passing values of incompatible types for them.
                 context_type context(attr_, params, caller_context);
 
+                Iterator i = first;
+
                 // If you are seeing a compilation error here stating that the
                 // fourth parameter can't be converted to a required target type
                 // then you are probably trying to use a rule or a grammar with
                 // an incompatible skipper type.
-                if (f(first, last, context, skipper))
+                if (f(i, last, context, skipper))
                 {
                     // do up-stream transformation, this integrates the results
                     // back into the original attribute value, if appropriate
-                    traits::post_transform(attr, attr_);
-                    return true;
+                    if (traits::post_transform(attr, attr_)) {
+                        first = i;
+                        return true;
+                    }
                 }
 
                 // inform attribute transformation of failed rhs

home/support/adapt_adt_attributes.hpp

@@ -257 +257 @@
         { 
             return val; 
         }
-        static void 
+        static bool
         post(
             fusion::extension::adt_attribute_proxy<T, N, false>& val
           , Attribute const& attr) 
         {
             val = attr;
+            return true;
         }
         static void 
         fail(fusion::extension::adt_attribute_proxy<T, N, false>&)
@@ -289 +290 @@
         { 
             return val; 
         }
-        static void 
+        static bool
         post(
             fusion::extension::adt_attribute_proxy<T, N, Const>&
           , Attribute const&)
         {
+            return true;
         }
         static void 
         fail(fusion::extension::adt_attribute_proxy<T, N, Const>&)

repository/home/qi/nonterminal/subrule.hpp

@@ -213 +213 @@
             // without passing values for them.
             context_type context(*this, attr_);
 
-            if (def.binder(first, last, context, skipper))
+            Iterator i = first;
+
+            if (def.binder(i, last, context, skipper))
             {
                 // do up-stream transformation, this integrates the results 
                 // back into the original attribute value, if appropriate
-                traits::post_transform(attr, attr_);
-                return true;
+                if (traits::post_transform(attr, attr_)) {
+                    first = i;
+                    return true;
+                }
             }
 
             // inform attribute transformation of failed rhs
@@ -267 +271 @@
             // passing values of incompatible types for them.
             context_type context(*this, attr_, params, caller_context);
 
-            if (def.binder(first, last, context, skipper))
+            Iterator i = first;
+
+            if (def.binder(i, last, context, skipper))
             {
                 // do up-stream transformation, this integrates the results 
                 // back into the original attribute value, if appropriate
-                traits::post_transform(attr, attr_);
-                return true;
+                if (traits::post_transform(attr, attr_)) {
+                    first = i;
+                    return true;
+                }
             }
 
             // inform attribute transformation of failed rhs