| /*============================================================================= |
| Copyright (c) 2010 Daniel James |
| Copyright (c) 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) |
| =============================================================================*/ |
| |
| // Used to parse an inner block, saves the streams and restores them if the |
| // parse fails. On success the action is passed the resulting block. |
| // |
| // Might be a good idea to do something more generic in the future. |
| // |
| // This is based on `boost::spirit::classic::scoped_lock` by Martin Wille |
| |
| #ifndef BOOST_QUICKBOOK_SCOPED_BLOCK_HPP |
| #define BOOST_QUICKBOOK_SCOPED_BLOCK_HPP |
| |
| #include <boost/spirit/home/classic/namespace.hpp> |
| #include <boost/spirit/home/classic/core/composite/composite.hpp> |
| #include "actions_class.hpp" |
| |
| namespace quickbook { |
| |
| namespace cl = boost::spirit::classic; |
| |
| struct scoped_block_push |
| { |
| typedef std::string attribute; |
| |
| scoped_block_push(quickbook::actions& actions) |
| : actions(actions) |
| { |
| actions.out.push(); |
| actions.phrase.push(); |
| } |
| |
| ~scoped_block_push() |
| { |
| actions.phrase.pop(); |
| actions.out.pop(); |
| } |
| |
| std::string const& finish() |
| { |
| actions.inside_paragraph(); |
| return actions.out.str(); |
| } |
| |
| quickbook::actions& actions; |
| }; |
| |
| template <typename ParserT> |
| struct scoped_block_parser |
| : public cl::unary< ParserT, cl::parser< scoped_block_parser<ParserT> > > |
| { |
| typedef scoped_block_parser<ParserT> self_t; |
| typedef cl::unary< ParserT, cl::parser< scoped_block_parser<ParserT> > > base_t; |
| |
| template <typename ScannerT> |
| struct result |
| { |
| typedef cl::match<std::string> type; |
| }; |
| |
| scoped_block_parser(quickbook::actions& a, ParserT const &p) |
| : base_t(p) |
| , actions(a) |
| {} |
| |
| template <typename ScannerT> |
| cl::match<std::string> parse(ScannerT const &scan) const |
| { |
| typedef typename ScannerT::iterator_t iterator_t; |
| iterator_t save = scan.first; |
| |
| scoped_block_push push(actions); |
| typename cl::parser_result<ParserT, ScannerT>::type result |
| = this->subject().parse(scan); |
| |
| if (result) |
| return scan.create_match(result.length(), push.finish(), save, scan.first); |
| else |
| return scan.no_match(); |
| } |
| |
| quickbook::actions& actions; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // scoped_block_parser_gen |
| // |
| // generator for scoped_block_parser objects |
| // operator[] returns scoped_block_parser according to its argument |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| struct scoped_block_parser_gen |
| { |
| explicit scoped_block_parser_gen(quickbook::actions& actions) |
| : actions(actions) {} |
| |
| template<typename ParserT> |
| scoped_block_parser |
| < |
| typename cl::as_parser<ParserT>::type |
| > |
| operator[](ParserT const &p) const |
| { |
| typedef cl::as_parser<ParserT> as_parser_t; |
| typedef typename as_parser_t::type parser_t; |
| |
| return scoped_block_parser<parser_t> |
| (actions, as_parser_t::convert(p)); |
| } |
| |
| quickbook::actions& actions; |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // scoped_block_d parser directive |
| // |
| // constructs a scoped_block_parser generator from its argument |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| inline scoped_block_parser_gen scoped_block(quickbook::actions& actions) { |
| return scoped_block_parser_gen(actions); |
| } |
| |
| } |
| #endif // BOOST_QUICKBOOK_SCOPED_BLOCK_HPP |
