123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222 |
- /*=============================================================================
- Copyright (c) 2001-2010 Joel de Guzman
- Copyright (c) 2001-2010 Hartmut Kaiser
- 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)
- =============================================================================*/
- ///////////////////////////////////////////////////////////////////////////////
- //
- // A mini XML-like parser, Karma is used to print out the generated AST
- //
- // [ JDG March 25, 2007 ] spirit2
- // [ HK April 02, 2007 ] spirit2
- //
- ///////////////////////////////////////////////////////////////////////////////
- #include <boost/config/warning_disable.hpp>
- #include <boost/spirit/include/qi.hpp>
- #include <boost/spirit/include/karma.hpp>
- #include <boost/spirit/include/phoenix_core.hpp>
- #include <boost/spirit/include/phoenix_operator.hpp>
- #include <boost/spirit/include/phoenix_fusion.hpp>
- #include <boost/spirit/include/phoenix_function.hpp>
- #include <boost/spirit/include/phoenix_stl.hpp>
- #include <boost/fusion/include/adapt_struct.hpp>
- #include <boost/variant/recursive_variant.hpp>
- #include <iostream>
- #include <fstream>
- #include <string>
- #include <vector>
- using namespace boost::spirit;
- using namespace boost::spirit::ascii;
- namespace fusion = boost::fusion;
- namespace phoenix = boost::phoenix;
- using phoenix::at_c;
- using phoenix::push_back;
- ///////////////////////////////////////////////////////////////////////////////
- // Our mini XML tree representation
- ///////////////////////////////////////////////////////////////////////////////
- struct mini_xml;
- typedef
- boost::variant<
- boost::recursive_wrapper<mini_xml>
- , std::string
- >
- mini_xml_node;
- struct mini_xml
- {
- std::string name; // tag name
- std::vector<mini_xml_node> children; // children
- };
- // We need to tell fusion about our mini_xml struct
- // to make it a first-class fusion citizen
- BOOST_FUSION_ADAPT_STRUCT(
- mini_xml,
- (std::string, name)
- (std::vector<mini_xml_node>, children)
- )
- ///////////////////////////////////////////////////////////////////////////////
- // Our mini XML grammar definition
- ///////////////////////////////////////////////////////////////////////////////
- template <typename Iterator>
- struct mini_xml_parser :
- qi::grammar<Iterator, mini_xml(), space_type>
- {
- mini_xml_parser() : mini_xml_parser::base_type(xml)
- {
- text = lexeme[+(char_ - '<') [_val += _1]];
- node = (xml | text) [_val = _1];
- start_tag =
- '<'
- >> !lit('/')
- >> lexeme[+(char_ - '>') [_val += _1]]
- >> '>'
- ;
- end_tag =
- "</"
- >> lit(_r1)
- >> '>'
- ;
- xml =
- start_tag [at_c<0>(_val) = _1]
- >> *node [push_back(at_c<1>(_val), _1)]
- >> end_tag(at_c<0>(_val))
- ;
- }
- qi::rule<Iterator, mini_xml(), space_type> xml;
- qi::rule<Iterator, mini_xml_node(), space_type> node;
- qi::rule<Iterator, std::string(), space_type> text;
- qi::rule<Iterator, std::string(), space_type> start_tag;
- qi::rule<Iterator, void(std::string), space_type> end_tag;
- };
- ///////////////////////////////////////////////////////////////////////////////
- // A couple of phoenix functions helping to access the elements of the
- // generated AST
- ///////////////////////////////////////////////////////////////////////////////
- template <typename T>
- struct get_element
- {
- template <typename T1>
- struct result { typedef T const& type; };
- T const& operator()(mini_xml_node const& node) const
- {
- return boost::get<T>(node);
- }
- };
- phoenix::function<get_element<std::string> > _string;
- phoenix::function<get_element<mini_xml> > _xml;
- ///////////////////////////////////////////////////////////////////////////////
- // The output grammar defining the format of the generated data
- ///////////////////////////////////////////////////////////////////////////////
- template <typename OutputIterator>
- struct mini_xml_generator
- : karma::grammar<OutputIterator, mini_xml()>
- {
- mini_xml_generator() : mini_xml_generator::base_type(xml)
- {
- node %= string | xml;
- xml =
- '<' << string[_1 = at_c<0>(_val)] << '>'
- << (*node)[_1 = at_c<1>(_val)]
- << "</" << string[_1 = at_c<0>(_val)] << '>'
- ;
- }
- karma::rule<OutputIterator, mini_xml()> xml;
- karma::rule<OutputIterator, mini_xml_node()> node;
- };
- ///////////////////////////////////////////////////////////////////////////////
- // Main program
- ///////////////////////////////////////////////////////////////////////////////
- int main(int argc, char **argv)
- {
- char const* filename;
- if (argc > 1)
- {
- filename = argv[1];
- }
- else
- {
- std::cerr << "Error: No input file provided." << std::endl;
- return 1;
- }
- std::ifstream in(filename, std::ios_base::in);
- if (!in)
- {
- std::cerr << "Error: Could not open input file: "
- << filename << std::endl;
- return 1;
- }
- std::string storage; // We will read the contents here.
- in.unsetf(std::ios::skipws); // No white space skipping!
- std::copy(
- std::istream_iterator<char>(in),
- std::istream_iterator<char>(),
- std::back_inserter(storage));
- typedef mini_xml_parser<std::string::const_iterator> mini_xml_parser;
- mini_xml_parser xmlin; // Our grammar definition
- mini_xml ast; // our tree
- std::string::const_iterator iter = storage.begin();
- std::string::const_iterator end = storage.end();
- bool r = qi::phrase_parse(iter, end, xmlin, space, ast);
- if (r && iter == end)
- {
- std::cout << "-------------------------\n";
- std::cout << "Parsing succeeded\n";
- std::cout << "-------------------------\n";
- typedef std::back_insert_iterator<std::string> outiter_type;
- typedef mini_xml_generator<outiter_type> mini_xml_generator;
- mini_xml_generator xmlout; // Our grammar definition
- std::string generated;
- outiter_type outit(generated);
- bool r = karma::generate(outit, xmlout, ast);
- if (r)
- std::cout << generated << std::endl;
- return 0;
- }
- else
- {
- std::string::const_iterator begin = storage.begin();
- std::size_t dist = std::distance(begin, iter);
- std::string::const_iterator some =
- iter + (std::min)(storage.size()-dist, std::size_t(30));
- std::string context(iter, some);
- std::cout << "-------------------------\n";
- std::cout << "Parsing failed\n";
- std::cout << "stopped at: \": " << context << "...\"\n";
- std::cout << "-------------------------\n";
- return 1;
- }
- }
|