update sources to v12.2.3

[ceph.git] / ceph / src / boost / tools / quickbook / src / actions.hpp

diff --git a/ceph/src/boost/tools/quickbook/src/actions.hpp b/ceph/src/boost/tools/quickbook/src/actions.hpp
index 534376e2244ec4416162770a59a4d045143586c0..513fcfdfc7d300ee6415113f6e7a13220881375e 100644 (file)
--- a/ceph/src/boost/tools/quickbook/src/actions.hpp
+++ b/ceph/src/boost/tools/quickbook/src/actions.hpp
@@ -16,15 +16,17 @@
 #include "utils.hpp"
 #include "values.hpp"
 #include "scoped.hpp"
+#include "iterator.hpp"
 #include <boost/spirit/include/classic_parser.hpp>
 
 namespace quickbook
 {
     namespace cl = boost::spirit::classic;
 
+    // Match if quickbook version is within range
     struct quickbook_range : cl::parser<quickbook_range> {
-        quickbook_range(unsigned lower, unsigned upper)
-            : lower(lower), upper(upper) {}
+        explicit quickbook_range(unsigned lower_, unsigned upper_)
+            : lower(lower_), upper(upper_) {}
 
         bool in_range() const;
         
@@ -42,6 +44,34 @@ namespace quickbook
         return quickbook_range(lower, upper);
     }
 
+    // Match if in strict mode.
+    struct quickbook_strict : cl::parser<quickbook_strict> {
+        explicit quickbook_strict(quickbook::state& state_, bool positive_ = true)
+            : state(state_), positive(positive_) {}
+
+        bool is_strict_checking() const;
+
+        template <typename ScannerT>
+        typename cl::parser_result<quickbook_range, ScannerT>::type
+        parse(ScannerT const& scan) const
+        {
+            return is_strict_checking() == positive ?
+                scan.empty_match() : scan.no_match();
+        }
+
+        quickbook_strict operator~() const
+        {
+            return quickbook_strict(state, !positive);
+        }
+
+        quickbook::state& state;
+        bool positive;
+    };
+
+    inline quickbook_strict qbk_strict(quickbook::state& state, unsigned lower = 999u) {
+        return quickbook_strict(state, lower);
+    }
+
     // Throws load_error
     int load_snippets(fs::path const& file, std::vector<template_symbol>& storage,
         std::string const& extension, value::tag_type load_type);
@@ -50,9 +80,9 @@ namespace quickbook
     {
         // Prints an error message to std::cerr
 
-        error_message_action(quickbook::state& state, std::string const& m)
-            : state(state)
-            , message(m)
+        explicit error_message_action(quickbook::state& state_, std::string const& message_)
+            : state(state_)
+            , message(message_)
         {}
 
         void operator()(parse_iterator, parse_iterator) const;
@@ -65,8 +95,8 @@ namespace quickbook
     {
         // Prints an error message to std::cerr
 
-        error_action(quickbook::state& state)
-        : state(state) {}
+        explicit error_action(quickbook::state& state_)
+            : state(state_) {}
 
         void operator()(parse_iterator first, parse_iterator last) const;
 
@@ -80,8 +110,8 @@ namespace quickbook
 
     struct element_action
     {
-        element_action(quickbook::state& state)
-            : state(state) {}
+        explicit element_action(quickbook::state& state_)
+            : state(state_) {}
 
         void operator()(parse_iterator, parse_iterator) const;
 
@@ -93,9 +123,8 @@ namespace quickbook
         //  implicit paragraphs
         //  doesn't output the paragraph if it's only whitespace.
 
-        paragraph_action(
-            quickbook::state& state)
-        : state(state) {}
+        explicit paragraph_action(quickbook::state& state_)
+            : state(state_) {}
 
         void operator()() const;
         void operator()(parse_iterator, parse_iterator) const { (*this)(); }
@@ -108,9 +137,8 @@ namespace quickbook
         //  implicit paragraphs
         //  doesn't output the paragraph if it's only whitespace.
 
-        explicit_list_action(
-            quickbook::state& state)
-        : state(state) {}
+        explicit explicit_list_action(quickbook::state& state_)
+            : state(state_) {}
 
         void operator()() const;
         void operator()(parse_iterator, parse_iterator) const { (*this)(); }
@@ -120,8 +148,8 @@ namespace quickbook
 
     struct phrase_end_action
     {
-        phrase_end_action(quickbook::state& state) :
-            state(state) {}
+        explicit phrase_end_action(quickbook::state& state_)
+            : state(state_) {}
 
         void operator()() const;
         void operator()(parse_iterator, parse_iterator) const { (*this)(); }
@@ -133,8 +161,8 @@ namespace quickbook
     {
         //  Handles simple text formats
 
-        simple_phrase_action(quickbook::state& state)
-        : state(state) {}
+        explicit simple_phrase_action(quickbook::state& state_)
+            : state(state_) {}
 
         void operator()(char) const;
 
@@ -158,7 +186,7 @@ namespace quickbook
     {
         // Handles macro substitutions
 
-        do_macro_action(quickbook::state& state) : state(state) {}
+        explicit do_macro_action(quickbook::state& state_) : state(state_) {}
 
         void operator()(std::string const& str) const;
         quickbook::state& state;
@@ -168,7 +196,7 @@ namespace quickbook
     {
         // Prints a space
 
-        raw_char_action(quickbook::state& state) : state(state) {}
+        explicit raw_char_action(quickbook::state& state_) : state(state_) {}
 
         void operator()(char ch) const;
         void operator()(parse_iterator first, parse_iterator last) const;
@@ -181,7 +209,7 @@ namespace quickbook
         // Prints a single plain char.
         // Converts '<' to "&lt;"... etc See utils.hpp
 
-        plain_char_action(quickbook::state& state) : state(state) {}
+        explicit plain_char_action(quickbook::state& state_) : state(state_) {}
 
         void operator()(char ch) const;
         void operator()(parse_iterator first, parse_iterator last) const;
@@ -191,7 +219,7 @@ namespace quickbook
     
     struct escape_unicode_action
     {
-        escape_unicode_action(quickbook::state& state) : state(state) {}
+        explicit escape_unicode_action(quickbook::state& state_) : state(state_) {}
 
         void operator()(parse_iterator first, parse_iterator last) const;
 
@@ -200,7 +228,7 @@ namespace quickbook
 
     struct break_action
     {
-        break_action(quickbook::state& state) : state(state) {}
+        explicit break_action(quickbook::state& state_) : state(state_) {}
 
         void operator()(parse_iterator f, parse_iterator) const;
 
@@ -209,7 +237,7 @@ namespace quickbook
 
    struct element_id_warning_action
    {
-        element_id_warning_action(quickbook::state& state_)
+        explicit element_id_warning_action(quickbook::state& state_)
             : state(state_) {}
 
         void operator()(parse_iterator first, parse_iterator last) const;
@@ -223,8 +251,8 @@ namespace quickbook
 
     struct to_value_scoped_action : scoped_action_base
     {
-        to_value_scoped_action(quickbook::state& state)
-            : state(state) {}
+        to_value_scoped_action(quickbook::state& state_)
+            : state(state_) {}
 
         bool start(value::tag_type = value::default_tag);
         void success(parse_iterator, parse_iterator);
@@ -247,7 +275,7 @@ namespace quickbook
         T& l;
         member_function mf;
 
-        member_action(T& l, member_function mf) : l(l), mf(mf) {}
+        explicit member_action(T& l_, member_function mf_) : l(l_), mf(mf_) {}
 
         void operator()(parse_iterator first, parse_iterator last) const {
             (l.*mf)(first, last);
@@ -266,15 +294,15 @@ namespace quickbook
         T& l;
         member_function mf;
 
-        member_action1(T& l, member_function mf) : l(l), mf(mf) {}
+        explicit member_action1(T& l_, member_function mf_) : l(l_), mf(mf_) {}
 
         struct impl
         {
             member_action1 a;
             Arg1 value;
 
-            impl(member_action1& a, Arg1 value) :
-                a(a), value(value)
+            explicit impl(member_action1& a_, Arg1 value_) :
+                a(a_), value(value_)
             {}
 
             void operator()(parse_iterator first, parse_iterator last) const {
@@ -299,7 +327,7 @@ namespace quickbook
         T& l;
         member_function mf;
 
-        member_action_value(T& l, member_function mf) : l(l), mf(mf) {}
+        explicit member_action_value(T& l_, member_function mf_) : l(l_), mf(mf_) {}
 
         void operator()(Value v) const {
             (l.*mf)(v);
@@ -319,13 +347,13 @@ namespace quickbook
         member_function mf;
         Value v;
 
-        member_action_fixed_value(T& l, member_function mf, Value v) : l(l), mf(mf), v(v) {}
+        explicit member_action_fixed_value(T& l_, member_function mf_, Value v_) : l(l_), mf(mf_), v(v_) {}
 
         void operator()() const {
             (l.*mf)(v);
         }
 
-        void operator()(parse_iterator first, parse_iterator last) const {
+        void operator()(parse_iterator, parse_iterator) const {
             (l.*mf)(v);
         }
     };