diff DEPENDENCIES/generic/include/boost/spirit/home/classic/dynamic/while.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/spirit/home/classic/dynamic/while.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,189 @@
+/*=============================================================================
+    Copyright (c) 2002-2003 Joel de Guzman
+    Copyright (c) 2002-2003 Martin Wille
+    http://spirit.sourceforge.net/
+
+  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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_WHILE_HPP
+#define BOOST_SPIRIT_WHILE_HPP
+
+#include <boost/spirit/home/classic/namespace.hpp>
+#include <boost/spirit/home/classic/core/parser.hpp>
+#include <boost/spirit/home/classic/core/composite/composite.hpp>
+#include <boost/spirit/home/classic/dynamic/impl/conditions.ipp>
+
+////////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+    namespace impl {
+
+    //////////////////////////////////
+    // while parser
+    // object are created by while_parser_gen and do_parser_gen
+    template <typename ParsableT, typename CondT, bool is_do_parser>
+    struct while_parser
+        : public condition_evaluator< typename as_parser<CondT>::type >
+        , public unary // the parent stores a copy of the body parser
+        <
+            typename as_parser<ParsableT>::type,
+            parser<while_parser<ParsableT, CondT, is_do_parser> >
+        >
+    {
+        typedef while_parser<ParsableT, CondT, is_do_parser> self_t;
+
+        typedef as_parser<ParsableT>            as_parser_t;
+        typedef typename as_parser_t::type      parser_t;
+        typedef as_parser<CondT>                cond_as_parser_t;
+        typedef typename cond_as_parser_t::type condition_t;
+
+        typedef unary<parser_t, parser<self_t> > base_t;
+        typedef condition_evaluator<condition_t> eval_t;
+
+
+        //////////////////////////////
+        // constructor, saves condition and body parser
+        while_parser(ParsableT const &body, CondT const &cond)
+            : eval_t(cond_as_parser_t::convert(cond))
+            , base_t(as_parser_t::convert(body))
+        {}
+
+        //////////////////////////////
+        // result type computer.
+        template <typename ScannerT>
+        struct result
+        {
+            typedef typename match_result
+                <ScannerT, nil_t>::type type;
+        };
+
+        //////////////////////////////
+        // parse member function
+        template <typename ScannerT>
+        typename parser_result<self_t, ScannerT>::type
+        parse(ScannerT const& scan) const
+        {
+            typedef typename parser_result<parser_t, ScannerT>::type sresult_t;
+            typedef typename ScannerT::iterator_t                    iterator_t;
+
+            iterator_t save(scan.first);
+            std::size_t length = 0;
+            int eval_length = 0;
+
+            bool dont_check_condition = is_do_parser;
+
+            while (dont_check_condition || (eval_length=this->evaluate(scan))>=0)
+            {
+                dont_check_condition = false;
+                length += eval_length;
+                sresult_t tmp(this->subject().parse(scan));
+                if (tmp)
+                {
+                    length+=tmp.length();
+                }
+                else
+                {
+                    return scan.no_match();
+                }
+            }
+            return scan.create_match(length, nil_t(), save, scan.first);
+        }
+    };
+
+    //////////////////////////////////
+    // while-parser generator, takes the body-parser in brackets
+    // and returns the actual while-parser.
+    template <typename CondT>
+    struct while_parser_gen
+    {
+        //////////////////////////////
+        // constructor, saves the condition for use by operator[]
+        while_parser_gen(CondT const& cond_) : cond(cond_) {}
+
+        //////////////////////////////
+        // operator[] returns the actual while-parser object
+        template <typename ParsableT>
+        while_parser<ParsableT, CondT, false>
+        operator[](ParsableT const &subject) const
+        {
+            return while_parser<ParsableT, CondT, false>(subject, cond);
+        }
+    private:
+
+        //////////////////////////////
+        // the condition is stored by reference here.
+        // this should not cause any harm since object of type
+        // while_parser_gen<> are only used as temporaries
+        // the while-parser object constructed by the operator[]
+        // stores a copy of the condition.
+        CondT const &cond;
+    };
+
+    //////////////////////////////////
+    // do-while-parser generator, takes the condition as
+    // parameter to while_p member function and returns the
+    // actual do-while-parser.
+    template <typename ParsableT>
+    struct do_while_parser_gen
+    {
+        //////////////////////////////
+        // constructor. saves the body parser for use by while_p.
+        explicit do_while_parser_gen(ParsableT const &body_parser)
+            : body(body_parser)
+        {}
+
+        //////////////////////////////
+        // while_p returns the actual while-parser object
+        template <typename CondT>
+        while_parser<ParsableT, CondT, true>
+        while_p(CondT cond) const
+        {
+            return while_parser<ParsableT, CondT, true>(body, cond);
+        }
+    private:
+
+        //////////////////////////////
+        // the body is stored by reference here
+        // this should not cause any harm since object of type
+        // do_while_parser_gen<> are only used as temporaries
+        // the while-parser object constructed by the while_p
+        // member function stores a copy of the body parser.
+        ParsableT const &body;
+    };
+
+    struct do_parser_gen
+    {
+        inline do_parser_gen() {}
+
+        template <typename ParsableT>
+        impl::do_while_parser_gen<ParsableT>
+        operator[](ParsableT const& body) const
+        {
+            return impl::do_while_parser_gen<ParsableT>(body);
+        }
+    };
+} // namespace impl
+
+//////////////////////////////////
+// while_p function, while-parser generator
+// Usage: spirit::while_p(Condition)[Body]
+template <typename CondT>
+impl::while_parser_gen<CondT>
+while_p(CondT const& cond)
+{
+    return impl::while_parser_gen<CondT>(cond);
+}
+
+//////////////////////////////////
+// do_p functor, do-while-parser generator
+// Usage: spirit::do_p[Body].while_p(Condition)
+impl::do_parser_gen const do_p = impl::do_parser_gen();
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace BOOST_SPIRIT_CLASSIC_NS
+
+#endif // BOOST_SPIRIT_WHILE_HPP