556 lines
16 KiB
Plaintext
556 lines
16 KiB
Plaintext
/*=============================================================================
|
|
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)
|