primitives/impl/primitives.ipp

0001 /*=============================================================================
0002     Copyright (c) 1998-2003 Joel de Guzman
0003     Copyright (c) 2003 Martin Wille
0004     http://spirit.sourceforge.net/
0005
0006     Use, modification and distribution is subject to the Boost Software
0007     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
0008     http://www.boost.org/LICENSE_1_0.txt)
0009 =============================================================================*/
0010 #if !defined(BOOST_SPIRIT_PRIMITIVES_IPP)
0011 #define BOOST_SPIRIT_PRIMITIVES_IPP
0012
0013 #include <cctype>
0014 #if !defined(BOOST_NO_CWCTYPE)
0015 #include <cwctype>
0016 #endif
0017
0018 #include <string> // char_traits
0019
0020 #if defined(BOOST_MSVC)
0021 #  pragma warning (push)
0022 #  pragma warning(disable:4800)
0023 #endif
0024
0025 namespace boost { namespace spirit {
0026
0027 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
0028
0029     template <typename DrivedT> struct char_parser;
0030
0031     namespace impl
0032     {
0033         template <typename IteratorT>
0034         inline IteratorT
0035         get_last(IteratorT first)
0036         {
0037             while (*first)
0038                 first++;
0039             return first;
0040         }
0041
0042         template<
0043             typename RT,
0044             typename IteratorT,
0045             typename ScannerT>
0046         inline RT
0047         string_parser_parse(
0048             IteratorT str_first,
0049             IteratorT str_last,
0050             ScannerT& scan)
0051         {
0052             typedef typename ScannerT::iterator_t iterator_t;
0053             iterator_t saved = scan.first;
0054             std::size_t slen = str_last - str_first;
0055
0056             while (str_first != str_last)
0057             {
0058                 if (scan.at_end() || (*str_first != *scan))
0059                     return scan.no_match();
0060                 ++str_first;
0061                 ++scan;
0062             }
0063
0064             return scan.create_match(slen, nil_t(), saved, scan.first);
0065         }
0066
0067     ///////////////////////////////////////////////////////////////////////////
0068     //
0069     // Conversion from char_type to int_type
0070     //
0071     ///////////////////////////////////////////////////////////////////////////
0072
0073         //  Use char_traits for char and wchar_t only, as these are the only
0074         //  specializations provided in the standard. Other types are on their
0075         //  own.
0076         //
0077         //  For UDT, one may override:
0078         //
0079         //      isalnum
0080         //      isalpha
0081         //      iscntrl
0082         //      isdigit
0083         //      isgraph
0084         //      islower
0085         //      isprint
0086         //      ispunct
0087         //      isspace
0088         //      isupper
0089         //      isxdigit
0090         //      isblank
0091         //      isupper
0092         //      tolower
0093         //      toupper
0094         //
0095         //  in a namespace suitable for Argument Dependent lookup or in
0096         //  namespace std (disallowed by the standard).
0097
0098         template <typename CharT>
0099         struct char_type_char_traits_helper
0100         {
0101             typedef CharT char_type;
0102             typedef typename std::char_traits<CharT>::int_type int_type;
0103
0104             static int_type to_int_type(CharT c)
0105             {
0106                 return std::char_traits<CharT>::to_int_type(c);
0107             }
0108
0109             static char_type to_char_type(int_type i)
0110             {
0111                 return std::char_traits<CharT>::to_char_type(i);
0112             }
0113         };
0114
0115         template <typename CharT>
0116         struct char_traits_helper
0117         {
0118             typedef CharT char_type;
0119             typedef CharT int_type;
0120
0121             static CharT & to_int_type(CharT & c)
0122             {
0123                 return c;
0124             }
0125
0126             static CharT & to_char_type(CharT & c)
0127             {
0128                 return c;
0129             }
0130         };
0131
0132         template <>
0133         struct char_traits_helper<char>
0134             : char_type_char_traits_helper<char>
0135         {
0136         };
0137
0138 #if !defined(BOOST_NO_CWCTYPE)
0139
0140         template <>
0141         struct char_traits_helper<wchar_t>
0142             : char_type_char_traits_helper<wchar_t>
0143         {
0144         };
0145
0146 #endif
0147
0148         template <typename CharT>
0149         inline typename char_traits_helper<CharT>::int_type
0150         to_int_type(CharT c)
0151         {
0152             return char_traits_helper<CharT>::to_int_type(c);
0153         }
0154
0155         template <typename CharT>
0156         inline CharT
0157         to_char_type(typename char_traits_helper<CharT>::int_type c)
0158         {
0159             return char_traits_helper<CharT>::to_char_type(c);
0160         }
0161
0162         ///////////////////////////////////////////////////////////////////////
0163         //
0164         //  Convenience functions
0165         //
0166         ///////////////////////////////////////////////////////////////////////
0167
0168         template <typename CharT>
0169         inline bool
0170         isalnum_(CharT c)
0171         {
0172             using namespace std;
0173             return isalnum(to_int_type(c)) ? true : false;
0174         }
0175
0176         template <typename CharT>
0177         inline bool
0178         isalpha_(CharT c)
0179         {
0180             using namespace std;
0181             return isalpha(to_int_type(c)) ? true : false;
0182         }
0183
0184         template <typename CharT>
0185         inline bool
0186         iscntrl_(CharT c)
0187         {
0188             using namespace std;
0189             return iscntrl(to_int_type(c)) ? true : false;
0190         }
0191
0192         template <typename CharT>
0193         inline bool
0194         isdigit_(CharT c)
0195         {
0196             using namespace std;
0197             return isdigit(to_int_type(c)) ? true : false;
0198         }
0199
0200         template <typename CharT>
0201         inline bool
0202         isgraph_(CharT c)
0203         {
0204             using namespace std;
0205             return isgraph(to_int_type(c)) ? true : false;
0206         }
0207
0208         template <typename CharT>
0209         inline bool
0210         islower_(CharT c)
0211         {
0212             using namespace std;
0213             return islower(to_int_type(c)) ? true : false;
0214         }
0215
0216         template <typename CharT>
0217         inline bool
0218         isprint_(CharT c)
0219         {
0220             using namespace std;
0221             return isprint(to_int_type(c)) ? true : false;
0222         }
0223
0224         template <typename CharT>
0225         inline bool
0226         ispunct_(CharT c)
0227         {
0228             using namespace std;
0229             return ispunct(to_int_type(c)) ? true : false;
0230         }
0231
0232         template <typename CharT>
0233         inline bool
0234         isspace_(CharT c)
0235         {
0236             using namespace std;
0237             return isspace(to_int_type(c)) ? true : false;
0238         }
0239
0240         template <typename CharT>
0241         inline bool
0242         isupper_(CharT c)
0243         {
0244             using namespace std;
0245             return isupper(to_int_type(c)) ? true : false;
0246         }
0247
0248         template <typename CharT>
0249         inline bool
0250         isxdigit_(CharT c)
0251         {
0252             using namespace std;
0253             return isxdigit(to_int_type(c)) ? true : false;
0254         }
0255
0256         template <typename CharT>
0257         inline bool
0258         isblank_(CharT c)
0259         {
0260             return (c == ' ' || c == '\t');
0261         }
0262
0263         template <typename CharT>
0264         inline CharT
0265         tolower_(CharT c)
0266         {
0267             using namespace std;
0268             return to_char_type<CharT>(tolower(to_int_type(c)));
0269         }
0270
0271         template <typename CharT>
0272         inline CharT
0273         toupper_(CharT c)
0274         {
0275             using namespace std;
0276             return to_char_type<CharT>(toupper(to_int_type(c)));
0277         }
0278
0279 #if !defined(BOOST_NO_CWCTYPE)
0280
0281         inline bool
0282         isalnum_(wchar_t c)
0283         {
0284             using namespace std;
0285             return iswalnum(to_int_type(c)) ? true : false;
0286         }
0287
0288         inline bool
0289         isalpha_(wchar_t c)
0290         {
0291             using namespace std;
0292             return iswalpha(to_int_type(c)) ? true : false;
0293         }
0294
0295         inline bool
0296         iscntrl_(wchar_t c)
0297         {
0298             using namespace std;
0299             return iswcntrl(to_int_type(c)) ? true : false;
0300         }
0301
0302         inline bool
0303         isdigit_(wchar_t c)
0304         {
0305             using namespace std;
0306             return iswdigit(to_int_type(c)) ? true : false;
0307         }
0308
0309         inline bool
0310         isgraph_(wchar_t c)
0311         {
0312             using namespace std;
0313             return iswgraph(to_int_type(c)) ? true : false;
0314         }
0315
0316         inline bool
0317         islower_(wchar_t c)
0318         {
0319             using namespace std;
0320             return iswlower(to_int_type(c)) ? true : false;
0321         }
0322
0323         inline bool
0324         isprint_(wchar_t c)
0325         {
0326             using namespace std;
0327             return iswprint(to_int_type(c)) ? true : false;
0328         }
0329
0330         inline bool
0331         ispunct_(wchar_t c)
0332         {
0333             using namespace std;
0334             return iswpunct(to_int_type(c)) ? true : false;
0335         }
0336
0337         inline bool
0338         isspace_(wchar_t c)
0339         {
0340             using namespace std;
0341             return iswspace(to_int_type(c)) ? true : false;
0342         }
0343
0344         inline bool
0345         isupper_(wchar_t c)
0346         {
0347             using namespace std;
0348             return iswupper(to_int_type(c)) ? true : false;
0349         }
0350
0351         inline bool
0352         isxdigit_(wchar_t c)
0353         {
0354             using namespace std;
0355             return iswxdigit(to_int_type(c)) ? true : false;
0356         }
0357
0358         inline bool
0359         isblank_(wchar_t c)
0360         {
0361             return (c == L' ' || c == L'\t');
0362         }
0363
0364         inline wchar_t
0365         tolower_(wchar_t c)
0366         {
0367             using namespace std;
0368             return to_char_type<wchar_t>(towlower(to_int_type(c)));
0369         }
0370
0371         inline wchar_t
0372         toupper_(wchar_t c)
0373         {
0374             using namespace std;
0375             return to_char_type<wchar_t>(towupper(to_int_type(c)));
0376         }
0377
0378         inline bool
0379         isblank_(bool)
0380         {
0381             return false;
0382         }
0383
0384 #endif // !defined(BOOST_NO_CWCTYPE)
0385
0386 }
0387
0388 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
0389
0390 }} // namespace boost::spirit::impl
0391
0392 #ifdef BOOST_MSVC
0393 #pragma warning (pop)
0394 #endif
0395
0396 #endif