text: /*=============================================================================
      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
  