| /*============================================================================= |
| Copyright (c) 2001-2003 Joel de Guzman |
| Copyright (c) 2002-2003 Hartmut Kaiser |
| http://spirit.sourceforge.net/ |
| |
| 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_PARSER_NAMES_IPP) |
| #define BOOST_SPIRIT_PARSER_NAMES_IPP |
| |
| #if defined(BOOST_SPIRIT_DEBUG) |
| |
| #include <string> |
| #include <iostream> |
| #include <map> |
| |
| #include <boost/config.hpp> |
| #ifdef BOOST_NO_STRINGSTREAM |
| #include <strstream> |
| #define BOOST_SPIRIT_SSTREAM std::strstream |
| std::string BOOST_SPIRIT_GETSTRING(std::strstream& ss) |
| { |
| ss << ends; |
| std::string rval = ss.str(); |
| ss.freeze(false); |
| return rval; |
| } |
| #else |
| #include <sstream> |
| #define BOOST_SPIRIT_GETSTRING(ss) ss.str() |
| #define BOOST_SPIRIT_SSTREAM std::stringstream |
| #endif |
| |
| namespace boost { namespace spirit { |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from actions.hpp |
| template <typename ParserT, typename ActionT> |
| inline std::string |
| parser_name(action<ParserT, ActionT> const& p) |
| { |
| return std::string("action") |
| + std::string("[") |
| + parser_name(p.subject()) |
| + std::string("]"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from directives.hpp |
| template <typename ParserT> |
| inline std::string |
| parser_name(contiguous<ParserT> const& p) |
| { |
| return std::string("contiguous") |
| + std::string("[") |
| + parser_name(p.subject()) |
| + std::string("]"); |
| } |
| |
| template <typename ParserT> |
| inline std::string |
| parser_name(inhibit_case<ParserT> const& p) |
| { |
| return std::string("inhibit_case") |
| + std::string("[") |
| + parser_name(p.subject()) |
| + std::string("]"); |
| } |
| |
| template <typename A, typename B> |
| inline std::string |
| parser_name(longest_alternative<A, B> const& p) |
| { |
| return std::string("longest_alternative") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| template <typename A, typename B> |
| inline std::string |
| parser_name(shortest_alternative<A, B> const& p) |
| { |
| return std::string("shortest_alternative") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from numerics.hpp |
| template <typename T, int Radix, unsigned MinDigits, int MaxDigits> |
| inline std::string |
| parser_name(uint_parser<T, Radix, MinDigits, MaxDigits> const& p) |
| { |
| BOOST_SPIRIT_SSTREAM stream; |
| stream << Radix << ", " << MinDigits << ", " << MaxDigits; |
| return std::string("uint_parser<") |
| + BOOST_SPIRIT_GETSTRING(stream) |
| + std::string(">"); |
| } |
| |
| template <typename T, int Radix, unsigned MinDigits, int MaxDigits> |
| inline std::string |
| parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& p) |
| { |
| BOOST_SPIRIT_SSTREAM stream; |
| stream << Radix << ", " << MinDigits << ", " << MaxDigits; |
| return std::string("int_parser<") |
| + BOOST_SPIRIT_GETSTRING(stream) |
| + std::string(">"); |
| } |
| |
| template <typename T, typename RealPoliciesT> |
| inline std::string |
| parser_name(real_parser<T, RealPoliciesT> const& p) |
| { |
| return std::string("real_parser"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from operators.hpp |
| template <typename A, typename B> |
| inline std::string |
| parser_name(sequence<A, B> const& p) |
| { |
| return std::string("sequence") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| template <typename A, typename B> |
| inline std::string |
| parser_name(sequential_or<A, B> const& p) |
| { |
| return std::string("sequential_or") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| template <typename A, typename B> |
| inline std::string |
| parser_name(alternative<A, B> const& p) |
| { |
| return std::string("alternative") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| template <typename A, typename B> |
| inline std::string |
| parser_name(intersection<A, B> const& p) |
| { |
| return std::string("intersection") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| template <typename A, typename B> |
| inline std::string |
| parser_name(difference<A, B> const& p) |
| { |
| return std::string("difference") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| template <typename A, typename B> |
| inline std::string |
| parser_name(exclusive_or<A, B> const& p) |
| { |
| return std::string("exclusive_or") |
| + std::string("[") |
| + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) |
| + std::string("]"); |
| } |
| |
| template <typename S> |
| inline std::string |
| parser_name(optional<S> const& p) |
| { |
| return std::string("optional") |
| + std::string("[") |
| + parser_name(p.subject()) |
| + std::string("]"); |
| } |
| |
| template <typename S> |
| inline std::string |
| parser_name(kleene_star<S> const& p) |
| { |
| return std::string("kleene_star") |
| + std::string("[") |
| + parser_name(p.subject()) |
| + std::string("]"); |
| } |
| |
| template <typename S> |
| inline std::string |
| parser_name(positive<S> const& p) |
| { |
| return std::string("positive") |
| + std::string("[") |
| + parser_name(p.subject()) |
| + std::string("]"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from parser.hpp |
| template <typename DerivedT> |
| inline std::string |
| parser_name(parser<DerivedT> const& p) |
| { |
| return std::string("parser"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from primitives.hpp |
| template <typename DerivedT> |
| inline std::string |
| parser_name(char_parser<DerivedT> const &p) |
| { |
| return std::string("char_parser"); |
| } |
| |
| template <typename CharT> |
| inline std::string |
| parser_name(chlit<CharT> const &p) |
| { |
| return std::string("chlit(\'") |
| + std::string(1, p.ch) |
| + std::string("\')"); |
| } |
| |
| template <typename CharT> |
| inline std::string |
| parser_name(range<CharT> const &p) |
| { |
| return std::string("range(") |
| + std::string(1, p.first) + std::string(", ") + std::string(1, p.last) |
| + std::string(")"); |
| } |
| |
| template <typename IteratorT> |
| inline std::string |
| parser_name(chseq<IteratorT> const &p) |
| { |
| return std::string("chseq(\"") |
| + std::string(p.first, p.last) |
| + std::string("\")"); |
| } |
| |
| template <typename IteratorT> |
| inline std::string |
| parser_name(strlit<IteratorT> const &p) |
| { |
| return std::string("strlit(\"") |
| + std::string(p.seq.first, p.seq.last) |
| + std::string("\")"); |
| } |
| |
| inline std::string |
| parser_name(nothing_parser const&) |
| { |
| return std::string("nothing"); |
| } |
| |
| inline std::string |
| parser_name(epsilon_parser const&) |
| { |
| return std::string("epsilon"); |
| } |
| |
| inline std::string |
| parser_name(anychar_parser const&) |
| { |
| return std::string("anychar"); |
| } |
| |
| inline std::string |
| parser_name(alnum_parser const&) |
| { |
| return std::string("alnum"); |
| } |
| |
| inline std::string |
| parser_name(alpha_parser const&) |
| { |
| return std::string("alpha"); |
| } |
| |
| inline std::string |
| parser_name(cntrl_parser const&) |
| { |
| return std::string("cntrl"); |
| } |
| |
| inline std::string |
| parser_name(digit_parser const&) |
| { |
| return std::string("digit"); |
| } |
| |
| inline std::string |
| parser_name(graph_parser const&) |
| { |
| return std::string("graph"); |
| } |
| |
| inline std::string |
| parser_name(lower_parser const&) |
| { |
| return std::string("lower"); |
| } |
| |
| inline std::string |
| parser_name(print_parser const&) |
| { |
| return std::string("print"); |
| } |
| |
| inline std::string |
| parser_name(punct_parser const&) |
| { |
| return std::string("punct"); |
| } |
| |
| inline std::string |
| parser_name(blank_parser const&) |
| { |
| return std::string("blank"); |
| } |
| |
| inline std::string |
| parser_name(space_parser const&) |
| { |
| return std::string("space"); |
| } |
| |
| inline std::string |
| parser_name(upper_parser const&) |
| { |
| return std::string("upper"); |
| } |
| |
| inline std::string |
| parser_name(xdigit_parser const&) |
| { |
| return std::string("xdigit"); |
| } |
| |
| inline std::string |
| parser_name(eol_parser const&) |
| { |
| return std::string("eol"); |
| } |
| |
| inline std::string |
| parser_name(end_parser const&) |
| { |
| return std::string("end"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from rule.hpp |
| namespace impl { |
| struct node_registry |
| { |
| typedef std::pair<std::string, bool> rule_info; |
| typedef std::map<void const *, rule_info> rule_infos; |
| |
| std::string find_node(void const *r) |
| { |
| rule_infos::const_iterator cit = infos.find(r); |
| if (cit != infos.end()) |
| return (*cit).second.first; |
| return std::string("<unknown>"); |
| } |
| |
| bool trace_node(void const *r) |
| { |
| rule_infos::const_iterator cit = infos.find(r); |
| if (cit != infos.end()) |
| return (*cit).second.second; |
| return BOOST_SPIRIT_DEBUG_TRACENODE; |
| } |
| |
| bool register_node(void const *r, char const *name_to_register, |
| bool trace_node) |
| { |
| if (infos.find(r) != infos.end()) |
| return false; |
| |
| return infos.insert(rule_infos::value_type(r, |
| rule_info(std::string(name_to_register), trace_node)) |
| ).second; |
| } |
| |
| bool unregister_node(void const *r) |
| { |
| if (infos.find(r) == infos.end()) |
| return false; |
| return (1 == infos.erase(r)); |
| } |
| |
| private: |
| rule_infos infos; |
| }; |
| |
| inline node_registry & |
| get_node_registry() |
| { |
| static node_registry node_infos; |
| return node_infos; |
| } |
| } // namespace impl |
| |
| template< |
| typename DerivedT, typename EmbedT, |
| typename T0, typename T1, typename T2 |
| > |
| inline std::string |
| parser_name(impl::rule_base<DerivedT, EmbedT, T0, T1, T2> const& p) |
| { |
| return std::string("rule_base") |
| + std::string("(") |
| + impl::get_node_registry().find_node(&p) |
| + std::string(")"); |
| } |
| |
| template<typename T0, typename T1, typename T2> |
| inline std::string |
| parser_name(rule<T0, T1, T2> const& p) |
| { |
| return std::string("rule") |
| + std::string("(") |
| + impl::get_node_registry().find_node(&p) |
| + std::string(")"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from subrule.hpp |
| template <typename FirstT, typename RestT> |
| inline std::string |
| parser_name(subrule_list<FirstT, RestT> const &p) |
| { |
| return std::string("subrule_list") |
| + std::string("(") |
| + impl::get_node_registry().find_node(&p) |
| + std::string(")"); |
| } |
| |
| template <int ID, typename DefT, typename ContextT> |
| inline std::string |
| parser_name(subrule_parser<ID, DefT, ContextT> const &p) |
| { |
| return std::string("subrule_parser") |
| + std::string("(") |
| + impl::get_node_registry().find_node(&p) |
| + std::string(")"); |
| } |
| |
| template <int ID, typename ContextT> |
| inline std::string |
| parser_name(subrule<ID, ContextT> const &p) |
| { |
| BOOST_SPIRIT_SSTREAM stream; |
| stream << ID; |
| return std::string("subrule<") |
| + BOOST_SPIRIT_GETSTRING(stream) |
| + std::string(">(") |
| + impl::get_node_registry().find_node(&p) |
| + std::string(")"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // from grammar.hpp |
| template <typename DerivedT, typename ContextT> |
| inline std::string |
| parser_name(grammar<DerivedT, ContextT> const& p) |
| { |
| return std::string("grammar") |
| + std::string("(") |
| + impl::get_node_registry().find_node(&p) |
| + std::string(")"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // decide, if a node is to be traced or not |
| template< |
| typename DerivedT, typename EmbedT, |
| typename T0, typename T1, typename T2 |
| > |
| inline bool |
| trace_parser(impl::rule_base<DerivedT, EmbedT, T0, T1, T2> |
| const& p) |
| { |
| return impl::get_node_registry().trace_node(&p); |
| } |
| |
| template<typename T0, typename T1, typename T2> |
| inline bool |
| trace_parser(rule<T0, T1, T2> const& p) |
| { |
| return impl::get_node_registry().trace_node(&p); |
| } |
| |
| template <typename DerivedT, typename ContextT> |
| inline bool |
| trace_parser(grammar<DerivedT, ContextT> const& p) |
| { |
| return impl::get_node_registry().trace_node(&p); |
| } |
| |
| template <typename DerivedT, int N, typename ContextT> |
| inline bool |
| trace_parser(impl::entry_grammar<DerivedT, N, ContextT> const& p) |
| { |
| return impl::get_node_registry().trace_node(&p); |
| } |
| |
| template <int ID, typename ContextT> |
| bool |
| trace_parser(subrule<ID, ContextT> const& p) |
| { |
| return impl::get_node_registry().trace_node(&p); |
| } |
| |
| template <typename ParserT, typename ActorTupleT> |
| bool |
| trace_parser(init_closure_parser<ParserT, ActorTupleT> const& p) |
| { |
| return impl::get_node_registry().trace_node(&p); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END |
| |
| }} // namespace boost::spirit |
| |
| #undef BOOST_SPIRIT_SSTREAM |
| #undef BOOST_SPIRIT_GETSTRING |
| |
| #endif // defined(BOOST_SPIRIT_DEBUG) |
| |
| #endif // !defined(BOOST_SPIRIT_PARSER_NAMES_IPP) |