From 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sat, 27 Apr 2024 20:24:20 +0200
Subject: Adding upstream version 14.2.21.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 src/boost/libs/spirit/test/qi/terminal_ex.cpp | 392 ++++++++++++++++++++++++++
 1 file changed, 392 insertions(+)
 create mode 100644 src/boost/libs/spirit/test/qi/terminal_ex.cpp

(limited to 'src/boost/libs/spirit/test/qi/terminal_ex.cpp')

diff --git a/src/boost/libs/spirit/test/qi/terminal_ex.cpp b/src/boost/libs/spirit/test/qi/terminal_ex.cpp
new file mode 100644
index 00000000..8514f113
--- /dev/null
+++ b/src/boost/libs/spirit/test/qi/terminal_ex.cpp
@@ -0,0 +1,392 @@
+/*=============================================================================
+    Copyright (c) 2008 Francois Barel
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/spirit/include/qi_operator.hpp>
+#include <boost/spirit/include/qi_char.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iterator>
+#include "test.hpp"
+
+
+namespace testns
+{
+
+    BOOST_SPIRIT_TERMINAL_NAME_EX( ops, ops_type )
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parsers
+    ///////////////////////////////////////////////////////////////////////////
+
+    template <typename T1>
+    struct ops_1_parser
+      : boost::spirit::qi::primitive_parser<ops_1_parser<T1> >
+    {
+        ops_1_parser(T1 t1)
+          : t1(t1)
+        {}
+
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef int type;   // Number of parsed chars.
+        };
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            boost::spirit::qi::skip_over(first, last, skipper);
+
+            int count = 0;
+
+            Iterator it = first;
+            typedef typename std::iterator_traits<Iterator>::value_type Char;
+            for (T1 t = 0; t < t1; t++, count++)
+                if (it == last || *it++ != Char('+'))
+                    return false;
+
+            boost::spirit::traits::assign_to(count, attr);
+            first = it;
+            return true;
+        }
+
+        template <typename Context>
+        boost::spirit::qi::info what(Context& /*context*/) const
+        {
+            return boost::spirit::qi::info("ops_1");
+        }
+
+        const T1 t1;
+
+        // silence MSVC warning C4512: assignment operator could not be generated
+        BOOST_DELETED_FUNCTION(ops_1_parser& operator= (ops_1_parser const&));
+    };
+
+    template <typename T1, typename T2>
+    struct ops_2_parser
+      : boost::spirit::qi::primitive_parser<ops_2_parser<T1, T2> >
+    {
+        ops_2_parser(T1 t1, T2 t2)
+          : t1(t1)
+          , t2(t2)
+        {}
+
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef int type;   // Number of parsed chars.
+        };
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            boost::spirit::qi::skip_over(first, last, skipper);
+
+            int count = 0;
+
+            Iterator it = first;
+            typedef typename std::iterator_traits<Iterator>::value_type Char;
+            for (T1 t = 0; t < t1; t++, count++)
+                if (it == last || *it++ != Char('+'))
+                    return false;
+            for (T2 t = 0; t < t2; t++, count++)
+                if (it == last || *it++ != Char('-'))
+                    return false;
+
+            boost::spirit::traits::assign_to(count, attr);
+            first = it;
+            return true;
+        }
+
+        template <typename Context>
+        boost::spirit::qi::info what(Context& /*context*/) const
+        {
+            return boost::spirit::qi::info("ops_2");
+        }
+
+        const T1 t1;
+        const T2 t2;
+
+        // silence MSVC warning C4512: assignment operator could not be generated
+        BOOST_DELETED_FUNCTION(ops_2_parser& operator= (ops_2_parser const&));
+    };
+
+    template <typename T1, typename T2, typename T3>
+    struct ops_3_parser
+      : boost::spirit::qi::primitive_parser<ops_3_parser<T1, T2, T3> >
+    {
+        ops_3_parser(T1 t1, T2 t2, T3 t3)
+          : t1(t1)
+          , t2(t2)
+          , t3(t3)
+        {}
+
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef int type;   // Number of parsed chars.
+        };
+
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            boost::spirit::qi::skip_over(first, last, skipper);
+
+            int count = 0;
+
+            Iterator it = first;
+            typedef typename std::iterator_traits<Iterator>::value_type Char;
+            for (T1 t = 0; t < t1; t++, count++)
+                if (it == last || *it++ != Char('+'))
+                    return false;
+            for (T2 t = 0; t < t2; t++, count++)
+                if (it == last || *it++ != Char('-'))
+                    return false;
+            for (T3 t = 0; t < t3; t++, count++)
+                if (it == last || *it++ != Char('*'))
+                    return false;
+
+            boost::spirit::traits::assign_to(count, attr);
+            first = it;
+            return true;
+        }
+
+        template <typename Context>
+        boost::spirit::qi::info what(Context& /*context*/) const
+        {
+            return boost::spirit::qi::info("ops_3");
+        }
+
+        const T1 t1;
+        const T2 t2;
+        const T3 t3;
+
+        // silence MSVC warning C4512: assignment operator could not be generated
+        BOOST_DELETED_FUNCTION(ops_3_parser& operator= (ops_3_parser const&));
+    };
+
+}
+
+
+namespace boost { namespace spirit
+{
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Enablers
+    ///////////////////////////////////////////////////////////////////////////
+
+    template <typename T1>
+    struct use_terminal<qi::domain
+      , terminal_ex<testns::tag::ops, fusion::vector1<T1> > >
+      : mpl::true_ {};
+
+    template <typename T1, typename T2>
+    struct use_terminal<qi::domain
+      , terminal_ex<testns::tag::ops, fusion::vector2<T1, T2> > >
+      : mpl::true_ {};
+
+    template <typename T1, typename T2, typename T3>
+    struct use_terminal<qi::domain
+      , terminal_ex<testns::tag::ops, fusion::vector3<T1, T2, T3> > >
+      : mpl::true_ {};
+
+    template <>
+    struct use_lazy_terminal<qi::domain, testns::tag::ops, 1>
+      : mpl::true_ {};
+
+    template <>
+    struct use_lazy_terminal<qi::domain, testns::tag::ops, 2>
+      : mpl::true_ {};
+
+    template <>
+    struct use_lazy_terminal<qi::domain, testns::tag::ops, 3>
+      : mpl::true_ {};
+
+}}
+
+namespace boost { namespace spirit { namespace qi
+{
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Parser generators: make_xxx function (objects)
+    ///////////////////////////////////////////////////////////////////////////
+
+    template <typename Modifiers, typename T1>
+    struct make_primitive<
+        terminal_ex<testns::tag::ops, fusion::vector1<T1> >
+      , Modifiers>
+    {
+        typedef testns::ops_1_parser<T1> result_type;
+        template <typename Terminal>
+        result_type operator()(const Terminal& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args)
+            );
+        }
+    };
+
+    template <typename Modifiers, typename T1, typename T2>
+    struct make_primitive<
+        terminal_ex<testns::tag::ops, fusion::vector2<T1, T2> >
+      , Modifiers>
+    {
+        typedef testns::ops_2_parser<T1, T2> result_type;
+        template <typename Terminal>
+        result_type operator()(const Terminal& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args)
+              , fusion::at_c<1>(term.args)
+            );
+        }
+    };
+
+    template <typename Modifiers, typename T1, typename T2, typename T3>
+    struct make_primitive<
+        terminal_ex<testns::tag::ops, fusion::vector3<T1, T2, T3> >
+      , Modifiers>
+    {
+        typedef testns::ops_3_parser<T1, T2, T3> result_type;
+        template <typename Terminal>
+        result_type operator()(const Terminal& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args)
+              , fusion::at_c<1>(term.args)
+              , fusion::at_c<2>(term.args)
+            );
+        }
+    };
+
+}}}
+
+
+namespace testns
+{
+    template <typename T1, typename T>
+    void check_type_1(const T& /*t*/)
+    {
+        BOOST_STATIC_ASSERT(( boost::is_same<T
+          , typename boost::spirit::terminal<testns::tag::ops>::result<T1>::type >::value ));
+    }
+
+    template <typename T1, typename T2, typename T>
+    void check_type_2(const T& /*t*/)
+    {
+        BOOST_STATIC_ASSERT(( boost::is_same<T
+          , typename boost::spirit::terminal<testns::tag::ops>::result<T1, T2>::type >::value ));
+    }
+
+    template <typename T1, typename T2, typename T3, typename T>
+    void check_type_3(const T& /*t*/)
+    {
+        BOOST_STATIC_ASSERT(( boost::is_same<T
+          , typename boost::spirit::terminal<testns::tag::ops>::result<T1, T2, T3>::type >::value ));
+    }
+}
+
+
+int
+main()
+{
+    using spirit_test::test_attr;
+    using spirit_test::test;
+
+    using testns::ops;
+    using testns::check_type_1;
+    using testns::check_type_2;
+    using testns::check_type_3;
+
+    { // immediate args
+        int c = 0;
+#define IP1 ops(2)
+        check_type_1<int>(IP1);
+        BOOST_TEST(test_attr("++/", IP1 >> '/', c) && c == 2);
+
+        c = 0;
+#define IP2 ops(2, 3)
+        check_type_2<int, int>(IP2);
+        BOOST_TEST(test_attr("++---/", IP2 >> '/', c) && c == 5);
+
+        c = 0;
+#define IP3 ops(2, 3, 4)
+        check_type_3<int, int, int>(IP3);
+        BOOST_TEST(!test("++---***/", IP3 >> '/'));
+#define IP4 ops(2, 3, 4)
+        check_type_3<int, int, int>(IP4);
+        BOOST_TEST(test_attr("++---****/", IP4 >> '/', c) && c == 9);
+    }
+
+    using boost::phoenix::val;
+    using boost::phoenix::actor;
+    using boost::phoenix::expression::value;
+
+    { // all lazy args
+        int c = 0;
+#define LP1 ops(val(1))
+        check_type_1<value<int>::type>(LP1);
+        BOOST_TEST(test_attr("+/", LP1 >> '/', c) && c == 1);
+
+        c = 0;
+#define LP2 ops(val(1), val(4))
+        check_type_2<value<int>::type, value<int>::type>(LP2);
+        BOOST_TEST(test_attr("+----/", LP2 >> '/', c) && c == 5);
+
+        c = 0;
+#define LP3 ops(val((char)2), val(3.), val(4))
+        check_type_3<value<char>::type, value<double>::type, value<int>::type>(LP3);
+        BOOST_TEST(!test("++---***/", LP3 >> '/'));
+#define LP4 ops(val(1), val(2), val(3))
+        check_type_3<value<int>::type, value<int>::type, value<int>::type>(LP4);
+        BOOST_TEST(test_attr("+--***/", LP4 >> '/', c) && c == 6);
+    }
+
+    { // mixed immediate and lazy args
+        namespace fusion = boost::fusion;
+        namespace phx = boost::phoenix;
+
+        int c = 0;
+#define MP1 ops(val(3), 2)
+        check_type_2<value<int>::type, int>(MP1);
+        BOOST_TEST(test_attr("+++--/", MP1 >> '/', c) && c == 5);
+
+        c = 0;
+#define MP2 ops(4, val(1))
+        check_type_2<int, value<int>::type>(MP2);
+        BOOST_TEST(test_attr("++++-/", MP2 >> '/', c) && c == 5);
+
+        c = 0;
+#define MP3 ops(2, val(2), val(2))
+        check_type_3<int, value<int>::type, value<int>::type>(MP3);
+        BOOST_TEST(!test("++-**/", MP3 >> '/'));
+#define MP4 ops(2, val(2), 2)
+        check_type_3<int, value<int>::type, int>(MP4);
+        BOOST_TEST(test_attr("++--**/", MP4 >> '/', c) && c == 6);
+
+        c = 0;
+#define MP5 ops(val(5) - val(3), 2, val(2))
+        check_type_3<phx::expression::minus<value<int>::type, value<int>::type>::type, int, value<int>::type>(MP5);
+        BOOST_TEST(test_attr("++--**/", MP5 >> '/', c) && c == 6);
+    }
+
+    return boost::report_errors();
+}
+
-- 
cgit v1.2.3