core/primitives/primitives.hpp

0001 /*=============================================================================
0002     Copyright (c) 1998-2003 Joel de Guzman
0003     Copyright (c) 2003 Martin Wille
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_PRIMITIVES_HPP)
0010 #define BOOST_SPIRIT_PRIMITIVES_HPP
0011
0012 #include <boost/ref.hpp>
0013 #include <boost/spirit/home/classic/namespace.hpp>
0014 #include <boost/spirit/home/classic/core/assert.hpp>
0015 #include <boost/spirit/home/classic/core/parser.hpp>
0016 #include <boost/spirit/home/classic/core/composite/impl/directives.ipp>
0017 #include <boost/spirit/home/classic/core/primitives/impl/primitives.ipp>
0018
0019 #ifdef BOOST_MSVC
0020 #pragma warning (push)
0021 #pragma warning(disable : 4512)
0022 #endif
0023
0024 namespace boost { namespace spirit {
0025
0026 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
0027
0028     ///////////////////////////////////////////////////////////////////////////
0029     //
0030     //  char_parser class
0031     //
0032     ///////////////////////////////////////////////////////////////////////////
0033     template <typename DerivedT>
0034     struct char_parser : public parser<DerivedT>
0035     {
0036         typedef DerivedT self_t;
0037         template <typename ScannerT>
0038         struct result
0039         {
0040             typedef typename match_result<
0041                 ScannerT,
0042                 typename ScannerT::value_t
0043             >::type type;
0044         };
0045
0046         template <typename ScannerT>
0047         typename parser_result<self_t, ScannerT>::type
0048         parse(ScannerT const& scan) const
0049         {
0050             typedef typename ScannerT::value_t value_t;
0051             typedef typename ScannerT::iterator_t iterator_t;
0052             typedef scanner_policies<
0053                 no_skipper_iteration_policy<
0054                 BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
0055                 BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
0056                 BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
0057             > policies_t;
0058
0059             if (!scan.at_end())
0060             {
0061                 value_t ch = *scan;
0062                 if (this->derived().test(ch))
0063                 {
0064                     iterator_t save(scan.first);
0065                     ++scan.change_policies(policies_t(scan));
0066                     return scan.create_match(1, ch, save, scan.first);
0067                 }
0068             }
0069             return scan.no_match();
0070         }
0071     };
0072
0073     ///////////////////////////////////////////////////////////////////////////
0074     //
0075     //  negation of char_parsers
0076     //
0077     ///////////////////////////////////////////////////////////////////////////
0078     template <typename PositiveT>
0079     struct negated_char_parser
0080     : public char_parser<negated_char_parser<PositiveT> >
0081     {
0082         typedef negated_char_parser<PositiveT> self_t;
0083         typedef PositiveT positive_t;
0084
0085         negated_char_parser(positive_t const& p)
0086         : positive(p.derived()) {}
0087
0088         template <typename T>
0089         bool test(T ch) const
0090         {
0091             return !positive.test(ch);
0092         }
0093
0094         positive_t const positive;
0095     };
0096
0097     template <typename ParserT>
0098     inline negated_char_parser<ParserT>
0099     operator~(char_parser<ParserT> const& p)
0100     {
0101         return negated_char_parser<ParserT>(p.derived());
0102     }
0103
0104     template <typename ParserT>
0105     inline ParserT
0106     operator~(negated_char_parser<ParserT> const& n)
0107     {
0108         return n.positive;
0109     }
0110
0111     ///////////////////////////////////////////////////////////////////////////
0112     //
0113     //  chlit class
0114     //
0115     ///////////////////////////////////////////////////////////////////////////
0116     template <typename CharT = char>
0117     struct chlit : public char_parser<chlit<CharT> >
0118     {
0119         chlit(CharT ch_)
0120         : ch(ch_) {}
0121
0122         template <typename T>
0123         bool test(T ch_) const
0124         {
0125             return ch_ == ch;
0126         }
0127
0128         CharT   ch;
0129     };
0130
0131     template <typename CharT>
0132     inline chlit<CharT>
0133     ch_p(CharT ch)
0134     {
0135         return chlit<CharT>(ch);
0136     }
0137
0138     // This should take care of ch_p("a") "bugs"
0139     template <typename CharT, std::size_t N>
0140     inline chlit<CharT>
0141     ch_p(CharT const (& str)[N])
0142     {
0143         //  ch_p's argument should be a single character or a null-terminated
0144         //  string with a single character
0145         BOOST_STATIC_ASSERT(N < 3);
0146         return chlit<CharT>(str[0]);
0147     }
0148
0149     ///////////////////////////////////////////////////////////////////////////
0150     //
0151     //  range class
0152     //
0153     ///////////////////////////////////////////////////////////////////////////
0154     template <typename CharT = char>
0155     struct range : public char_parser<range<CharT> >
0156     {
0157         range(CharT first_, CharT last_)
0158         : first(first_), last(last_)
0159         {
0160             BOOST_SPIRIT_ASSERT(!(last < first));
0161         }
0162
0163         template <typename T>
0164         bool test(T ch) const
0165         {
0166             return !(CharT(ch) < first) && !(last < CharT(ch));
0167         }
0168
0169         CharT   first;
0170         CharT   last;
0171     };
0172
0173     template <typename CharT>
0174     inline range<CharT>
0175     range_p(CharT first, CharT last)
0176     {
0177         return range<CharT>(first, last);
0178     }
0179
0180     ///////////////////////////////////////////////////////////////////////////
0181     //
0182     //  chseq class
0183     //
0184     ///////////////////////////////////////////////////////////////////////////
0185     template <typename IteratorT = char const*>
0186     class chseq : public parser<chseq<IteratorT> >
0187     {
0188     public:
0189
0190         typedef chseq<IteratorT> self_t;
0191
0192         chseq(IteratorT first_, IteratorT last_)
0193         : first(first_), last(last_) {}
0194
0195         chseq(IteratorT first_)
0196         : first(first_), last(impl::get_last(first_)) {}
0197
0198         template <typename ScannerT>
0199         typename parser_result<self_t, ScannerT>::type
0200         parse(ScannerT const& scan) const
0201         {
0202             typedef typename boost::unwrap_reference<IteratorT>::type striter_t;
0203             typedef typename parser_result<self_t, ScannerT>::type result_t;
0204             return impl::string_parser_parse<result_t>(
0205                 striter_t(first),
0206                 striter_t(last),
0207                 scan);
0208         }
0209
0210     private:
0211
0212         IteratorT first;
0213         IteratorT last;
0214     };
0215
0216     template <typename CharT>
0217     inline chseq<CharT const*>
0218     chseq_p(CharT const* str)
0219     {
0220         return chseq<CharT const*>(str);
0221     }
0222
0223     template <typename IteratorT>
0224     inline chseq<IteratorT>
0225     chseq_p(IteratorT first, IteratorT last)
0226     {
0227         return chseq<IteratorT>(first, last);
0228     }
0229
0230     ///////////////////////////////////////////////////////////////////////////
0231     //
0232     //  strlit class
0233     //
0234     ///////////////////////////////////////////////////////////////////////////
0235     template <typename IteratorT = char const*>
0236     class strlit : public parser<strlit<IteratorT> >
0237     {
0238     public:
0239
0240         typedef strlit<IteratorT> self_t;
0241
0242         strlit(IteratorT first, IteratorT last)
0243         : seq(first, last) {}
0244
0245         strlit(IteratorT first)
0246         : seq(first) {}
0247
0248         template <typename ScannerT>
0249         typename parser_result<self_t, ScannerT>::type
0250         parse(ScannerT const& scan) const
0251         {
0252             typedef typename parser_result<self_t, ScannerT>::type result_t;
0253             return impl::contiguous_parser_parse<result_t>
0254                 (seq, scan, scan);
0255         }
0256
0257     private:
0258
0259         chseq<IteratorT> seq;
0260     };
0261
0262     template <typename CharT>
0263     inline strlit<CharT const*>
0264     str_p(CharT const* str)
0265     {
0266         return strlit<CharT const*>(str);
0267     }
0268
0269     template <typename CharT>
0270     inline strlit<CharT *>
0271     str_p(CharT * str)
0272     {
0273         return strlit<CharT *>(str);
0274     }
0275
0276     template <typename IteratorT>
0277     inline strlit<IteratorT>
0278     str_p(IteratorT first, IteratorT last)
0279     {
0280         return strlit<IteratorT>(first, last);
0281     }
0282
0283     // This should take care of str_p('a') "bugs"
0284     template <typename CharT>
0285     inline chlit<CharT>
0286     str_p(CharT ch)
0287     {
0288         return chlit<CharT>(ch);
0289     }
0290
0291     ///////////////////////////////////////////////////////////////////////////
0292     //
0293     //  nothing_parser class
0294     //
0295     ///////////////////////////////////////////////////////////////////////////
0296     struct nothing_parser : public parser<nothing_parser>
0297     {
0298         typedef nothing_parser self_t;
0299
0300         nothing_parser() {}
0301
0302         template <typename ScannerT>
0303         typename parser_result<self_t, ScannerT>::type
0304         parse(ScannerT const& scan) const
0305         {
0306             return scan.no_match();
0307         }
0308     };
0309
0310     nothing_parser const nothing_p = nothing_parser();
0311
0312     ///////////////////////////////////////////////////////////////////////////
0313     //
0314     //  anychar_parser class
0315     //
0316     ///////////////////////////////////////////////////////////////////////////
0317     struct anychar_parser : public char_parser<anychar_parser>
0318     {
0319         typedef anychar_parser self_t;
0320
0321         anychar_parser() {}
0322
0323         template <typename CharT>
0324         bool test(CharT) const
0325         {
0326             return true;
0327         }
0328     };
0329
0330     anychar_parser const anychar_p = anychar_parser();
0331
0332     inline nothing_parser
0333     operator~(anychar_parser)
0334     {
0335         return nothing_p;
0336     }
0337
0338     ///////////////////////////////////////////////////////////////////////////
0339     //
0340     //  alnum_parser class
0341     //
0342     ///////////////////////////////////////////////////////////////////////////
0343     struct alnum_parser : public char_parser<alnum_parser>
0344     {
0345         typedef alnum_parser self_t;
0346
0347         alnum_parser() {}
0348
0349         template <typename CharT>
0350         bool test(CharT ch) const
0351         {
0352             return impl::isalnum_(ch);
0353         }
0354     };
0355
0356     alnum_parser const alnum_p = alnum_parser();
0357
0358     ///////////////////////////////////////////////////////////////////////////
0359     //
0360     //  alpha_parser class
0361     //
0362     ///////////////////////////////////////////////////////////////////////////
0363     struct alpha_parser : public char_parser<alpha_parser>
0364     {
0365         typedef alpha_parser self_t;
0366
0367         alpha_parser() {}
0368
0369         template <typename CharT>
0370         bool test(CharT ch) const
0371         {
0372             return impl::isalpha_(ch);
0373         }
0374     };
0375
0376     alpha_parser const alpha_p = alpha_parser();
0377
0378     ///////////////////////////////////////////////////////////////////////////
0379     //
0380     //  cntrl_parser class
0381     //
0382     ///////////////////////////////////////////////////////////////////////////
0383     struct cntrl_parser : public char_parser<cntrl_parser>
0384     {
0385         typedef cntrl_parser self_t;
0386
0387         cntrl_parser() {}
0388
0389         template <typename CharT>
0390         bool test(CharT ch) const
0391         {
0392             return impl::iscntrl_(ch);
0393         }
0394     };
0395
0396     cntrl_parser const cntrl_p = cntrl_parser();
0397
0398     ///////////////////////////////////////////////////////////////////////////
0399     //
0400     //  digit_parser class
0401     //
0402     ///////////////////////////////////////////////////////////////////////////
0403     struct digit_parser : public char_parser<digit_parser>
0404     {
0405         typedef digit_parser self_t;
0406
0407         digit_parser() {}
0408
0409         template <typename CharT>
0410         bool test(CharT ch) const
0411         {
0412             return impl::isdigit_(ch);
0413         }
0414     };
0415
0416     digit_parser const digit_p = digit_parser();
0417
0418     ///////////////////////////////////////////////////////////////////////////
0419     //
0420     //  graph_parser class
0421     //
0422     ///////////////////////////////////////////////////////////////////////////
0423     struct graph_parser : public char_parser<graph_parser>
0424     {
0425         typedef graph_parser self_t;
0426
0427         graph_parser() {}
0428
0429         template <typename CharT>
0430         bool test(CharT ch) const
0431         {
0432             return impl::isgraph_(ch);
0433         }
0434     };
0435
0436     graph_parser const graph_p = graph_parser();
0437
0438     ///////////////////////////////////////////////////////////////////////////
0439     //
0440     //  lower_parser class
0441     //
0442     ///////////////////////////////////////////////////////////////////////////
0443     struct lower_parser : public char_parser<lower_parser>
0444     {
0445         typedef lower_parser self_t;
0446
0447         lower_parser() {}
0448
0449         template <typename CharT>
0450         bool test(CharT ch) const
0451         {
0452             return impl::islower_(ch);
0453         }
0454     };
0455
0456     lower_parser const lower_p = lower_parser();
0457
0458     ///////////////////////////////////////////////////////////////////////////
0459     //
0460     //  print_parser class
0461     //
0462     ///////////////////////////////////////////////////////////////////////////
0463     struct print_parser : public char_parser<print_parser>
0464     {
0465         typedef print_parser self_t;
0466
0467         print_parser() {}
0468
0469         template <typename CharT>
0470         bool test(CharT ch) const
0471         {
0472             return impl::isprint_(ch);
0473         }
0474     };
0475
0476     print_parser const print_p = print_parser();
0477
0478     ///////////////////////////////////////////////////////////////////////////
0479     //
0480     //  punct_parser class
0481     //
0482     ///////////////////////////////////////////////////////////////////////////
0483     struct punct_parser : public char_parser<punct_parser>
0484     {
0485         typedef punct_parser self_t;
0486
0487         punct_parser() {}
0488
0489         template <typename CharT>
0490         bool test(CharT ch) const
0491         {
0492             return impl::ispunct_(ch);
0493         }
0494     };
0495
0496     punct_parser const punct_p = punct_parser();
0497
0498     ///////////////////////////////////////////////////////////////////////////
0499     //
0500     //  blank_parser class
0501     //
0502     ///////////////////////////////////////////////////////////////////////////
0503     struct blank_parser : public char_parser<blank_parser>
0504     {
0505         typedef blank_parser self_t;
0506
0507         blank_parser() {}
0508
0509         template <typename CharT>
0510         bool test(CharT ch) const
0511         {
0512             return impl::isblank_(ch);
0513         }
0514     };
0515
0516     blank_parser const blank_p = blank_parser();
0517
0518     ///////////////////////////////////////////////////////////////////////////
0519     //
0520     //  space_parser class
0521     //
0522     ///////////////////////////////////////////////////////////////////////////
0523     struct space_parser : public char_parser<space_parser>
0524     {
0525         typedef space_parser self_t;
0526
0527         space_parser() {}
0528
0529         template <typename CharT>
0530         bool test(CharT ch) const
0531         {
0532             return impl::isspace_(ch);
0533         }
0534     };
0535
0536     space_parser const space_p = space_parser();
0537
0538     ///////////////////////////////////////////////////////////////////////////
0539     //
0540     //  upper_parser class
0541     //
0542     ///////////////////////////////////////////////////////////////////////////
0543     struct upper_parser : public char_parser<upper_parser>
0544     {
0545         typedef upper_parser self_t;
0546
0547         upper_parser() {}
0548
0549         template <typename CharT>
0550         bool test(CharT ch) const
0551         {
0552             return impl::isupper_(ch);
0553         }
0554     };
0555
0556     upper_parser const upper_p = upper_parser();
0557
0558     ///////////////////////////////////////////////////////////////////////////
0559     //
0560     //  xdigit_parser class
0561     //
0562     ///////////////////////////////////////////////////////////////////////////
0563     struct xdigit_parser : public char_parser<xdigit_parser>
0564     {
0565         typedef xdigit_parser self_t;
0566
0567         xdigit_parser() {}
0568
0569         template <typename CharT>
0570         bool test(CharT ch) const
0571         {
0572             return impl::isxdigit_(ch);
0573         }
0574     };
0575
0576     xdigit_parser const xdigit_p = xdigit_parser();
0577
0578     ///////////////////////////////////////////////////////////////////////////
0579     //
0580     //  eol_parser class (contributed by Martin Wille)
0581     //
0582     ///////////////////////////////////////////////////////////////////////////
0583     struct eol_parser : public parser<eol_parser>
0584     {
0585         typedef eol_parser self_t;
0586
0587         eol_parser() {}
0588
0589         template <typename ScannerT>
0590         typename parser_result<self_t, ScannerT>::type
0591         parse(ScannerT const& scan) const
0592         {
0593             typedef scanner_policies<
0594                 no_skipper_iteration_policy<
0595                 BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
0596                 BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
0597                 BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
0598             > policies_t;
0599
0600             typename ScannerT::iterator_t save = scan.first;
0601             std::size_t len = 0;
0602
0603             if (!scan.at_end() && *scan == '\r')    // CR
0604             {
0605                 ++scan.change_policies(policies_t(scan));
0606                 ++len;
0607             }
0608
0609             // Don't call skipper here
0610             if (scan.first != scan.last && *scan == '\n')    // LF
0611             {
0612                 ++scan.change_policies(policies_t(scan));
0613                 ++len;
0614             }
0615
0616             if (len)
0617                 return scan.create_match(len, nil_t(), save, scan.first);
0618             return scan.no_match();
0619         }
0620     };
0621
0622     eol_parser const eol_p = eol_parser();
0623
0624     ///////////////////////////////////////////////////////////////////////////
0625     //
0626     //  end_parser class (suggested by Markus Schoepflin)
0627     //
0628     ///////////////////////////////////////////////////////////////////////////
0629     struct end_parser : public parser<end_parser>
0630     {
0631         typedef end_parser self_t;
0632
0633         end_parser() {}
0634
0635         template <typename ScannerT>
0636         typename parser_result<self_t, ScannerT>::type
0637         parse(ScannerT const& scan) const
0638         {
0639             if (scan.at_end())
0640                 return scan.empty_match();
0641             return scan.no_match();
0642         }
0643     };
0644
0645     end_parser const end_p = end_parser();
0646
0647     ///////////////////////////////////////////////////////////////////////////
0648     //
0649     //  the pizza_p parser :-)
0650     //
0651     ///////////////////////////////////////////////////////////////////////////
0652     inline strlit<char const*> const
0653     pizza_p(char const* your_favorite_pizza)
0654     {
0655         return your_favorite_pizza;
0656     }
0657
0658 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
0659
0660 }} // namespace BOOST_SPIRIT_CLASSIC_NS
0661
0662 #ifdef BOOST_MSVC
0663 #pragma warning (pop)
0664 #endif
0665
0666 #endif