Subject: [Boost-commit] svn:boost r68883 - branches/quickbook-filenames/tools/quickbook/src
From: dnljms_at_[hidden]
Date: 2011-02-14 19:20:53
Author: danieljames
Date: 2011-02-14 19:20:51 EST (Mon, 14 Feb 2011)
New Revision: 68883
URL: http://svn.boost.org/trac/boost/changeset/68883
Log:
Parser support for values.
Added:
branches/quickbook-filenames/tools/quickbook/src/values_parse.hpp (contents, props changed)
Added: branches/quickbook-filenames/tools/quickbook/src/values_parse.hpp
==============================================================================
--- (empty file)
+++ branches/quickbook-filenames/tools/quickbook/src/values_parse.hpp 2011-02-14 19:20:51 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,283 @@
+/*=============================================================================
+ Copyright (c) 2010-2011 Daniel James
+
+ Use, modification and distribution is subject to 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)
+=============================================================================*/
+
+#if !defined(BOOST_SPIRIT_QUICKBOOK_VALUES_PARSE_HPP)
+#define BOOST_SPIRIT_QUICKBOOK_VALUES_PARSE_HPP
+
+#include "values.hpp"
+#include <boost/spirit/include/classic_core.hpp>
+
+namespace quickbook {
+ namespace cl = boost::spirit::classic;
+
+ struct value_builder_save
+ {
+ value_builder_save(value_builder& a) : a(a) { a.save(); }
+ ~value_builder_save() { a.restore(); }
+ value_builder& a;
+ };
+
+ template <typename ParserT>
+ struct value_save_parser
+ : public cl::unary< ParserT, cl::parser< value_save_parser<ParserT> > >
+ {
+ typedef value_save_parser<ParserT> self_t;
+ typedef cl::unary< ParserT, cl::parser< value_save_parser<ParserT> > > base_t;
+
+ template <typename ScannerT>
+ struct result
+ {
+ typedef typename cl::parser_result<ParserT, ScannerT>::type type;
+ };
+
+ value_save_parser(value_builder& a, ParserT const &p)
+ : base_t(p)
+ , builder_(a)
+ {}
+
+ template <typename ScannerT>
+ typename result<ScannerT>::type parse(ScannerT const &scan) const
+ {
+ typedef typename ScannerT::iterator_t iterator_t;
+ iterator_t save = scan.first;
+
+ value_builder_save saver(builder_);
+
+ typename cl::parser_result<ParserT, ScannerT>::type result
+ = this->subject().parse(scan);
+
+ if (result) {
+ return scan.create_match(result.length(), cl::nil_t(), save, scan.first);
+ }
+ else {
+ return scan.no_match();
+ }
+ }
+
+ value_builder& builder_;
+ };
+
+ struct value_save_gen
+ {
+ explicit value_save_gen(value_builder& b)
+ : builder_(b) {}
+
+ template<typename ParserT>
+ value_save_parser<typename cl::as_parser<ParserT>::type>
+ operator[](ParserT const& p) const
+ {
+ typedef typename cl::as_parser<ParserT> as_parser_t;
+ typedef typename as_parser_t::type parser_t;
+
+ return value_save_parser<parser_t>
+ (builder_, as_parser_t::convert(p));
+ }
+
+ value_builder& builder_;
+ };
+
+ struct value_builder_list
+ {
+ value_builder_list(value_builder& a, value::tag_type t)
+ : a(a), finished(false) { a.start_list(t); }
+ void finish() { a.finish_list(); finished = true; }
+ ~value_builder_list() { if(!finished) a.clear_list(); }
+ value_builder& a;
+ bool finished;
+ };
+
+ template <typename ParserT>
+ struct value_scoped_list_parser
+ : public cl::unary< ParserT, cl::parser< value_scoped_list_parser<ParserT> > >
+ {
+ typedef value_scoped_list_parser<ParserT> self_t;
+ typedef cl::unary< ParserT, cl::parser< value_scoped_list_parser<ParserT> > > base_t;
+
+ template <typename ScannerT>
+ struct result
+ {
+ typedef typename cl::parser_result<ParserT, ScannerT>::type type;
+ };
+
+ value_scoped_list_parser(value_builder& a, value::tag_type k, ParserT const &p)
+ : base_t(p)
+ , builder_(a)
+ , tag_(k)
+ {}
+
+ template <typename ScannerT>
+ typename result<ScannerT>::type parse(ScannerT const &scan) const
+ {
+ typedef typename ScannerT::iterator_t iterator_t;
+ iterator_t save = scan.first;
+
+ value_builder_list list(builder_, tag_);
+ typename cl::parser_result<ParserT, ScannerT>::type result
+ = this->subject().parse(scan);
+
+ if (result) {
+ list.finish();
+ return scan.create_match(result.length(), cl::nil_t(), save, scan.first);
+ }
+ else {
+ return scan.no_match();
+ }
+ }
+
+ value_builder& builder_;
+ value::tag_type tag_;
+ };
+
+ struct value_scoped_list_gen
+ {
+ explicit value_scoped_list_gen(value_builder& b, value::tag_type t = value::no_tag)
+ : b(b), tag_(t) {}
+
+ template<typename ParserT>
+ value_scoped_list_parser<typename cl::as_parser<ParserT>::type>
+ operator[](ParserT const& p) const
+ {
+ typedef typename cl::as_parser<ParserT> as_parser_t;
+ typedef typename as_parser_t::type parser_t;
+
+ return value_scoped_list_parser<parser_t>
+ (b, tag_, as_parser_t::convert(p));
+ }
+
+ value_scoped_list_gen operator()(value::tag_type const& tag) const
+ {
+ return value_scoped_list_gen(b, tag);
+ }
+
+ value_builder& b;
+ value::tag_type tag_;
+ };
+
+ /* value_scoped_list_gen
+ */
+
+ struct value_string_entry {
+ value_string_entry(value_builder& b, std::string const& v, value::tag_type t = value::no_tag)
+ : b(b), v(v), tag_(t) {}
+
+ template <typename Iterator>
+ void operator()(Iterator, Iterator) const {
+ b.insert(bbk_value(v, tag_));
+ }
+
+ value_builder& b;
+ std::string v;
+ value::tag_type tag_;
+ };
+
+ struct value_entry
+ {
+ value_entry(value_builder& b, value::tag_type t = value::no_tag)
+ : b(b), tag_(t) {}
+
+ template <typename Iterator>
+ void operator()(Iterator begin, Iterator end) const {
+ b.insert(qbk_value(begin, end, tag_));
+ }
+
+ value_string_entry operator()(std::string const& value) {
+ return value_string_entry(b, value, tag_);
+ }
+
+ value_string_entry operator()(value::tag_type tag, std::string const& value) {
+ return value_string_entry(b, value, tag);
+ }
+
+ value_entry operator()(value::tag_type const& value) {
+ return value_entry(b, value);
+ }
+
+ value_builder& b;
+ value::tag_type tag_;
+ };
+
+ struct value_fixed_tag {
+ value_fixed_tag(value_builder& b, value::tag_type v)
+ : b(b), v(v) {}
+
+ template <typename Iterator>
+ void operator()(Iterator, Iterator) const {
+ b.set_tag(v);
+ }
+
+ value_builder& b;
+ value::tag_type v;
+ };
+
+ struct value_tag
+ {
+ value_tag(value_builder& b)
+ : b(b) {}
+
+ void operator()(value::tag_type value) const {
+ b.set_tag(value);
+ }
+
+ value_fixed_tag operator()(value::tag_type value) {
+ return value_fixed_tag(b, value);
+ }
+
+ value_builder& b;
+ };
+
+ struct value_reset
+ {
+ value_reset(value_builder& b)
+ : b(b) {}
+
+ template <typename Iterator>
+ void operator()(Iterator, Iterator) const {
+ b.reset();
+ }
+
+ value_builder& b;
+ };
+
+ struct value_sort
+ {
+ value_sort(value_builder& b)
+ : b(b) {}
+
+ template <typename Iterator>
+ void operator()(Iterator, Iterator) const {
+ b.sort_list();
+ }
+
+ value_builder& b;
+ };
+
+ struct value_parser
+ {
+ value_parser()
+ : builder()
+ , save(builder)
+ , reset(builder)
+ , scoped(builder)
+ , tag(builder)
+ , entry(builder)
+ , sort(builder)
+ {}
+
+ value get() { return builder.get(); }
+
+ value_builder builder;
+ value_save_gen save;
+ value_reset reset;
+ value_scoped_list_gen scoped;
+ value_tag tag;
+ value_entry entry;
+ value_sort sort;
+ };
+}
+
+#endif