/Src/Dependencies/Boost/boost/spirit/home/classic/debug/impl/parser_names.ipp

  1/*=============================================================================
  2    Copyright (c) 2001-2003 Joel de Guzman
  3    Copyright (c) 2002-2003 Hartmut Kaiser
  4    http://spirit.sourceforge.net/
  5
  6    Use, modification and distribution is subject to the Boost Software
  7    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  8    http://www.boost.org/LICENSE_1_0.txt)
  9=============================================================================*/
 10#if !defined(BOOST_SPIRIT_PARSER_NAMES_IPP)
 11#define BOOST_SPIRIT_PARSER_NAMES_IPP
 12
 13#if defined(BOOST_SPIRIT_DEBUG)
 14
 15#include <string>
 16#include <iostream>
 17#include <map>
 18
 19#include <boost/config.hpp>
 20#ifdef BOOST_NO_STRINGSTREAM
 21#include <strstream>
 22#define BOOST_SPIRIT_SSTREAM std::strstream
 23std::string BOOST_SPIRIT_GETSTRING(std::strstream& ss)
 24{
 25    ss << ends;
 26    std::string rval = ss.str();
 27    ss.freeze(false);
 28    return rval;
 29}
 30#else
 31#include <sstream>
 32#define BOOST_SPIRIT_GETSTRING(ss) ss.str()
 33#define BOOST_SPIRIT_SSTREAM std::stringstream
 34#endif
 35
 36namespace boost { namespace spirit {
 37
 38BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 39
 40///////////////////////////////////////////////////////////////////////////////
 41//  from actions.hpp
 42    template <typename ParserT, typename ActionT>
 43    inline std::string
 44    parser_name(action<ParserT, ActionT> const& p)
 45    {
 46        return std::string("action")
 47            + std::string("[")
 48            + parser_name(p.subject())
 49            + std::string("]");
 50    }
 51
 52///////////////////////////////////////////////////////////////////////////////
 53//  from directives.hpp
 54    template <typename ParserT>
 55    inline std::string
 56    parser_name(contiguous<ParserT> const& p)
 57    {
 58        return std::string("contiguous")
 59            + std::string("[")
 60            + parser_name(p.subject())
 61            + std::string("]");
 62    }
 63
 64    template <typename ParserT>
 65    inline std::string
 66    parser_name(inhibit_case<ParserT> const& p)
 67    {
 68        return std::string("inhibit_case")
 69            + std::string("[")
 70            + parser_name(p.subject())
 71            + std::string("]");
 72    }
 73
 74    template <typename A, typename B>
 75    inline std::string
 76    parser_name(longest_alternative<A, B> const& p)
 77    {
 78        return std::string("longest_alternative")
 79            + std::string("[")
 80            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
 81            + std::string("]");
 82    }
 83
 84    template <typename A, typename B>
 85    inline std::string
 86    parser_name(shortest_alternative<A, B> const& p)
 87    {
 88        return std::string("shortest_alternative")
 89            + std::string("[")
 90            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
 91            + std::string("]");
 92    }
 93
 94///////////////////////////////////////////////////////////////////////////////
 95//  from numerics.hpp
 96    template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
 97    inline std::string
 98    parser_name(uint_parser<T, Radix, MinDigits, MaxDigits> const& p)
 99    {
100        BOOST_SPIRIT_SSTREAM stream;
101        stream << Radix << ", " << MinDigits << ", " << MaxDigits;
102        return std::string("uint_parser<")
103            + BOOST_SPIRIT_GETSTRING(stream)
104            + std::string(">");
105    }
106
107    template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
108    inline std::string
109    parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& p)
110    {
111        BOOST_SPIRIT_SSTREAM stream;
112        stream << Radix << ", " << MinDigits << ", " << MaxDigits;
113        return std::string("int_parser<")
114            + BOOST_SPIRIT_GETSTRING(stream)
115            + std::string(">");
116    }
117
118    template <typename T, typename RealPoliciesT>
119    inline std::string
120    parser_name(real_parser<T, RealPoliciesT> const& p)
121    {
122        return std::string("real_parser");
123    }
124
125///////////////////////////////////////////////////////////////////////////////
126//  from operators.hpp
127    template <typename A, typename B>
128    inline std::string
129    parser_name(sequence<A, B> const& p)
130    {
131        return std::string("sequence")
132            + std::string("[")
133            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
134            + std::string("]");
135    }
136
137    template <typename A, typename B>
138    inline std::string
139    parser_name(sequential_or<A, B> const& p)
140    {
141        return std::string("sequential_or")
142            + std::string("[")
143            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
144            + std::string("]");
145    }
146
147    template <typename A, typename B>
148    inline std::string
149    parser_name(alternative<A, B> const& p)
150    {
151        return std::string("alternative")
152            + std::string("[")
153            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
154            + std::string("]");
155    }
156
157    template <typename A, typename B>
158    inline std::string
159    parser_name(intersection<A, B> const& p)
160    {
161        return std::string("intersection")
162            + std::string("[")
163            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
164            + std::string("]");
165    }
166
167    template <typename A, typename B>
168    inline std::string
169    parser_name(difference<A, B> const& p)
170    {
171        return std::string("difference")
172            + std::string("[")
173            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
174            + std::string("]");
175    }
176
177    template <typename A, typename B>
178    inline std::string
179    parser_name(exclusive_or<A, B> const& p)
180    {
181        return std::string("exclusive_or")
182            + std::string("[")
183            + parser_name(p.left()) + std::string(", ") + parser_name(p.right())
184            + std::string("]");
185    }
186
187    template <typename S>
188    inline std::string
189    parser_name(optional<S> const& p)
190    {
191        return std::string("optional")
192            + std::string("[")
193            + parser_name(p.subject())
194            + std::string("]");
195    }
196
197    template <typename S>
198    inline std::string
199    parser_name(kleene_star<S> const& p)
200    {
201        return std::string("kleene_star")
202            + std::string("[")
203            + parser_name(p.subject())
204            + std::string("]");
205    }
206
207    template <typename S>
208    inline std::string
209    parser_name(positive<S> const& p)
210    {
211        return std::string("positive")
212            + std::string("[")
213            + parser_name(p.subject())
214            + std::string("]");
215    }
216
217///////////////////////////////////////////////////////////////////////////////
218//  from parser.hpp
219    template <typename DerivedT>
220    inline std::string
221    parser_name(parser<DerivedT> const& p)
222    {
223        return std::string("parser");
224    }
225
226///////////////////////////////////////////////////////////////////////////////
227//  from primitives.hpp
228    template <typename DerivedT>
229    inline std::string
230    parser_name(char_parser<DerivedT> const &p)
231    {
232        return std::string("char_parser");
233    }
234
235    template <typename CharT>
236    inline std::string
237    parser_name(chlit<CharT> const &p)
238    {
239        return std::string("chlit(\'")
240            + std::string(1, p.ch)
241            + std::string("\')");
242    }
243
244    template <typename CharT>
245    inline std::string
246    parser_name(range<CharT> const &p)
247    {
248        return std::string("range(")
249            + std::string(1, p.first) + std::string(", ") + std::string(1, p.last)
250            + std::string(")");
251    }
252
253    template <typename IteratorT>
254    inline std::string
255    parser_name(chseq<IteratorT> const &p)
256    {
257        return std::string("chseq(\"")
258            + std::string(p.first, p.last)
259            + std::string("\")");
260    }
261
262    template <typename IteratorT>
263    inline std::string
264    parser_name(strlit<IteratorT> const &p)
265    {
266        return std::string("strlit(\"")
267            + std::string(p.seq.first, p.seq.last)
268            + std::string("\")");
269    }
270
271    inline std::string
272    parser_name(nothing_parser const&)
273    {
274        return std::string("nothing");
275    }
276
277    inline std::string
278    parser_name(epsilon_parser const&)
279    {
280        return std::string("epsilon");
281    }
282
283    inline std::string
284    parser_name(anychar_parser const&)
285    {
286        return std::string("anychar");
287    }
288
289    inline std::string
290    parser_name(alnum_parser const&)
291    {
292        return std::string("alnum");
293    }
294
295    inline std::string
296    parser_name(alpha_parser const&)
297    {
298        return std::string("alpha");
299    }
300
301    inline std::string
302    parser_name(cntrl_parser const&)
303    {
304        return std::string("cntrl");
305    }
306
307    inline std::string
308    parser_name(digit_parser const&)
309    {
310        return std::string("digit");
311    }
312
313    inline std::string
314    parser_name(graph_parser const&)
315    {
316        return std::string("graph");
317    }
318
319    inline std::string
320    parser_name(lower_parser const&)
321    {
322        return std::string("lower");
323    }
324
325    inline std::string
326    parser_name(print_parser const&)
327    {
328        return std::string("print");
329    }
330
331    inline std::string
332    parser_name(punct_parser const&)
333    {
334        return std::string("punct");
335    }
336
337    inline std::string
338    parser_name(blank_parser const&)
339    {
340        return std::string("blank");
341    }
342
343    inline std::string
344    parser_name(space_parser const&)
345    {
346        return std::string("space");
347    }
348
349    inline std::string
350    parser_name(upper_parser const&)
351    {
352        return std::string("upper");
353    }
354
355    inline std::string
356    parser_name(xdigit_parser const&)
357    {
358        return std::string("xdigit");
359    }
360
361    inline std::string
362    parser_name(eol_parser const&)
363    {
364        return std::string("eol");
365    }
366
367    inline std::string
368    parser_name(end_parser const&)
369    {
370        return std::string("end");
371    }
372
373///////////////////////////////////////////////////////////////////////////////
374//  from rule.hpp
375    namespace impl {
376        struct node_registry
377        {
378            typedef std::pair<std::string, bool> rule_info;
379            typedef std::map<void const *, rule_info> rule_infos;
380
381            std::string find_node(void const *r)
382            {
383                rule_infos::const_iterator cit = infos.find(r);
384                if (cit != infos.end())
385                    return (*cit).second.first;
386                return std::string("<unknown>");
387            }
388
389            bool trace_node(void const *r)
390            {
391                rule_infos::const_iterator cit = infos.find(r);
392                if (cit != infos.end())
393                    return (*cit).second.second;
394                return BOOST_SPIRIT_DEBUG_TRACENODE;
395            }
396
397            bool register_node(void const *r, char const *name_to_register,
398                bool trace_node)
399            {
400                if (infos.find(r) != infos.end())
401                    return false;
402
403                return infos.insert(rule_infos::value_type(r,
404                    rule_info(std::string(name_to_register), trace_node))
405                ).second;
406            }
407
408            bool unregister_node(void const *r)
409            {
410                if (infos.find(r) == infos.end())
411                    return false;
412                return (1 == infos.erase(r));
413            }
414
415        private:
416            rule_infos infos;
417        };
418
419        inline node_registry &
420        get_node_registry()
421        {
422            static node_registry node_infos;
423            return node_infos;
424        }
425    }   // namespace impl
426
427    template<
428        typename DerivedT, typename EmbedT, 
429        typename T0, typename T1, typename T2
430    >
431    inline std::string
432    parser_name(impl::rule_base<DerivedT, EmbedT, T0, T1, T2> const& p)
433    {
434        return std::string("rule_base")
435            + std::string("(")
436            + impl::get_node_registry().find_node(&p)
437            + std::string(")");
438    }
439
440    template<typename T0, typename T1, typename T2>
441    inline std::string
442    parser_name(rule<T0, T1, T2> const& p)
443    {
444        return std::string("rule")
445            + std::string("(")
446            + impl::get_node_registry().find_node(&p)
447            + std::string(")");
448    }
449
450///////////////////////////////////////////////////////////////////////////////
451//  from subrule.hpp
452    template <typename FirstT, typename RestT>
453    inline std::string
454    parser_name(subrule_list<FirstT, RestT> const &p)
455    {
456        return std::string("subrule_list")
457            + std::string("(")
458            + impl::get_node_registry().find_node(&p)
459            + std::string(")");
460    }
461
462    template <int ID, typename DefT, typename ContextT>
463    inline std::string
464    parser_name(subrule_parser<ID, DefT, ContextT> const &p)
465    {
466        return std::string("subrule_parser")
467            + std::string("(")
468            + impl::get_node_registry().find_node(&p)
469            + std::string(")");
470    }
471
472    template <int ID, typename ContextT>
473    inline std::string
474    parser_name(subrule<ID, ContextT> const &p)
475    {
476        BOOST_SPIRIT_SSTREAM stream;
477        stream << ID;
478        return std::string("subrule<")
479            + BOOST_SPIRIT_GETSTRING(stream)
480            + std::string(">(")
481            + impl::get_node_registry().find_node(&p)
482            + std::string(")");
483    }
484
485///////////////////////////////////////////////////////////////////////////////
486//  from grammar.hpp
487    template <typename DerivedT, typename ContextT>
488    inline std::string
489    parser_name(grammar<DerivedT, ContextT> const& p)
490    {
491        return std::string("grammar")
492            + std::string("(")
493            + impl::get_node_registry().find_node(&p)
494            + std::string(")");
495    }
496
497///////////////////////////////////////////////////////////////////////////////
498//  decide, if a node is to be traced or not
499    template<
500        typename DerivedT, typename EmbedT, 
501        typename T0, typename T1, typename T2
502    >
503    inline bool
504    trace_parser(impl::rule_base<DerivedT, EmbedT, T0, T1, T2> 
505        const& p)
506    {
507        return impl::get_node_registry().trace_node(&p);
508    }
509
510    template<typename T0, typename T1, typename T2>
511    inline bool
512    trace_parser(rule<T0, T1, T2> const& p)
513    {
514        return impl::get_node_registry().trace_node(&p);
515    }
516
517    template <typename DerivedT, typename ContextT>
518    inline bool
519    trace_parser(grammar<DerivedT, ContextT> const& p)
520    {
521        return impl::get_node_registry().trace_node(&p);
522    }
523
524    template <typename DerivedT, int N, typename ContextT>
525    inline bool
526    trace_parser(impl::entry_grammar<DerivedT, N, ContextT> const& p)
527    {
528        return impl::get_node_registry().trace_node(&p);
529    }
530
531    template <int ID, typename ContextT>
532    bool
533    trace_parser(subrule<ID, ContextT> const& p)
534    {
535        return impl::get_node_registry().trace_node(&p);
536    }
537
538    template <typename ParserT, typename ActorTupleT>
539    bool
540    trace_parser(init_closure_parser<ParserT, ActorTupleT> const& p)
541    {
542        return impl::get_node_registry().trace_node(&p);
543    }
544
545///////////////////////////////////////////////////////////////////////////////
546BOOST_SPIRIT_CLASSIC_NAMESPACE_END
547
548}} // namespace boost::spirit
549
550#undef BOOST_SPIRIT_SSTREAM
551#undef BOOST_SPIRIT_GETSTRING
552
553#endif // defined(BOOST_SPIRIT_DEBUG)
554
555#endif // !defined(BOOST_SPIRIT_PARSER_NAMES_IPP)