classic/debug/parser_names.hpp

0001 /*=============================================================================
0002     Copyright (c) 2001-2003 Joel de Guzman
0003     Copyright (c) 2002-2003 Hartmut Kaiser
0004     http://spirit.sourceforge.net/
0005
0006   Distributed under the Boost Software License, Version 1.0. (See accompanying
0007   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008 =============================================================================*/
0009 #if !defined(BOOST_SPIRIT_PARSER_NAMES_HPP)
0010 #define BOOST_SPIRIT_PARSER_NAMES_HPP
0011
0012 #if defined(BOOST_SPIRIT_DEBUG)
0013
0014 //////////////////////////////////
0015 #include <boost/spirit/home/classic/namespace.hpp>
0016 #include <boost/spirit/home/classic/core.hpp>
0017
0018 namespace boost { namespace spirit {
0019
0020 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
0021
0022 ///////////////////////////////////////////////////////////////////////////////
0023 //
0024 //  Declaration of helper functions, which return the name of a concrete
0025 //  parser instance. The functions are specialized on the parser types. The
0026 //  functions declared in this file are for the predefined parser types from
0027 //  the Spirit core library only, so additional functions might be provided as
0028 //  needed.
0029 //
0030 ///////////////////////////////////////////////////////////////////////////////
0031
0032 ///////////////////////////////////////////////////////////////////////////////
0033 //  from actions.hpp
0034     template <typename ParserT, typename ActionT>
0035     std::string
0036     parser_name(action<ParserT, ActionT> const& p);
0037
0038 ///////////////////////////////////////////////////////////////////////////////
0039 //  from directives.hpp
0040     template <typename ParserT>
0041     std::string
0042     parser_name(contiguous<ParserT> const& p);
0043
0044     template <typename ParserT>
0045     std::string
0046     parser_name(inhibit_case<ParserT> const& p);
0047
0048     template <typename A, typename B>
0049     std::string
0050     parser_name(longest_alternative<A, B> const& p);
0051
0052     template <typename A, typename B>
0053     std::string
0054     parser_name(shortest_alternative<A, B> const& p);
0055
0056 ///////////////////////////////////////////////////////////////////////////////
0057 //  from grammar.hpp
0058     template <typename DerivedT, typename ContextT>
0059     std::string
0060     parser_name(grammar<DerivedT, ContextT> const& p);
0061
0062 ///////////////////////////////////////////////////////////////////////////////
0063 //  from numerics.hpp
0064     template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
0065     std::string
0066     parser_name(uint_parser<T, Radix, MinDigits, MaxDigits> const& p);
0067
0068     template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
0069     std::string
0070     parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& p);
0071
0072     template <typename T, typename RealPoliciesT>
0073     std::string
0074     parser_name(real_parser<T, RealPoliciesT> const& p);
0075
0076 ///////////////////////////////////////////////////////////////////////////////
0077 //  from operators.hpp
0078     template <typename A, typename B>
0079     std::string
0080     parser_name(sequence<A, B> const& p);
0081
0082     template <typename A, typename B>
0083     std::string
0084     parser_name(sequential_or<A, B> const& p);
0085
0086     template <typename A, typename B>
0087     std::string
0088     parser_name(alternative<A, B> const& p);
0089
0090     template <typename A, typename B>
0091     std::string
0092     parser_name(intersection<A, B> const& p);
0093
0094     template <typename A, typename B>
0095     std::string
0096     parser_name(difference<A, B> const& p);
0097
0098     template <typename A, typename B>
0099     std::string
0100     parser_name(exclusive_or<A, B> const& p);
0101
0102     template <typename S>
0103     std::string
0104     parser_name(optional<S> const& p);
0105
0106     template <typename S>
0107     std::string
0108     parser_name(kleene_star<S> const& p);
0109
0110     template <typename S>
0111     std::string
0112     parser_name(positive<S> const& p);
0113
0114 ///////////////////////////////////////////////////////////////////////////////
0115 //  from parser.hpp
0116     template <typename DerivedT>
0117     std::string
0118     parser_name(parser<DerivedT> const& p);
0119
0120 ///////////////////////////////////////////////////////////////////////////////
0121 //  from primitives.hpp
0122     template <typename DerivedT>
0123     std::string
0124     parser_name(char_parser<DerivedT> const &p);
0125
0126     template <typename CharT>
0127     std::string
0128     parser_name(chlit<CharT> const &p);
0129
0130     template <typename CharT>
0131     std::string
0132     parser_name(range<CharT> const &p);
0133
0134     template <typename IteratorT>
0135     std::string
0136     parser_name(chseq<IteratorT> const &p);
0137
0138     template <typename IteratorT>
0139     std::string
0140     parser_name(strlit<IteratorT> const &p);
0141
0142     std::string
0143     parser_name(nothing_parser const &p);
0144
0145     std::string
0146     parser_name(epsilon_parser const &p);
0147
0148     std::string
0149     parser_name(anychar_parser const &p);
0150
0151     std::string
0152     parser_name(alnum_parser const &p);
0153
0154     std::string
0155     parser_name(alpha_parser const &p);
0156
0157     std::string
0158     parser_name(cntrl_parser const &p);
0159
0160     std::string
0161     parser_name(digit_parser const &p);
0162
0163     std::string
0164     parser_name(graph_parser const &p);
0165
0166     std::string
0167     parser_name(lower_parser const &p);
0168
0169     std::string
0170     parser_name(print_parser const &p);
0171
0172     std::string
0173     parser_name(punct_parser const &p);
0174
0175     std::string
0176     parser_name(blank_parser const &p);
0177
0178     std::string
0179     parser_name(space_parser const &p);
0180
0181     std::string
0182     parser_name(upper_parser const &p);
0183
0184     std::string
0185     parser_name(xdigit_parser const &p);
0186
0187     std::string
0188     parser_name(eol_parser const &p);
0189
0190     std::string
0191     parser_name(end_parser const &p);
0192
0193 ///////////////////////////////////////////////////////////////////////////////
0194 //  from rule.hpp
0195     template<typename T0, typename T1, typename T2>
0196     std::string
0197     parser_name(rule<T0, T1, T2> const& p);
0198
0199 ///////////////////////////////////////////////////////////////////////////////
0200 //  from subrule.hpp
0201     template <typename FirstT, typename RestT>
0202     std::string
0203     parser_name(subrule_list<FirstT, RestT> const &p);
0204
0205     template <int ID, typename DefT, typename ContextT>
0206     std::string
0207     parser_name(subrule_parser<ID, DefT, ContextT> const &p);
0208
0209     template <int ID, typename ContextT>
0210     std::string
0211     parser_name(subrule<ID, ContextT> const &p);
0212
0213 ///////////////////////////////////////////////////////////////////////////////
0214 //  from chset.hpp
0215
0216 ///////////////////////////////////////////////////////////////////////////////
0217 //
0218 //  Decide, if a node is to be traced or not
0219 //
0220 ///////////////////////////////////////////////////////////////////////////////
0221     template<
0222         typename DerivedT, typename EmbedT,
0223         typename T0, typename T1, typename T2
0224     >
0225     bool
0226     trace_parser(impl::rule_base<DerivedT, EmbedT, T0, T1, T2>
0227         const& p);
0228
0229     template <typename DerivedT, typename ContextT>
0230     bool
0231     trace_parser(grammar<DerivedT, ContextT> const& p);
0232
0233     template <int ID, typename ContextT>
0234     bool
0235     trace_parser(subrule<ID, ContextT> const& p);
0236
0237     template <typename ParserT, typename ActorTupleT>
0238     struct init_closure_parser;
0239
0240     template <typename ParserT, typename ActorTupleT>
0241     bool
0242     trace_parser(init_closure_parser<ParserT, ActorTupleT> const& p);
0243
0244 ///////////////////////////////////////////////////////////////////////////////
0245 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
0246
0247 }} // namespace BOOST_SPIRIT_CLASSIC_NS
0248
0249 //////////////////////////////////
0250 #include <boost/spirit/home/classic/debug/impl/parser_names.ipp>
0251
0252 #endif // defined(BOOST_SPIRIT_DEBUG)
0253
0254 #endif // !defined(BOOST_SPIRIT_PARSER_NAMES_HPP)