PageRenderTime 66ms CodeModel.GetById 17ms app.highlight 45ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/spirit/home/classic/core/primitives/primitives.hpp

http://hadesmem.googlecode.com/
C++ Header | 654 lines | 411 code | 115 blank | 128 comment | 13 complexity | 61cf4e39f2be99f7144b58848fab49cc MD5 | raw file
  1/*=============================================================================
  2    Copyright (c) 1998-2003 Joel de Guzman
  3    Copyright (c) 2003 Martin Wille
  4    http://spirit.sourceforge.net/
  5
  6  Distributed under the Boost Software License, Version 1.0. (See accompanying
  7  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  8=============================================================================*/
  9#if !defined(BOOST_SPIRIT_PRIMITIVES_HPP)
 10#define BOOST_SPIRIT_PRIMITIVES_HPP
 11
 12#include <boost/ref.hpp>
 13#include <boost/spirit/home/classic/namespace.hpp>
 14#include <boost/spirit/home/classic/core/assert.hpp>
 15#include <boost/spirit/home/classic/core/parser.hpp>
 16#include <boost/spirit/home/classic/core/composite/impl/directives.ipp>
 17#include <boost/spirit/home/classic/core/primitives/impl/primitives.ipp>
 18
 19#ifdef BOOST_MSVC
 20#pragma warning (push)
 21#pragma warning(disable : 4512)
 22#endif
 23
 24namespace boost { namespace spirit {
 25
 26BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 27
 28    ///////////////////////////////////////////////////////////////////////////
 29    //
 30    //  char_parser class
 31    //
 32    ///////////////////////////////////////////////////////////////////////////
 33    template <typename DerivedT>
 34    struct char_parser : public parser<DerivedT>
 35    {
 36        typedef DerivedT self_t;
 37        template <typename ScannerT>
 38        struct result
 39        {
 40            typedef typename match_result<
 41                ScannerT,
 42                typename ScannerT::value_t
 43            >::type type;
 44        };
 45
 46        template <typename ScannerT>
 47        typename parser_result<self_t, ScannerT>::type
 48        parse(ScannerT const& scan) const
 49        {
 50            typedef typename parser_result<self_t, ScannerT>::type result_t;
 51            typedef typename ScannerT::value_t value_t;
 52            typedef typename ScannerT::iterator_t iterator_t;
 53
 54            if (!scan.at_end())
 55            {
 56                value_t ch = *scan;
 57                if (this->derived().test(ch))
 58                {
 59                    iterator_t save(scan.first);
 60                    ++scan.first;
 61                    return scan.create_match(1, ch, save, scan.first);
 62                }
 63            }
 64            return scan.no_match();
 65        }
 66    };
 67
 68    ///////////////////////////////////////////////////////////////////////////
 69    //
 70    //  negation of char_parsers
 71    //
 72    ///////////////////////////////////////////////////////////////////////////
 73    template <typename PositiveT>
 74    struct negated_char_parser
 75    : public char_parser<negated_char_parser<PositiveT> >
 76    {
 77        typedef negated_char_parser<PositiveT> self_t;
 78        typedef PositiveT positive_t;
 79
 80        negated_char_parser(positive_t const& p)
 81        : positive(p.derived()) {}
 82
 83        template <typename T>
 84        bool test(T ch) const
 85        {
 86            return !positive.test(ch);
 87        }
 88
 89        positive_t const positive;
 90    };
 91
 92    template <typename ParserT>
 93    inline negated_char_parser<ParserT>
 94    operator~(char_parser<ParserT> const& p)
 95    {
 96        return negated_char_parser<ParserT>(p.derived());
 97    }
 98
 99    template <typename ParserT>
100    inline ParserT
101    operator~(negated_char_parser<ParserT> const& n)
102    {
103        return n.positive;
104    }
105
106    ///////////////////////////////////////////////////////////////////////////
107    //
108    //  chlit class
109    //
110    ///////////////////////////////////////////////////////////////////////////
111    template <typename CharT = char>
112    struct chlit : public char_parser<chlit<CharT> >
113    {
114        chlit(CharT ch_)
115        : ch(ch_) {}
116
117        template <typename T>
118        bool test(T ch_) const
119        {
120            return ch_ == ch;
121        }
122
123        CharT   ch;
124    };
125
126    template <typename CharT>
127    inline chlit<CharT>
128    ch_p(CharT ch)
129    {
130        return chlit<CharT>(ch);
131    }
132
133    // This should take care of ch_p("a") "bugs"
134    template <typename CharT, std::size_t N>
135    inline chlit<CharT>
136    ch_p(CharT const (& str)[N])
137    {
138        //  ch_p's argument should be a single character or a null-terminated
139        //  string with a single character
140        BOOST_STATIC_ASSERT(N < 3);
141        return chlit<CharT>(str[0]);
142    }
143
144    ///////////////////////////////////////////////////////////////////////////
145    //
146    //  range class
147    //
148    ///////////////////////////////////////////////////////////////////////////
149    template <typename CharT = char>
150    struct range : public char_parser<range<CharT> >
151    {
152        range(CharT first_, CharT last_)
153        : first(first_), last(last_)
154        {
155            BOOST_SPIRIT_ASSERT(!(last < first));
156        }
157
158        template <typename T>
159        bool test(T ch) const
160        {
161            return !(CharT(ch) < first) && !(last < CharT(ch));
162        }
163
164        CharT   first;
165        CharT   last;
166    };
167
168    template <typename CharT>
169    inline range<CharT>
170    range_p(CharT first, CharT last)
171    {
172        return range<CharT>(first, last);
173    }
174
175    ///////////////////////////////////////////////////////////////////////////
176    //
177    //  chseq class
178    //
179    ///////////////////////////////////////////////////////////////////////////
180    template <typename IteratorT = char const*>
181    class chseq : public parser<chseq<IteratorT> >
182    {
183    public:
184
185        typedef chseq<IteratorT> self_t;
186
187        chseq(IteratorT first_, IteratorT last_)
188        : first(first_), last(last_) {}
189
190        chseq(IteratorT first_)
191        : first(first_), last(impl::get_last(first_)) {}
192
193        template <typename ScannerT>
194        typename parser_result<self_t, ScannerT>::type
195        parse(ScannerT const& scan) const
196        {
197            typedef typename boost::unwrap_reference<IteratorT>::type striter_t;
198            typedef typename parser_result<self_t, ScannerT>::type result_t;
199            return impl::string_parser_parse<result_t>(
200                striter_t(first),
201                striter_t(last),
202                scan);
203        }
204
205    private:
206
207        IteratorT first;
208        IteratorT last;
209    };
210
211    template <typename CharT>
212    inline chseq<CharT const*>
213    chseq_p(CharT const* str)
214    {
215        return chseq<CharT const*>(str);
216    }
217
218    template <typename IteratorT>
219    inline chseq<IteratorT>
220    chseq_p(IteratorT first, IteratorT last)
221    {
222        return chseq<IteratorT>(first, last);
223    }
224
225    ///////////////////////////////////////////////////////////////////////////
226    //
227    //  strlit class
228    //
229    ///////////////////////////////////////////////////////////////////////////
230    template <typename IteratorT = char const*>
231    class strlit : public parser<strlit<IteratorT> >
232    {
233    public:
234
235        typedef strlit<IteratorT> self_t;
236
237        strlit(IteratorT first, IteratorT last)
238        : seq(first, last) {}
239
240        strlit(IteratorT first)
241        : seq(first) {}
242
243        template <typename ScannerT>
244        typename parser_result<self_t, ScannerT>::type
245        parse(ScannerT const& scan) const
246        {
247            typedef typename parser_result<self_t, ScannerT>::type result_t;
248            return impl::contiguous_parser_parse<result_t>
249                (seq, scan, scan);
250        }
251
252    private:
253
254        chseq<IteratorT> seq;
255    };
256
257    template <typename CharT>
258    inline strlit<CharT const*>
259    str_p(CharT const* str)
260    {
261        return strlit<CharT const*>(str);
262    }
263
264    template <typename CharT>
265    inline strlit<CharT *>
266    str_p(CharT * str)
267    {
268        return strlit<CharT *>(str);
269    }
270
271    template <typename IteratorT>
272    inline strlit<IteratorT>
273    str_p(IteratorT first, IteratorT last)
274    {
275        return strlit<IteratorT>(first, last);
276    }
277
278    // This should take care of str_p('a') "bugs"
279    template <typename CharT>
280    inline chlit<CharT>
281    str_p(CharT ch)
282    {
283        return chlit<CharT>(ch);
284    }
285
286    ///////////////////////////////////////////////////////////////////////////
287    //
288    //  nothing_parser class
289    //
290    ///////////////////////////////////////////////////////////////////////////
291    struct nothing_parser : public parser<nothing_parser>
292    {
293        typedef nothing_parser self_t;
294
295        nothing_parser() {}
296
297        template <typename ScannerT>
298        typename parser_result<self_t, ScannerT>::type
299        parse(ScannerT const& scan) const
300        {
301            return scan.no_match();
302        }
303    };
304
305    nothing_parser const nothing_p = nothing_parser();
306
307    ///////////////////////////////////////////////////////////////////////////
308    //
309    //  anychar_parser class
310    //
311    ///////////////////////////////////////////////////////////////////////////
312    struct anychar_parser : public char_parser<anychar_parser>
313    {
314        typedef anychar_parser self_t;
315
316        anychar_parser() {}
317
318        template <typename CharT>
319        bool test(CharT) const
320        {
321            return true;
322        }
323    };
324
325    anychar_parser const anychar_p = anychar_parser();
326
327    inline nothing_parser
328    operator~(anychar_parser)
329    {
330        return nothing_p;
331    }
332
333    ///////////////////////////////////////////////////////////////////////////
334    //
335    //  alnum_parser class
336    //
337    ///////////////////////////////////////////////////////////////////////////
338    struct alnum_parser : public char_parser<alnum_parser>
339    {
340        typedef alnum_parser self_t;
341
342        alnum_parser() {}
343
344        template <typename CharT>
345        bool test(CharT ch) const
346        {
347            return impl::isalnum_(ch);
348        }
349    };
350
351    alnum_parser const alnum_p = alnum_parser();
352
353    ///////////////////////////////////////////////////////////////////////////
354    //
355    //  alpha_parser class
356    //
357    ///////////////////////////////////////////////////////////////////////////
358    struct alpha_parser : public char_parser<alpha_parser>
359    {
360        typedef alpha_parser self_t;
361
362        alpha_parser() {}
363
364        template <typename CharT>
365        bool test(CharT ch) const
366        {
367            return impl::isalpha_(ch);
368        }
369    };
370
371    alpha_parser const alpha_p = alpha_parser();
372
373    ///////////////////////////////////////////////////////////////////////////
374    //
375    //  cntrl_parser class
376    //
377    ///////////////////////////////////////////////////////////////////////////
378    struct cntrl_parser : public char_parser<cntrl_parser>
379    {
380        typedef cntrl_parser self_t;
381
382        cntrl_parser() {}
383
384        template <typename CharT>
385        bool test(CharT ch) const
386        {
387            return impl::iscntrl_(ch);
388        }
389    };
390
391    cntrl_parser const cntrl_p = cntrl_parser();
392
393    ///////////////////////////////////////////////////////////////////////////
394    //
395    //  digit_parser class
396    //
397    ///////////////////////////////////////////////////////////////////////////
398    struct digit_parser : public char_parser<digit_parser>
399    {
400        typedef digit_parser self_t;
401
402        digit_parser() {}
403
404        template <typename CharT>
405        bool test(CharT ch) const
406        {
407            return impl::isdigit_(ch);
408        }
409    };
410
411    digit_parser const digit_p = digit_parser();
412
413    ///////////////////////////////////////////////////////////////////////////
414    //
415    //  graph_parser class
416    //
417    ///////////////////////////////////////////////////////////////////////////
418    struct graph_parser : public char_parser<graph_parser>
419    {
420        typedef graph_parser self_t;
421
422        graph_parser() {}
423
424        template <typename CharT>
425        bool test(CharT ch) const
426        {
427            return impl::isgraph_(ch);
428        }
429    };
430
431    graph_parser const graph_p = graph_parser();
432
433    ///////////////////////////////////////////////////////////////////////////
434    //
435    //  lower_parser class
436    //
437    ///////////////////////////////////////////////////////////////////////////
438    struct lower_parser : public char_parser<lower_parser>
439    {
440        typedef lower_parser self_t;
441
442        lower_parser() {}
443
444        template <typename CharT>
445        bool test(CharT ch) const
446        {
447            return impl::islower_(ch);
448        }
449    };
450
451    lower_parser const lower_p = lower_parser();
452
453    ///////////////////////////////////////////////////////////////////////////
454    //
455    //  print_parser class
456    //
457    ///////////////////////////////////////////////////////////////////////////
458    struct print_parser : public char_parser<print_parser>
459    {
460        typedef print_parser self_t;
461
462        print_parser() {}
463
464        template <typename CharT>
465        bool test(CharT ch) const
466        {
467            return impl::isprint_(ch);
468        }
469    };
470
471    print_parser const print_p = print_parser();
472
473    ///////////////////////////////////////////////////////////////////////////
474    //
475    //  punct_parser class
476    //
477    ///////////////////////////////////////////////////////////////////////////
478    struct punct_parser : public char_parser<punct_parser>
479    {
480        typedef punct_parser self_t;
481
482        punct_parser() {}
483
484        template <typename CharT>
485        bool test(CharT ch) const
486        {
487            return impl::ispunct_(ch);
488        }
489    };
490
491    punct_parser const punct_p = punct_parser();
492
493    ///////////////////////////////////////////////////////////////////////////
494    //
495    //  blank_parser class
496    //
497    ///////////////////////////////////////////////////////////////////////////
498    struct blank_parser : public char_parser<blank_parser>
499    {
500        typedef blank_parser self_t;
501
502        blank_parser() {}
503
504        template <typename CharT>
505        bool test(CharT ch) const
506        {
507            return impl::isblank_(ch);
508        }
509    };
510
511    blank_parser const blank_p = blank_parser();
512
513    ///////////////////////////////////////////////////////////////////////////
514    //
515    //  space_parser class
516    //
517    ///////////////////////////////////////////////////////////////////////////
518    struct space_parser : public char_parser<space_parser>
519    {
520        typedef space_parser self_t;
521
522        space_parser() {}
523
524        template <typename CharT>
525        bool test(CharT ch) const
526        {
527            return impl::isspace_(ch);
528        }
529    };
530
531    space_parser const space_p = space_parser();
532
533    ///////////////////////////////////////////////////////////////////////////
534    //
535    //  upper_parser class
536    //
537    ///////////////////////////////////////////////////////////////////////////
538    struct upper_parser : public char_parser<upper_parser>
539    {
540        typedef upper_parser self_t;
541
542        upper_parser() {}
543
544        template <typename CharT>
545        bool test(CharT ch) const
546        {
547            return impl::isupper_(ch);
548        }
549    };
550
551    upper_parser const upper_p = upper_parser();
552
553    ///////////////////////////////////////////////////////////////////////////
554    //
555    //  xdigit_parser class
556    //
557    ///////////////////////////////////////////////////////////////////////////
558    struct xdigit_parser : public char_parser<xdigit_parser>
559    {
560        typedef xdigit_parser self_t;
561
562        xdigit_parser() {}
563
564        template <typename CharT>
565        bool test(CharT ch) const
566        {
567            return impl::isxdigit_(ch);
568        }
569    };
570
571    xdigit_parser const xdigit_p = xdigit_parser();
572
573    ///////////////////////////////////////////////////////////////////////////
574    //
575    //  eol_parser class (contributed by Martin Wille)
576    //
577    ///////////////////////////////////////////////////////////////////////////
578    struct eol_parser : public parser<eol_parser>
579    {
580        typedef eol_parser self_t;
581
582        eol_parser() {}
583
584        template <typename ScannerT>
585        typename parser_result<self_t, ScannerT>::type
586        parse(ScannerT const& scan) const
587        {
588            typename ScannerT::iterator_t save = scan.first;
589            std::size_t len = 0;
590
591            if (!scan.at_end() && *scan == '\r')    // CR
592            {
593                ++scan.first;
594                ++len;
595            }
596
597            // Don't call skipper here
598            if (scan.first != scan.last && *scan == '\n')    // LF
599            {
600                ++scan.first;
601                ++len;
602            }
603
604            if (len)
605                return scan.create_match(len, nil_t(), save, scan.first);
606            return scan.no_match();
607        }
608    };
609
610    eol_parser const eol_p = eol_parser();
611
612    ///////////////////////////////////////////////////////////////////////////
613    //
614    //  end_parser class (suggested by Markus Schoepflin)
615    //
616    ///////////////////////////////////////////////////////////////////////////
617    struct end_parser : public parser<end_parser>
618    {
619        typedef end_parser self_t;
620
621        end_parser() {}
622
623        template <typename ScannerT>
624        typename parser_result<self_t, ScannerT>::type
625        parse(ScannerT const& scan) const
626        {
627            if (scan.at_end())
628                return scan.empty_match();
629            return scan.no_match();
630        }
631    };
632
633    end_parser const end_p = end_parser();
634
635    ///////////////////////////////////////////////////////////////////////////
636    //
637    //  the pizza_p parser :-)
638    //
639    ///////////////////////////////////////////////////////////////////////////
640    inline strlit<char const*> const
641    pizza_p(char const* your_favorite_pizza)
642    {
643        return your_favorite_pizza;
644    }
645
646BOOST_SPIRIT_CLASSIC_NAMESPACE_END
647
648}} // namespace BOOST_SPIRIT_CLASSIC_NS
649
650#ifdef BOOST_MSVC
651#pragma warning (pop)
652#endif
653
654#endif