Add pre_- and post_parser members to parser_modifiers; these are used as

look-ahead/-behind positive or negative assertions.

When combining parsers using op>> and op>, if either side is an expect_parser
and the other side has an open pre_-/post_parser slot, take the subparser out
of the expect_parser, and use it directly in the pre_-/post_parser slot.

See #160.

include/boost/parser/detail/printing.hpp

@@ -52,110 +52,118 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename DelimiterParser,
         typename MinType,
-        typename MaxType>
+        typename MaxType,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        repeat_parser<Parser, DelimiterParser, MinType, MaxType> const & parser,
+        repeat_parser<
+            Parser,
+            DelimiterParser,
+            MinType,
+            MaxType,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        opt_parser<Parser> const & parser,
+        opt_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename ParserTuple>
+    template<typename Context, typename ParserTuple, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        or_parser<ParserTuple> const & parser,
+        or_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename ParserTuple>
+    template<typename Context, typename ParserTuple, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        perm_parser<ParserTuple> const & parser,
+        perm_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups> const &
+        seq_parser<
-            parser,
+            ParserTuple,
+            BacktrackingTuple,
+            CombiningGroups,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser, typename Action>
+    template<
-    void print_parser(
+        typename Context,
+        typename Parser,
+        typename Action,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        action_parser<Parser, Action> const & parser,
+        action_parser<Parser, Action, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser, typename F>
+    template<typename Context, typename Parser, typename F, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        transform_parser<Parser, F> const & parser,
+        transform_parser<Parser, F, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        omit_parser<Parser> const & parser,
+        raw_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
-
-    template<typename Context, typename Parser>
-    void print_parser(
-        Context const & context,
-        raw_parser<Parser> const & parser,
-        std::ostream & os,
-        int components = 0);
 
 #if defined(BOOST_PARSER_DOXYGEN) || BOOST_PARSER_USE_CONCEPTS
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        string_view_parser<Parser> const & parser,
+        string_view_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 #endif
 
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        lexeme_parser<Parser> const & parser,
+        lexeme_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser>
+    template<
-    void print_parser(
+        typename Context,
+        typename Parser,
+        typename SkipParser,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        no_case_parser<Parser> const & parser,
+        skip_parser<Parser, SkipParser, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Parser, typename SkipParser>
+    template<
-    void print_parser(
+        typename Context,
+        typename Parser,
+        expect_match_t ExpectMatch,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        skip_parser<Parser, SkipParser> const & parser,
+        expect_parser<Parser, ExpectMatch, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
-
-    template<typename Context, typename Parser, bool FailOnMatch>
-    void print_parser(
-        Context const & context,
-        expect_parser<Parser, FailOnMatch> const & parser,
-        std::ostream & os,
-        int components = 0);
 
     template<
         typename Context,
@@ -163,143 +171,147 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename Attribute,
         typename LocalState,
-        typename ParamsTuple>
+        typename ParamsTuple,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
         rule_parser<
             UseCallbacks,
             Parser,
             Attribute,
             LocalState,
-            ParamsTuple> const & parser,
+            ParamsTuple,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename T>
+    template<typename Context, typename T, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        symbol_parser<T> const & parser,
+        symbol_parser<T, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Predicate>
+    template<typename Context, typename Predicate, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        eps_parser<Predicate> const & parser,
+        eps_parser<Predicate, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        eps_parser<nope> const & parser,
+        eps_parser<nope, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        eoi_parser const & parser,
+        eoi_parser<ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Atribute>
+    template<typename Context, typename Atribute, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        attr_parser<Atribute> const & parser,
+        attr_parser<Atribute, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Expected, typename AttributeType>
+    template<
-    void print_parser(
+        typename Context,
+        typename Expected,
+        typename AttributeType,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_parser<Expected, AttributeType> const & parser,
+        char_parser<Expected, AttributeType, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        digit_parser const & parser,
+        digit_parser<ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<hex_digit_subranges> const & parser,
+        char_subrange_parser<hex_digit_subranges, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<control_subranges> const & parser,
+        char_subrange_parser<control_subranges, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<punct_chars> const & parser,
+        char_set_parser<punct_chars, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<lower_case_chars> const & parser,
+        char_set_parser<lower_case_chars, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<upper_case_chars> const & parser,
+        char_set_parser<upper_case_chars, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Expected, typename AttributeType>
+    template<
-    void print_parser(
+        typename Context,
+        typename StrIter,
+        typename StrSentinel,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        omit_parser<char_parser<Expected, AttributeType>> const & parser,
+        string_parser<StrIter, StrSentinel, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename StrIter, typename StrSentinel>
+    template<
-    void print_parser(
+        typename Context,
+        typename Quotes,
+        typename Escapes,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        string_parser<StrIter, StrSentinel> const & parser,
+        quoted_string_parser<Quotes, Escapes, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename StrIter, typename StrSentinel>
+    template<
-    void print_parser(
+        typename Context,
+        bool NewlinesOnly,
+        bool NoNewlines,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        omit_parser<string_parser<StrIter, StrSentinel>> const & parser,
+        ws_parser<NewlinesOnly, NoNewlines, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename Quotes, typename Escapes>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        quoted_string_parser<Quotes, Escapes> const & parser,
+        bool_parser<ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
-
-    template<typename Context, bool NewlinesOnly, bool NoNewlines>
-    void print_parser(
-        Context const & context,
-        ws_parser<NewlinesOnly, NoNewlines> const & parser,
-        std::ostream & os,
-        int components = 0);
-
-    template<typename Context>
-    void print_parser(
-        Context const & context,
-        bool_parser const & parser,
-        std::ostream & os,
-        int components = 0);
 
     template<
         typename Context,
@@ -307,12 +319,19 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
+        typename Expected,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        uint_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        uint_parser<
+            T,
+            Radix,
+            MinDigits,
+            MaxDigits,
+            Expected,
+            ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
     template<
         typename Context,
@@ -320,38 +339,51 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
+        typename Expected,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        int_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        int_parser<T, Radix, MinDigits, MaxDigits, Expected, ParserMods> const &
+            parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename T>
+    template<typename Context, typename T, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        float_parser<T> const & parser,
+        float_parser<T, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        float_parser<float> const & parser,
+        float_parser<float, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        float_parser<double> const & parser,
+        float_parser<double, ParserMods> const & parser,
         std::ostream & os,
-        int components = 0);
+        int components);
 
-    template<typename Context, typename SwitchValue, typename OrParser>
+    template<
+        typename Context,
+        typename SwitchValue,
+        typename OrParser,
+        typename ParserMods>
+    void print_parser_impl(
+        Context const & context,
+        switch_parser<SwitchValue, OrParser, ParserMods> const & parser,
+        std::ostream & os,
+        int components);
+
+    template<bool SuppressOmit = false, typename Context, typename Parser>
     void print_parser(
         Context const & context,
-        switch_parser<SwitchValue, OrParser> const & parser,
+        Parser const & parser,
         std::ostream & os,
         int components = 0);
 

include/boost/parser/detail/printing_impl.hpp

@@ -43,36 +43,44 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename DelimiterParser,
         typename MinType,
-        typename MaxType>
+        typename MaxType,
+        typename ParserMods>
     struct n_aray_parser<
-        repeat_parser<Parser, DelimiterParser, MinType, MaxType>>
+        repeat_parser<Parser, DelimiterParser, MinType, MaxType, ParserMods>>
         : std::true_type
     {};
 
-    template<typename Parser, typename MinType, typename MaxType>
+    template<
-    struct n_aray_parser<repeat_parser<Parser, detail::nope, MinType, MaxType>>
+        typename Parser,
+        typename MinType,
+        typename MaxType,
+        typename ParserMods>
+    struct n_aray_parser<
+        repeat_parser<Parser, detail::nope, MinType, MaxType, ParserMods>>
         : std::false_type
     {};
 
-    template<typename Parser, typename DelimiterParser>
+    template<typename Parser, typename DelimiterParser, typename ParserMods>
-    struct n_aray_parser<delimited_seq_parser<Parser, DelimiterParser>>
+    struct n_aray_parser<
+        delimited_seq_parser<Parser, DelimiterParser, ParserMods>>
         : std::true_type
     {};
 
-    template<typename ParserTuple>
+    template<typename ParserTuple, typename ParserMods>
-    struct n_aray_parser<or_parser<ParserTuple>> : std::true_type
+    struct n_aray_parser<or_parser<ParserTuple, ParserMods>> : std::true_type
     {};
 
-    template<typename ParserTuple>
+    template<typename ParserTuple, typename ParserMods>
-    struct n_aray_parser<perm_parser<ParserTuple>> : std::true_type
+    struct n_aray_parser<perm_parser<ParserTuple, ParserMods>> : std::true_type
     {};
 
     template<
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
+        typename ParserMods>
     struct n_aray_parser<
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups>>
+        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups, ParserMods>>
         : std::true_type
     {};
 
@@ -101,10 +109,16 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename DelimiterParser,
         typename MinType,
-        typename MaxType>
+        typename MaxType,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        repeat_parser<Parser, DelimiterParser, MinType, MaxType> const & parser,
+        repeat_parser<
+            Parser,
+            DelimiterParser,
+            MinType,
+            MaxType,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -116,7 +130,7 @@ namespace boost { namespace parser { namespace detail {
                 os << "*";
                 if (n_ary_child)
                     os << "(";
-                detail::print_parser(
+                detail::print_parser_impl(
                     context, parser.parser_, os, components + 1);
                 if (n_ary_child)
                     os << ")";
@@ -124,7 +138,7 @@ namespace boost { namespace parser { namespace detail {
                 os << "+";
                 if (n_ary_child)
                     os << "(";
-                detail::print_parser(
+                detail::print_parser_impl(
                     context, parser.parser_, os, components + 1);
                 if (n_ary_child)
                     os << ")";
@@ -141,22 +155,22 @@ namespace boost { namespace parser { namespace detail {
                         detail::print(os, max_);
                     os << ")[";
                 }
-                detail::print_parser(
+                detail::print_parser_impl(
                     context, parser.parser_, os, components + 1);
                 os << "]";
             }
         } else {
-            detail::print_parser(context, parser.parser_, os, components + 1);
+            detail::print_parser_impl(context, parser.parser_, os, components + 1);
             os << " % ";
-            detail::print_parser(
+            detail::print_parser_impl(
                 context, parser.delimiter_parser_, os, components + 2);
         }
     }
 
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        opt_parser<Parser> const & parser,
+        opt_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -164,7 +178,7 @@ namespace boost { namespace parser { namespace detail {
         constexpr bool n_ary_child = n_aray_parser_v<Parser>;
         if (n_ary_child)
             os << "(";
-        detail::print_parser(context, parser.parser_, os, components + 1);
+        detail::print_parser_impl(context, parser.parser_, os, components + 1);
         if (n_ary_child)
             os << ")";
     }
@@ -189,16 +203,16 @@ namespace boost { namespace parser { namespace detail {
             }
             if (i)
                 os << ws_or;
-            detail::print_parser(context, parser, os, components);
+            detail::print_parser_impl(context, parser, os, components);
             ++components;
             ++i;
         });
     }
 
-    template<typename Context, typename ParserTuple>
+    template<typename Context, typename ParserTuple, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        or_parser<ParserTuple> const & parser,
+        or_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -206,10 +220,10 @@ namespace boost { namespace parser { namespace detail {
             context, parser, os, components, " | ...", " | ");
     }
 
-    template<typename Context, typename ParserTuple>
+    template<typename Context, typename ParserTuple, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        perm_parser<ParserTuple> const & parser,
+        perm_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -221,11 +235,15 @@ namespace boost { namespace parser { namespace detail {
         typename Context,
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups> const &
+        seq_parser<
-            parser,
+            ParserTuple,
+            BacktrackingTuple,
+            CombiningGroups,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -264,14 +282,18 @@ namespace boost { namespace parser { namespace detail {
             os << ']';
     }
 
-    template<typename Context, typename Parser, typename Action>
+    template<
-    void print_parser(
+        typename Context,
+        typename Parser,
+        typename Action,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        action_parser<Parser, Action> const & parser,
+        action_parser<Parser, Action, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
-        detail::print_parser(context, parser.parser_, os, components);
+        detail::print_parser_impl(context, parser.parser_, os, components);
         os << "[<<action>>]";
     }
 
@@ -287,14 +309,14 @@ namespace boost { namespace parser { namespace detail {
         if (++components == parser_component_limit)
             os << "...";
         else
-            detail::print_parser(context, parser, os, components + 1);
+            detail::print_parser_impl(context, parser, os, components + 1);
         os << "]";
     }
 
-    template<typename Context, typename Parser, typename F>
+    template<typename Context, typename Parser, typename F, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        transform_parser<Parser, F> const & parser,
+        transform_parser<Parser, F, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -302,21 +324,10 @@ namespace boost { namespace parser { namespace detail {
             context, "transform(<<f>>)", parser.parser_, os, components);
     }
 
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        omit_parser<Parser> const & parser,
+        raw_parser<Parser, ParserMods> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        detail::print_directive(
-            context, "omit", parser.parser_, os, components);
-    }
-
-    template<typename Context, typename Parser>
-    void print_parser(
-        Context const & context,
-        raw_parser<Parser> const & parser,
         std::ostream & os,
         int components)
     {
@@ -324,10 +335,10 @@ namespace boost { namespace parser { namespace detail {
     }
 
 #if defined(BOOST_PARSER_DOXYGEN) || BOOST_PARSER_USE_CONCEPTS
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        string_view_parser<Parser> const & parser,
+        string_view_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -336,10 +347,10 @@ namespace boost { namespace parser { namespace detail {
     }
 #endif
 
-    template<typename Context, typename Parser>
+    template<typename Context, typename Parser, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        lexeme_parser<Parser> const & parser,
+        lexeme_parser<Parser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -347,21 +358,14 @@ namespace boost { namespace parser { namespace detail {
             context, "lexeme", parser.parser_, os, components);
     }
 
-    template<typename Context, typename Parser>
+    template<
-    void print_parser(
+        typename Context,
+        typename Parser,
+        typename SkipParser,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        no_case_parser<Parser> const & parser,
+        skip_parser<Parser, SkipParser, ParserMods> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        detail::print_directive(
-            context, "no_case", parser.parser_, os, components);
-    }
-
-    template<typename Context, typename Parser, typename SkipParser>
-    void print_parser(
-        Context const & context,
-        skip_parser<Parser, SkipParser> const & parser,
         std::ostream & os,
         int components)
     {
@@ -370,7 +374,7 @@ namespace boost { namespace parser { namespace detail {
                 context, "skip", parser.parser_, os, components);
         } else {
             os << "skip(";
-            detail::print_parser(
+            detail::print_parser_impl(
                 context, parser.skip_parser_.parser_, os, components);
             os << ")";
             detail::print_directive(
@@ -378,21 +382,25 @@ namespace boost { namespace parser { namespace detail {
         }
     }
 
-    template<typename Context, typename Parser, bool FailOnMatch>
+    template<
-    void print_parser(
+        typename Context,
+        typename Parser,
+        expect_match_t ExpectMatch,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        expect_parser<Parser, FailOnMatch> const & parser,
+        expect_parser<Parser, ExpectMatch, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
-        if (FailOnMatch)
+        if constexpr (ExpectMatch == expect_match_t::yes)
-            os << "!";
-        else
             os << "&";
+        else
+            os << "!";
         constexpr bool n_ary_child = n_aray_parser_v<Parser>;
         if (n_ary_child)
             os << "(";
-        detail::print_parser(context, parser.parser_, os, components + 1);
+        detail::print_parser_impl(context, parser.parser_, os, components + 1);
         if (n_ary_child)
             os << ")";
     }
@@ -403,15 +411,17 @@ namespace boost { namespace parser { namespace detail {
         typename Parser,
         typename Attribute,
         typename LocalState,
-        typename ParamsTuple>
+        typename ParamsTuple,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
         rule_parser<
             UseCallbacks,
             Parser,
             Attribute,
             LocalState,
-            ParamsTuple> const & parser,
+            ParamsTuple,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -428,10 +438,10 @@ namespace boost { namespace parser { namespace detail {
         }
     }
 
-    template<typename Context, typename T>
+    template<typename Context, typename T, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        symbol_parser<T> const & parser,
+        symbol_parser<T, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -441,40 +451,40 @@ namespace boost { namespace parser { namespace detail {
             os << parser.diagnostic_text_;
     }
 
-    template<typename Context, typename Predicate>
+    template<typename Context, typename Predicate, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        eps_parser<Predicate> const & parser,
+        eps_parser<Predicate, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "eps(<<pred>>)";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        eps_parser<nope> const & parser,
+        eps_parser<nope, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "eps";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        eoi_parser const & parser,
+        eoi_parser<ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "eoi";
     }
 
-    template<typename Context, typename Atribute>
+    template<typename Context, typename Atribute, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        attr_parser<Atribute> const & parser,
+        attr_parser<Atribute, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -527,7 +537,7 @@ namespace boost { namespace parser { namespace detail {
     }
 
     template<typename Context, typename T>
-    struct char_print_parser_impl
+    struct char_print_parser_impl_impl
     {
         static void call(Context const & context, std::ostream & os, T expected)
         {
@@ -536,7 +546,7 @@ namespace boost { namespace parser { namespace detail {
     };
 
     template<typename Context, typename T, typename U>
-    struct char_print_parser_impl<Context, char_pair<T, U>>
+    struct char_print_parser_impl_impl<Context, char_pair<T, U>>
     {
         static void call(
             Context const & context,
@@ -550,7 +560,7 @@ namespace boost { namespace parser { namespace detail {
     };
 
     template<typename Context, typename Iter, typename Sentinel, bool B>
-    struct char_print_parser_impl<Context, char_range<Iter, Sentinel, B>>
+    struct char_print_parser_impl_impl<Context, char_range<Iter, Sentinel, B>>
     {
         static void call(
             Context const & context,
@@ -566,139 +576,134 @@ namespace boost { namespace parser { namespace detail {
         }
     };
 
-    template<typename Context, typename Expected, typename AttributeType>
+    template<
-    void print_parser(
+        typename Context,
+        typename Expected,
+        typename AttributeType,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        char_parser<Expected, AttributeType> const & parser,
+        char_parser<Expected, AttributeType, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
-        if (std::is_same_v<AttributeType, uint32_t>)
+        if constexpr (parser.mods_.omit_attr == parser::omit_attr_t::yes) {
-            os << "cp";
+            if constexpr (is_nope_v<Expected>) {
-        else if (std::is_same_v<AttributeType, char>)
+                os << "char_";
-            os << "cu";
+            } else {
-        else
+                char_print_parser_impl_impl<Context, Expected>::call(
-            os << "char_";
+                    context, os, parser.expected_);
-        if constexpr (!is_nope_v<Expected>) {
+            }
-            os << "(";
+        } else {
-            char_print_parser_impl<Context, Expected>::call(
+            if (std::is_same_v<AttributeType, uint32_t>)
-                context, os, parser.expected_);
+                os << "cp";
-            os << ")";
+            else if (std::is_same_v<AttributeType, char>)
+                os << "cu";
+            else
+                os << "char_";
+            if constexpr (!is_nope_v<Expected>) {
+                os << "(";
+                char_print_parser_impl_impl<Context, Expected>::call(
+                    context, os, parser.expected_);
+                os << ")";
+            }
         }
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        digit_parser const & parser,
+        digit_parser<ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "digit";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<hex_digit_subranges> const & parser,
+        char_subrange_parser<hex_digit_subranges, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "hex_digit";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_subrange_parser<control_subranges> const & parser,
+        char_subrange_parser<control_subranges, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "control";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<punct_chars> const & parser,
+        char_set_parser<punct_chars, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "punct";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<lower_case_chars> const & parser,
+        char_set_parser<lower_case_chars, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "lower";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        char_set_parser<upper_case_chars> const & parser,
+        char_set_parser<upper_case_chars, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "upper";
     }
 
-    template<typename Context, typename Expected, typename AttributeType>
+    template<
-    void print_parser(
+        typename Context,
+        typename StrIter,
+        typename StrSentinel,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        omit_parser<char_parser<Expected, AttributeType>> const & parser,
+        string_parser<StrIter, StrSentinel, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
-        if constexpr (is_nope_v<Expected>) {
+        if constexpr (parser.mods_.omit_attr == parser::omit_attr_t::no) {
-            os << "omit[char_]";
+            os << "string(";
-        } else {
-            char_print_parser_impl<Context, Expected>::call(
-                context, os, parser.parser_.expected_);
         }
-    }
+        os << "\"";
-
-    template<typename Context, typename StrIter, typename StrSentinel>
-    void print_parser(
-        Context const & context,
-        string_parser<StrIter, StrSentinel> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        os << "string(\"";
         for (auto c : BOOST_PARSER_DETAIL_TEXT_SUBRANGE(
                           parser.expected_first_, parser.expected_last_) |
                           text::as_utf8) {
             detail::print_char(os, c);
         }
-        os << "\")";
-    }
-
-    template<typename Context, typename StrIter, typename StrSentinel>
-    void print_parser(
-        Context const & context,
-        omit_parser<string_parser<StrIter, StrSentinel>> const & parser,
-        std::ostream & os,
-        int components)
-    {
         os << "\"";
-        for (auto c : BOOST_PARSER_DETAIL_TEXT_SUBRANGE(
+        if constexpr (parser.mods_.omit_attr == parser::omit_attr_t::no) {
-                          parser.parser_.expected_first_,
+            os << ")";
-                          parser.parser_.expected_last_) |
-                          text::as_utf8) {
-            detail::print_char(os, c);
         }
-        os << "\"";
     }
 
-    template<typename Context, typename Quotes, typename Escapes>
+    template<
-    void print_parser(
+        typename Context,
+        typename Quotes,
+        typename Escapes,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        quoted_string_parser<Quotes, Escapes> const & parser,
+        quoted_string_parser<Quotes, Escapes, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -716,10 +721,14 @@ namespace boost { namespace parser { namespace detail {
         os << ')';
     }
 
-    template<typename Context, bool NewlinesOnly, bool NoNewlines>
+    template<
-    void print_parser(
+        typename Context,
+        bool NewlinesOnly,
+        bool NoNewlines,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        ws_parser<NewlinesOnly, NoNewlines> const & parser,
+        ws_parser<NewlinesOnly, NoNewlines, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -731,10 +740,10 @@ namespace boost { namespace parser { namespace detail {
             os << "ws";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        bool_parser const & parser,
+        bool_parser<ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -747,10 +756,17 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
+        typename Expected,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        uint_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        uint_parser<
+            T,
+            Radix,
+            MinDigits,
+            MaxDigits,
+            Expected,
+            ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -791,27 +807,29 @@ namespace boost { namespace parser { namespace detail {
         int Radix,
         int MinDigits,
         int MaxDigits,
-        typename Expected>
+        typename Expected,
-    void print_parser(
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        int_parser<T, Radix, MinDigits, MaxDigits, Expected> const & parser,
+        int_parser<T, Radix, MinDigits, MaxDigits, Expected, ParserMods> const &
+            parser,
         std::ostream & os,
         int components)
     {
         if (Radix == 10 && MinDigits == 1 && MaxDigits == -1) {
-            if (std::is_same_v<T, short>) {
+            if constexpr (std::is_same_v<T, short>) {
                 os << "short_";
                 detail::print_expected(context, os, parser.expected_);
                 return;
-            } else if (std::is_same_v<T, int>) {
+            } else if constexpr (std::is_same_v<T, int>) {
                 os << "int_";
                 detail::print_expected(context, os, parser.expected_);
                 return;
-            } else if (std::is_same_v<T, long>) {
+            } else if constexpr (std::is_same_v<T, long>) {
                 os << "long_";
                 detail::print_expected(context, os, parser.expected_);
                 return;
-            } else if (std::is_same_v<T, long long>) {
+            } else if constexpr (std::is_same_v<T, long long>) {
                 os << "long_long";
                 detail::print_expected(context, os, parser.expected_);
                 return;
@@ -822,60 +840,30 @@ namespace boost { namespace parser { namespace detail {
         detail::print_expected(context, os, parser.expected_);
     }
             
-    template<typename Context>
+    template<typename Context, typename T, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        int_parser<short> const & parser,
+        float_parser<T, ParserMods> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        os << "short_";
-    }
-
-    template<typename Context>
-    void print_parser(
-        Context const & context,
-        int_parser<long> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        os << "long_";
-    }
-
-    template<typename Context>
-    void print_parser(
-        Context const & context,
-        int_parser<long long> const & parser,
-        std::ostream & os,
-        int components)
-    {
-        os << "long_long";
-    }
-
-    template<typename Context, typename T>
-    void print_parser(
-        Context const & context,
-        float_parser<T> const & parser,
         std::ostream & os,
         int components)
     {
         os << "float<" << detail::type_name<T>() << ">";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        float_parser<float> const & parser,
+        float_parser<float, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
         os << "float_";
     }
 
-    template<typename Context>
+    template<typename Context, typename ParserMods>
-    void print_parser(
+    void print_parser_impl(
         Context const & context,
-        float_parser<double> const & parser,
+        float_parser<double, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -886,10 +874,11 @@ namespace boost { namespace parser { namespace detail {
         typename Context,
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
+        typename ParserMods>
     void print_switch_matchers(
         Context const & context,
-        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups> const &
+        seq_parser<ParserTuple, BacktrackingTuple, CombiningGroups, ParserMods> const &
             parser,
         std::ostream & os,
         int components)
@@ -901,15 +890,15 @@ namespace boost { namespace parser { namespace detail {
             detail::resolve(
                 context, parser::get(parser.parsers_, 0_c).pred_.value_));
         os << ", ";
-        detail::print_parser(
+        detail::print_parser_impl(
             context, parser::get(parser.parsers_, 1_c), os, components);
         os << ")";
     }
 
-    template<typename Context, typename ParserTuple>
+    template<typename Context, typename ParserTuple, typename ParserMods>
     void print_switch_matchers(
         Context const & context,
-        or_parser<ParserTuple> const & parser,
+        or_parser<ParserTuple, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -928,10 +917,14 @@ namespace boost { namespace parser { namespace detail {
         });
     }
 
-    template<typename Context, typename SwitchValue, typename OrParser>
+    template<
-    void print_parser(
+        typename Context,
+        typename SwitchValue,
+        typename OrParser,
+        typename ParserMods>
+    void print_parser_impl(
         Context const & context,
-        switch_parser<SwitchValue, OrParser> const & parser,
+        switch_parser<SwitchValue, OrParser, ParserMods> const & parser,
         std::ostream & os,
         int components)
     {
@@ -942,6 +935,123 @@ namespace boost { namespace parser { namespace detail {
             context, parser.or_parser_, os, components);
     }
 
+    template<typename Context, typename Parser>
+    struct scoped_print_parser_mods
+    {
+        using parser_mods = decltype(std::declval<Parser>().mods_);
+
+        scoped_print_parser_mods(
+            Context const & context,
+            Parser const & parser,
+            std::ostream & os,
+            int & components,
+            bool suppress_omit) :
+            context_(context),
+            parser_(parser),
+            os_(os),
+            components_(components),
+            skip_omit_(suppress_omit)
+        {
+            if constexpr (parser_mods::omit_attr == parser::omit_attr_t::yes) {
+                if (!skip_omit_ && !skip_omit(parser_))
+                    os_ << "omit[";
+            }
+            if constexpr (
+                parser_mods::ignore_case == parser::ignore_case_t::yes) {
+                os_ << "no_case[";
+            }
+            if constexpr (!is_nope_v<typename parser_mods::pre_parser_type>) {
+                print_expected_operator<
+                    typename parser_mods::pre_parser_type>();
+                detail::print_parser<true>(
+                    context_,
+                    parser_.mods_.pre_parser.parser,
+                    os_,
+                    components_);
+                os_ << " >> ";
+            }
+        }
+        ~scoped_print_parser_mods()
+        {
+            if constexpr (!is_nope_v<typename parser_mods::post_parser_type>) {
+                os_ << " >> ";
+                print_expected_operator<
+                    typename parser_mods::post_parser_type>();
+                detail::print_parser<true>(
+                    context_,
+                    parser_.mods_.post_parser.parser,
+                    os_,
+                    components_);
+            }
+            if constexpr (
+                parser_mods::ignore_case == parser::ignore_case_t::yes) {
+                os_ << "]";
+            }
+            if constexpr (parser_mods::omit_attr == parser::omit_attr_t::yes) {
+                if (!skip_omit_ && !skip_omit(parser_))
+                    os_ << "]";
+            }
+        }
+
+        template<typename ExpectedParser>
+        void print_expected_operator()
+        {
+            if constexpr (ExpectedParser::expect_match == expect_match_t::yes) {
+                os_ << "&";
+            } else {
+                os_ << "!";
+            }
+        }
+
+        template<typename T>
+        static bool skip_omit(T const &)
+        {
+            return false;
+        }
+        template<typename Expected, typename AttributeType, typename ParserMods>
+        static bool
+        skip_omit(char_parser<Expected, AttributeType, ParserMods> const &)
+        {
+            return !std::is_same_v<Expected, detail::nope>;
+        }
+        template<typename StrIter, typename StrSentinel, typename ParserMods>
+        static bool
+        skip_omit(string_parser<StrIter, StrSentinel, ParserMods> const &)
+        {
+            return true;
+        }
+        template<
+            typename Parser2,
+            expect_match_t ExpectMatch,
+            typename ParserMods>
+        static bool
+        skip_omit(expect_parser<Parser2, ExpectMatch, ParserMods> const &)
+        {
+            return true;
+        }
+
+        Context const & context_;
+        Parser const & parser_;
+        std::ostream & os_;
+        int & components_;
+        bool skip_omit_;
+    };
+
+    // TODO: Document how recursive directives like 'omit[]' and
+    // `no_case[]`will reappear for subparsers sometimes, as in
+    // omt[*omit[char_]] (see test/tracing.cpp).
+    template<bool SuppressOmit, typename Context, typename Parser>
+    void print_parser(
+        Context const & context,
+        Parser const & parser,
+        std::ostream & os,
+        int components)
+    {
+        scoped_print_parser_mods _(
+            context, parser, os, components, SuppressOmit);
+        detail::print_parser_impl(context, parser, os, components);
+    }
+
 }}}
 
 #endif

include/boost/parser/parser_fwd.hpp

@@ -149,6 +149,35 @@ namespace boost { namespace parser {
         {};
     }
 
+    enum struct omit_attr_t { no, yes };
+    enum struct ignore_case_t { no, yes };
+    enum struct expect_match_t { no, yes };
+
+    template<typename Parser, expect_match_t ExpectMatch>
+    struct expected_parser
+    {
+        static constexpr expect_match_t expect_match = ExpectMatch;
+
+        Parser parser;
+    };
+
+    template<
+        omit_attr_t OmitAttr = omit_attr_t::no,
+        ignore_case_t IgnoreCase = ignore_case_t::no,
+        typename PreParser = detail::nope,
+        typename PostParser = detail::nope>
+    struct parser_modifiers
+    {
+        using pre_parser_type = PreParser;
+        using post_parser_type = PostParser;
+
+        static constexpr omit_attr_t omit_attr = OmitAttr;
+        static constexpr ignore_case_t ignore_case = IgnoreCase;
+
+        [[no_unique_address]] PreParser pre_parser;
+        [[no_unique_address]] PostParser post_parser;
+    };
+
     /** Repeats the application of another parser `p` of type `Parser`,
         optionally applying another parser `d` of type `DelimiterParser` in
         between each pair of applications of `p`.  The parse succeeds if `p`
@@ -159,20 +188,21 @@ namespace boost { namespace parser {
         typename Parser,
         typename DelimiterParser = detail::nope,
         typename MinType = int64_t,
-        typename MaxType = int64_t>
+        typename MaxType = int64_t,
+        typename ParserMods = parser_modifiers<>>
     struct repeat_parser;
 
     /** Repeats the application of another parser `p` of type `Parser`, `[0,
         Inf)` times.  The parse always succeeds.  The attribute produced is a
         sequence of the type of attribute produced by `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct zero_plus_parser;
 
     /** Repeats the application of another parser `p` of type `Parser`, `[1,
         Inf)` times.  The parse succeeds iff `p` succeeds at least once.  The
         attribute produced is a sequence of the type of attribute produced by
         `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct one_plus_parser;
 
     /** Repeats the application of another parser `p` of type `Parser`, `[1,
@@ -181,14 +211,14 @@ namespace boost { namespace parser {
         succeeds at least once, and `d` succeeds each time it is applied.  The
         attribute produced is a sequence of the type of attribute produced by
         `Parser`. */
-    template<typename Parser, typename DelimiterParser>
+    template<typename Parser, typename DelimiterParser, typename ParserMods>
     struct delimited_seq_parser;
 
     /** Repeats the application of another parser of type `Parser`, `[0, 1]`
         times.  The parse always succeeds.  The attribute produced is a
         `std::optional<T>`, where `T` is the type of attribute produced by
         `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct opt_parser;
 
     /** Applies each parser in `ParserTuple`, in order, stopping after the
@@ -196,7 +226,7 @@ namespace boost { namespace parser {
         one of the sub-parsers succeeds.  The attribute produced is a
         `std::variant` over the types of attribute produced by the parsers in
         `ParserTuple`. */
-    template<typename ParserTuple>
+    template<typename ParserTuple, typename ParserMods>
     struct or_parser;
 
     /** Applies each parsers in `ParserTuple`, an any order, stopping after
@@ -207,7 +237,7 @@ namespace boost { namespace parser {
         `ParserTuple`, not the order of the parsers' matches.  It is an error
         to specialize `perm_parser` with a `ParserTuple` template parameter
         that includes an `eps_parser`. */
-    template<typename ParserTuple>
+    template<typename ParserTuple, typename ParserMods>
     struct perm_parser;
 
     /** Applies each parser in `ParserTuple`, in order.  The parse succeeds
@@ -220,14 +250,15 @@ namespace boost { namespace parser {
     template<
         typename ParserTuple,
         typename BacktrackingTuple,
-        typename CombiningGroups>
+        typename CombiningGroups,
+        typename ParserMods>
     struct seq_parser;
 
     /** Applies the given parser `p` of type `Parser` and an invocable `a` of
         type `Action`.  `Action` shall model `semantic_action`, and `a` will
         only be invoked if `p` succeeds.  The parse succeeds iff `p` succeeds.
         Produces no attribute. */
-    template<typename Parser, typename Action>
+    template<typename Parser, typename Action, typename ParserMods>
     struct action_parser;
 
     /** Applies the given parser `p` of type `Parser`.  The attribute produced
@@ -235,21 +266,14 @@ namespace boost { namespace parser {
         only be invoked if `p` succeeds and sttributes are currently being
         generated.  The parse succeeds iff `p` succeeds.  The attribute
         produced is the the result of the call to `f`. */
-    template<typename Parser, typename F>
+    template<typename Parser, typename F, typename ParserMods>
     struct transform_parser;
 
-    /** Applies the given parser `p` of type `Parser`.  This parser produces
-        no attribute, and suppresses the production of any attributes that
-        would otherwise be produced by `p`.  The parse succeeds iff `p`
-        succeeds. */
-    template<typename Parser>
-    struct omit_parser;
-
     /** Applies the given parser `p` of type `Parser`; regardless of the
         attribute produced by `Parser`, this parser's attribute is equivalent
         to `_where(ctx)` within a semantic action on `p`.  The parse succeeds
         iff `p` succeeds. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct raw_parser;
 
 #if defined(BOOST_PARSER_DOXYGEN) || BOOST_PARSER_USE_CONCEPTS
@@ -262,34 +286,30 @@ namespace boost { namespace parser {
         non-contiguous, code using `string_view_parser` is ill-formed.  The
         parse succeeds iff `p` succeeds.  This parser is only available in
         C++20 and later. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct string_view_parser;
 #endif
 
     /** Applies the given parser `p` of type `Parser`, disabling the current
         skipper in use, if any.  The parse succeeds iff `p` succeeds.  The
         attribute produced is the type of attribute produced by `Parser`. */
-    template<typename Parser>
+    template<typename Parser, typename ParserMods>
     struct lexeme_parser;
 
-    /** Applies the given parser `p` of type `Parser`, enabling
-        case-insensitive matching, based on Unicode case folding.  The parse
-        succeeds iff `p` succeeds.  The attribute produced is the type of
-        attribute produced by `Parser`. */
-    template<typename Parser>
-    struct no_case_parser;
-
     /** Applies the given parser `p` of type `Parser`, using a parser of type
         `SkipParser` as the skipper.  The parse succeeds iff `p` succeeds.
         The attribute produced is the type of attribute produced by
         `Parser`. */
-    template<typename Parser, typename SkipParser = detail::nope>
+    template<
+        typename Parser,
+        typename SkipParser = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct skip_parser;
 
     /** Applies the given parser `p` of type `Parser`, producing no attributes
-        and consuming no input.  The parse succeeds iff `p`'s success is
+        and consuming no input.  The parse succeeds iff `p`'s success is equal
-        unequal to `FailOnMatch`. */
+        to `ExpectMatch == expect_match_t::yes`. */
-    template<typename Parser, bool FailOnMatch>
+    template<typename Parser, expect_match_t ExpectMatch, typename ParserMods>
     struct expect_parser;
 
     /** Matches one of a set S of possible inputs, each of which is associated
@@ -298,7 +318,7 @@ namespace boost { namespace parser {
         from S dynamically, during parsing; any such changes are reverted at
         the end of parsing.  The parse succeeds iff an element of S is
         matched.  \see `symbols` */
-    template<typename T>
+    template<typename T, typename ParserMods>
     struct symbol_parser;
 
     /** Applies another parser `p`, associated with this parser via `TagType`.
@@ -317,22 +337,24 @@ namespace boost { namespace parser {
         typename TagType,
         typename Attribute,
         typename LocalState,
-        typename ParamsTuple>
+        typename ParamsTuple,
+        typename ParserMods>
     struct rule_parser;
 
     /** Matches anything, and consumes no input.  If `Predicate` is anything
         other than `detail::nope` (which it is by default), and `pred_(ctx)`
         evaluates to false, where `ctx` is the parser context, the parse
         fails. */
-    template<typename Predicate>
+    template<typename Predicate, typename ParserMods>
     struct eps_parser;
 
     /** Matches only the end of input.  Produces no attribute. */
+    template<typename ParserMods>
     struct eoi_parser;
 
     /** Matches anything, consumes no input, and produces an attribute of type
         `RESOLVE(Attribute)`. */
-    template<typename Attribute>
+    template<typename Attribute, typename ParserMods>
     struct attr_parser;
 
     /** A tag type that can be passed as the first parameter to `char_()` when
@@ -349,7 +371,10 @@ namespace boost { namespace parser {
         parse fails only if the parser is constructed with a specific set of
         expected code point values that does not include the matched code
         point. */
-    template<typename Expected, typename AttributeType = void>
+    template<
+        typename Expected,
+        typename AttributeType = void,
+        typename ParserMods = parser_modifiers<>>
     struct char_parser;
 
     /** Matches a single code point that is equal to one of the code points
@@ -357,7 +382,7 @@ namespace boost { namespace parser {
         characters for matching Unicode character classes like punctuation or
         lower case.  Attribute type is the attribute type of the character
         being matched. */
-    template<typename Tag>
+    template<typename Tag, typename ParserMods>
     struct char_set_parser;
 
     /** Matches a single code point that falls into one of the subranges of
@@ -365,22 +390,26 @@ namespace boost { namespace parser {
         sets of characters for matching Unicode character classes like hex
         digits or control characters.  Attribute type is the attribute type of
         the character being matched. */
-    template<typename Tag>
+    template<typename Tag, typename ParserMods>
     struct char_subrange_parser;
 
     /** Matches a single decimal digit code point, using the Unicode character
         class Hex_Digit.  Attribute type is the attribute type of the
         character being matched. */
+    template<typename ParserMods>
     struct digit_parser;
 
     /** Matches a particular string, delimited by an iterator sentinel pair;
         produces no attribute. */
-    template<typename StrIter, typename StrSentinel>
+    template<typename StrIter, typename StrSentinel, typename ParserMods>
     struct string_parser;
 
     /** Matches a string delimited by quotation marks; produces a
         `std::string` attribute. */
-    template<typename Quotes = detail::nope, typename Escapes = detail::nope>
+    template<
+        typename Quotes = detail::nope,
+        typename Escapes = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct quoted_string_parser;
 
     /** Matches an end-of-line (`NewlinesOnly == true`), whitespace
@@ -388,11 +417,12 @@ namespace boost { namespace parser {
         but not newline) code point, based on the Unicode definitions of each
         (also matches the two code points `"\r\n"`).  Produces no
         attribute. */
-    template<bool NewlinesOnly, bool NoNewlines>
+    template<bool NewlinesOnly, bool NoNewlines, typename ParserMods>
     struct ws_parser;
 
     /** Matches the strings "true" and "false", producing an attribute of
         `true` or `false`, respectively, and fails on any other input. */
+    template<typename ParserMods>
     struct bool_parser;
 
     /** Matches an unsigned number of radix `Radix`, of at least `MinDigits`
@@ -406,7 +436,8 @@ namespace boost { namespace parser {
         int Radix = 10,
         int MinDigits = 1,
         int MaxDigits = -1,
-        typename Expected = detail::nope>
+        typename Expected = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct uint_parser;
 
     /** Matches a signed number of radix `Radix`, of at least `MinDigits` and
@@ -420,12 +451,13 @@ namespace boost { namespace parser {
         int Radix = 10,
         int MinDigits = 1,
         int MaxDigits = -1,
-        typename Expected = detail::nope>
+        typename Expected = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct int_parser;
 
     /** Matches a floating point number, producing an attribute of type
         `T`. */
-    template<typename T>
+    template<typename T, typename ParserMods>
     struct float_parser;
 
     /** Applies at most one of the parsers in `OrParser`.  If `switch_value_`
@@ -433,7 +465,10 @@ namespace boost { namespace parser {
         first such parser is applied, and the success or failure and attribute
         of the parse are those of the applied parser.  Otherwise, the parse
         fails. */
-    template<typename SwitchValue, typename OrParser = detail::nope>
+    template<
+        typename SwitchValue,
+        typename OrParser = detail::nope,
+        typename ParserMods = parser_modifiers<>>
     struct switch_parser;
 
     /** A wrapper for parsers that provides the operations that must be

include/boost/parser/replace.hpp

@@ -451,7 +451,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -469,7 +469,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -571,7 +571,8 @@ namespace boost::parser {
                              Parser,
                              GlobalState,
                              ErrorHandler,
-                             parser_interface<eps_parser<detail::phony>>>
+                             parser_interface<
+                                 eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -582,7 +583,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     (ReplacementR &&)replacement,
                     trace_mode);
             }
@@ -623,10 +625,11 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, replacement, trace) case
                     return impl(
-                        (R &&) r,
+                        (R &&)r,
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
+                        parser_interface<
-                        (SkipParser &&) skip,
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
+                        (SkipParser &&)skip,
                         replacement);
                 } else {
                     static_assert(

include/boost/parser/search.hpp

@@ -116,7 +116,9 @@ namespace boost::parser {
                 return BOOST_PARSER_SUBRANGE(first, first);
 
             auto const search_parser = omit[*(char_ - parser)] >> -raw[parser];
-            if constexpr (std::is_same_v<SkipParser, eps_parser<phony>>) {
+            if constexpr (std::is_same_v<
+                              SkipParser,
+                              eps_parser<phony, parser_modifiers<>>>) {
                 auto result = parser::prefix_parse(
                     first, last, search_parser, trace_mode);
                 if (*result)
@@ -255,9 +257,9 @@ namespace boost::parser {
         trace trace_mode = trace::off)
     {
         return parser::search(
-            (R &&) r,
+            (R &&)r,
             parser,
-            parser_interface<eps_parser<detail::phony>>{},
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>{},
             trace_mode);
     }
 
@@ -292,7 +294,7 @@ namespace boost::parser {
         return parser::search(
             BOOST_PARSER_SUBRANGE(first, last),
             parser,
-            parser_interface<eps_parser<detail::phony>>{},
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>{},
             trace_mode);
     }
 
@@ -483,7 +485,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -496,7 +498,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -569,7 +571,8 @@ namespace boost::parser {
                             Parser,
                             GlobalState,
                             ErrorHandler,
-                            parser_interface<eps_parser<detail::phony>>>
+                            parser_interface<
+                                eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -579,7 +582,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     trace_mode);
             }
 
@@ -590,8 +594,8 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler,
-                typename SkipParser =
+                typename SkipParser = parser_interface<
-                    parser_interface<eps_parser<detail::phony>>,
+                    eps_parser<detail::phony, parser_modifiers<>>>,
                 typename Trace = trace,
                 typename Enable = std::enable_if_t<is_parsable_range_v<R>>>
             [[nodiscard]] constexpr auto operator()(
@@ -607,9 +611,10 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, trace) case
                     return impl(
-                        (R &&) r,
+                        (R &&)r,
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
+                        parser_interface<
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
                         skip);
                 } else if constexpr (
                     detail::is_parser_iface<SkipParser> &&

include/boost/parser/split.hpp

@@ -193,14 +193,13 @@ namespace boost::parser {
         typename Parser,
         typename GlobalState,
         typename ErrorHandler>
-    split_view(
+    split_view(V &&, parser_interface<Parser, GlobalState, ErrorHandler>, trace)
-        V &&, parser_interface<Parser, GlobalState, ErrorHandler>, trace)
         -> split_view<
             detail::text::detail::all_t<V>,
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -213,7 +212,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -286,7 +285,8 @@ namespace boost::parser {
                             Parser,
                             GlobalState,
                             ErrorHandler,
-                            parser_interface<eps_parser<detail::phony>>>
+                            parser_interface<
+                                eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -296,7 +296,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     trace_mode);
             }
 
@@ -307,8 +308,8 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler,
-                typename SkipParser =
+                typename SkipParser = parser_interface<
-                    parser_interface<eps_parser<detail::phony>>,
+                    eps_parser<detail::phony, parser_modifiers<>>>,
                 typename Trace = trace,
                 typename Enable = std::enable_if_t<is_parsable_range_v<R>>>
             [[nodiscard]] constexpr auto operator()(
@@ -324,9 +325,10 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, trace) case
                     return impl(
-                        (R &&) r,
+                        (R &&)r,
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
+                        parser_interface<
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
                         skip);
                 } else if constexpr (
                     detail::is_parser_iface<SkipParser> &&

include/boost/parser/transform_replace.hpp

@@ -254,7 +254,9 @@ namespace boost::parser {
                     BOOST_PARSER_SUBRANGE(first, first), parse_result{});
             }
 
-            if constexpr (std::is_same_v<SkipParser, eps_parser<phony>>) {
+            if constexpr (std::is_same_v<
+                              SkipParser,
+                              eps_parser<phony, parser_modifiers<>>>) {
                 auto result = parser::prefix_parse(
                     first, last, search_parser, trace_mode);
                 if (*result) {
@@ -578,7 +580,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     template<
         typename V,
@@ -594,7 +596,7 @@ namespace boost::parser {
             Parser,
             GlobalState,
             ErrorHandler,
-            parser_interface<eps_parser<detail::phony>>>;
+            parser_interface<eps_parser<detail::phony, parser_modifiers<>>>>;
 
     namespace detail {
         template<
@@ -697,7 +699,8 @@ namespace boost::parser {
                              Parser,
                              GlobalState,
                              ErrorHandler,
-                             parser_interface<eps_parser<detail::phony>>>
+                             parser_interface<
+                                 eps_parser<detail::phony, parser_modifiers<>>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -708,7 +711,8 @@ namespace boost::parser {
                 return (*this)(
                     (R &&)r,
                     parser,
-                    parser_interface<eps_parser<detail::phony>>{},
+                    parser_interface<
+                        eps_parser<detail::phony, parser_modifiers<>>>{},
                     (F &&)f,
                     trace_mode);
             }
@@ -753,10 +757,11 @@ namespace boost::parser {
                     std::is_same_v<Trace, trace>) {
                     // (r, parser, f, trace) case
                     return impl(
-                        to_range<R>::call((R &&) r),
+                        to_range<R>::call((R &&)r),
                         parser,
-                        parser_interface<eps_parser<detail::phony>>{},
+                        parser_interface<
-                        (SkipParser &&) skip,
+                            eps_parser<detail::phony, parser_modifiers<>>>{},
+                        (SkipParser &&)skip,
                         f);
                 } else {
                     static_assert(

test/no_case.cpp

@@ -39,7 +39,7 @@ constexpr auto double_s = u8"sS";       // U+0073 U+0073
 
 // basic)
 {
-    constexpr auto char_p = no_case[char_('a') | char_('B')];
+    auto char_p = no_case[char_('a') | char_('B')];
 
     {
         auto const result = parse("a", char_p);
@@ -461,12 +461,12 @@ constexpr auto double_s = u8"sS";       // U+0073 U+0073
 {
     constexpr auto mixed_sharp_s1 = U"ẞs";
     constexpr auto mixed_sharp_s2 = U"sẞ";
-    auto const result = detail::no_case_aware_string_mismatch(
+    auto const result =
-        mixed_sharp_s1,
+        detail::no_case_aware_string_mismatch<ignore_case_t::yes>(
-        detail::text::null_sentinel,
+            mixed_sharp_s1,
-        mixed_sharp_s2,
+            detail::text::null_sentinel,
-        detail::text::null_sentinel,
+            mixed_sharp_s2,
-        true);
+            detail::text::null_sentinel);
     BOOST_TEST(result.first == detail::text::null_sentinel);
     BOOST_TEST(result.second == detail::text::null_sentinel);
 }

test/tracing.cpp

@@ -144,7 +144,7 @@ int main()
 
     std::cout << "\n\n"
               << "----------------------------------------\n"
-              << "| transform)f_[]                        |\n"
+              << "| transform(f)[]                        |\n"
               << "----------------------------------------\n";
 
     auto f = [](auto x) { return x; };
@@ -156,6 +156,8 @@ int main()
               << "----------------------------------------\n";
 
     PARSE(omit[char_]);
+    PARSE(omit[omit[char_]]);
+    PARSE(omit[*omit[char_]]);
 
     std::cout << "\n\n"
               << "----------------------------------------\n"
@@ -188,6 +190,15 @@ int main()
     PARSE(skip[char_]);
     PARSE(skip(ws)[char_]);
 
+    std::cout << "\n\n"
+              << "----------------------------------------\n"
+              << "| no_case[]                             |\n"
+              << "----------------------------------------\n";
+
+    PARSE(no_case[char_]);
+    PARSE(no_case[no_case[char_]]);
+    PARSE(no_case[*no_case[char_]]);
+
     std::cout << "\n\n"
               << "----------------------------------------\n"
               << "| merge[]                               |\n"
@@ -218,6 +229,16 @@ int main()
     PARSE(!char_);
     PARSE(!(*char_ >> char_));
 
+    PARSE(!char_ >> char_);
+    PARSE(*char_ >> !char_);
+    PARSE(!char_ >> *char_ >> char_ >> !char_);
+    try {
+        PARSE((!char_) > char_);
+    } catch (...) {
+    }
+    PARSE(*char_ > !char_);
+    PARSE((!char_) > *char_ >> char_ > !char_);
+
     std::cout << "\n\n"
               << "----------------------------------------\n"
               << "| operator&                             |\n"
@@ -226,6 +247,16 @@ int main()
     PARSE(&char_);
     PARSE(&(*char_ >> char_));
 
+    PARSE(&char_ >> char_);
+    PARSE(*char_ >> &char_);
+    PARSE(&char_ >> *char_ >> char_ >> &char_);
+    try {
+        PARSE(&char_ > char_);
+    } catch (...) {
+    }
+    PARSE(*char_ > &char_);
+    PARSE(&char_ >>*char_ >> char_ > &char_);
+
     std::cout << "\n\n"
               << "----------------------------------------\n"
               << "| symbols<T>                            |\n"