FM / impl

/usr/include/boost/spirit/home/classic/debug/impl/

/usr/include/boost/spirit/home/classic/debug/impl

Name	Size	Mode	Actions
parser_names.ipp	15336	0644	edit dl rm

Edit: /usr/include/boost/spirit/home/classic/debug/impl/parser_names.ipp (15336B)

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)

/*============================================================================= 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 #include #include #include #ifdef BOOST_NO_STRINGSTREAM #include #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 #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 inline std::string parser_name(action const& p) { return std::string("action") + std::string("[") + parser_name(p.subject()) + std::string("]"); } /////////////////////////////////////////////////////////////////////////////// // from directives.hpp template inline std::string parser_name(contiguous const& p) { return std::string("contiguous") + std::string("[") + parser_name(p.subject()) + std::string("]"); } template inline std::string parser_name(inhibit_case const& p) { return std::string("inhibit_case") + std::string("[") + parser_name(p.subject()) + std::string("]"); } template inline std::string parser_name(longest_alternative const& p) { return std::string("longest_alternative") + std::string("[") + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) + std::string("]"); } template inline std::string parser_name(shortest_alternative 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 inline std::string parser_name(uint_parser const& /*p*/) { BOOST_SPIRIT_SSTREAM stream; stream << Radix << ", " << MinDigits << ", " << MaxDigits; return std::string("uint_parser<") + BOOST_SPIRIT_GETSTRING(stream) + std::string(">"); } template inline std::string parser_name(int_parser const& /*p*/) { BOOST_SPIRIT_SSTREAM stream; stream << Radix << ", " << MinDigits << ", " << MaxDigits; return std::string("int_parser<") + BOOST_SPIRIT_GETSTRING(stream) + std::string(">"); } template inline std::string parser_name(real_parser const& /*p*/) { return std::string("real_parser"); } /////////////////////////////////////////////////////////////////////////////// // from operators.hpp template inline std::string parser_name(sequence const& p) { return std::string("sequence") + std::string("[") + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) + std::string("]"); } template inline std::string parser_name(sequential_or const& p) { return std::string("sequential_or") + std::string("[") + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) + std::string("]"); } template inline std::string parser_name(alternative const& p) { return std::string("alternative") + std::string("[") + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) + std::string("]"); } template inline std::string parser_name(intersection const& p) { return std::string("intersection") + std::string("[") + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) + std::string("]"); } template inline std::string parser_name(difference const& p) { return std::string("difference") + std::string("[") + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) + std::string("]"); } template inline std::string parser_name(exclusive_or const& p) { return std::string("exclusive_or") + std::string("[") + parser_name(p.left()) + std::string(", ") + parser_name(p.right()) + std::string("]"); } template inline std::string parser_name(optional const& p) { return std::string("optional") + std::string("[") + parser_name(p.subject()) + std::string("]"); } template inline std::string parser_name(kleene_star const& p) { return std::string("kleene_star") + std::string("[") + parser_name(p.subject()) + std::string("]"); } template inline std::string parser_name(positive const& p) { return std::string("positive") + std::string("[") + parser_name(p.subject()) + std::string("]"); } /////////////////////////////////////////////////////////////////////////////// // from parser.hpp template inline std::string parser_name(parser const& /*p*/) { return std::string("parser"); } /////////////////////////////////////////////////////////////////////////////// // from primitives.hpp template inline std::string parser_name(char_parser const &/*p*/) { return std::string("char_parser"); } template inline std::string parser_name(chlit const &p) { return std::string("chlit(\'") + std::string(1, p.ch) + std::string("\')"); } template inline std::string parser_name(range const &p) { return std::string("range(") + std::string(1, p.first) + std::string(", ") + std::string(1, p.last) + std::string(")"); } template inline std::string parser_name(chseq const &p) { return std::string("chseq(\"") + std::string(p.first, p.last) + std::string("\")"); } template inline std::string parser_name(strlit 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 rule_info; typedef std::map 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(""); } 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 const& p) { return std::string("rule_base") + std::string("(") + impl::get_node_registry().find_node(&p) + std::string(")"); } template inline std::string parser_name(rule const& p) { return std::string("rule") + std::string("(") + impl::get_node_registry().find_node(&p) + std::string(")"); } /////////////////////////////////////////////////////////////////////////////// // from subrule.hpp template inline std::string parser_name(subrule_list const &p) { return std::string("subrule_list") + std::string("(") + impl::get_node_registry().find_node(&p) + std::string(")"); } template inline std::string parser_name(subrule_parser const &p) { return std::string("subrule_parser") + std::string("(") + impl::get_node_registry().find_node(&p) + std::string(")"); } template inline std::string parser_name(subrule 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 inline std::string parser_name(grammar 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 const& p) { return impl::get_node_registry().trace_node(&p); } template inline bool trace_parser(rule const& p) { return impl::get_node_registry().trace_node(&p); } template inline bool trace_parser(grammar const& p) { return impl::get_node_registry().trace_node(&p); } template inline bool trace_parser(impl::entry_grammar const& p) { return impl::get_node_registry().trace_node(&p); } template bool trace_parser(subrule const& p) { return impl::get_node_registry().trace_node(&p); } template bool trace_parser(init_closure_parser 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)